diff --git a/README.md b/README.md index 7f2d6ea0..8f3275c3 100644 --- a/README.md +++ b/README.md @@ -3,12 +3,26 @@ ![Image of Flex the T-Rex](./assets/flex.png) + ## Why the Tableau Extensions API? -The Extensions API lets you do more without leaving Tableau. Build Tableau extensions that can interact and communicate with Tableau, and embed them directly in your workbooks. + +The Extensions API lets you do more without leaving Tableau. Build Tableau dashboard and viz extensions that can interact and communicate with Tableau, and embed them directly in your workbooks. + +* Build viz extensions to create new viz types that Tableau users can access through the worksheet Marks card. + + + + + +* Build dashboard extensions to add new features and functionality to Tableau that users can access through the dashboard. + + + ## Setup and Running Samples ### Prerequisites + * You must have Node.js and npm installed. You can get these from [https://nodejs.org](https://nodejs.org). ### Install Extensions API SDK Components and Start Server @@ -27,13 +41,14 @@ The Extensions API lets you do more without leaving Tableau. Build Tableau exten **npm start** -5. Launch Tableau and try the sample extensions in a dashboard. The samples are located in the `Samples` folder. +5. Launch Tableau and try a dashboard sample extension in a dashboard, or a viz extension in a worksheet. The dashboard and viz extension samples are located in the `Samples` folder. - >**Note** The local web server you start just serves to host the extension samples and extensions used in the tutorial, which have URLs similar to the following: `http://localhost:8765/Samples/DataSources/datasources.html` or `http://localhost:8765/Samples-Typescript/DataSources/datasources.html` - > This local web server is not intended to serve the Extensions API Help pages. + >**Note** The local web server you start just serves to host the extension samples and tutorial. These extensions have URLs similar to the following: `http://localhost:8765/Samples/Dashboard/DataSources/datasources.html`. + > This local web server is not intended to serve the Extensions API Help pages. > View the Help on GitHub at [https://tableau.github.io/extensions-api](https://tableau.github.io/extensions-api). ### Typescript Development + Samples written in Typescript are located in the `Samples-Typescript` folder. If you want to use TypeScript to write your extensions, you can run a script that starts up the HTTP server and actively listens for changes to the `.ts` files located in the `Samples-Typescript` folder. You can then add your extension to the folder and use the script to transpile your extension to JavaScript. @@ -41,7 +56,7 @@ If you want to use TypeScript to write your extensions, you can run a script tha **npm run dev** -For more information, see [Use TypeScript with the Extensions API](https://tableau.github.io/extensions-api/docs/trex_typescript.html). +For more information, see [Use TypeScript with the Extensions API](https://tableau.github.io/extensions-api/docs/core/trex_typescript). ### Sandboxed Extension Development Environment @@ -51,18 +66,19 @@ Tableau is introducing development support for Sandboxed Extensions with Tableau **npm run start-sandbox** -2. Launch Tableau (Tableau 2019.3 and later) and try the sample Sandboxed Extension in a dashboard. You can find the `.trex` file and sample code in the `Samples\UINamespace-sandboxed` folder. +2. Launch Tableau (Tableau 2019.3 and later) and try the sample Sandboxed dashboard extension in a dashboard. You can find the `.trex` file and sample code in the `Samples\Dashboard\UINamespace-sandboxed` folder. -For more information, see [Create and Test Sandboxed Extensions](https://tableau.github.io/extensions-api/docs/trex_sandbox_test.html). +For more information, see [Create and Test Sandboxed Extensions](https://tableau.github.io/extensions-api/docs/security/trex_sandbox_test). ## Contributions + Contributions and improvements by the community are welcomed! See the LICENSE file for current open-source licensing and use information. Before we can accept pull requests from contributors, we require a signed [Contributor License Agreement (CLA)](https://tableau.github.io/contributing.html). To submit a contribution, please fork the repository then submit a pull request to the `main` branch. ## Code Style -Our sample code follows the [Semi-Standard Style](https://github.com/Flet/semistandard) for JavaScript samples linting and [tslint](https://palantir.github.io/tslint/) for TypeScript. If you add your own extension code to the Samples or Samples-Typescript directories, you can run `npm run lint` to validate the style of your code. Please run this command before submitting any pull requests for Sample code. +Our sample code follows the [Semi-Standard Style](https://github.com/Flet/semistandard) for JavaScript samples linting and [tslint](https://palantir.github.io/tslint/) for TypeScript. If you add your own extension code to the Samples or Samples-Typescript directories, you can run `npm run lint` to validate the style of your code. Please run this command before submitting any pull requests for Sample code. `npx semistandard --fix` to fix linting issues which can be fixed automatically. diff --git a/Samples-Typescript/Annotation/Annotation.trex b/Samples-Typescript/Dashboard/Annotation/Annotation.trex similarity index 97% rename from Samples-Typescript/Annotation/Annotation.trex rename to Samples-Typescript/Dashboard/Annotation/Annotation.trex index 1d1b4b78..ba39183a 100644 --- a/Samples-Typescript/Annotation/Annotation.trex +++ b/Samples-Typescript/Dashboard/Annotation/Annotation.trex @@ -7,7 +7,7 @@ 1.10 - http://localhost:8765/Samples-Typescript/Annotation/annotation.html + http://localhost:8765/Samples-Typescript/Dashboard/Annotation/annotation.html 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 diff --git a/Samples-Typescript/Annotation/annotation.html b/Samples-Typescript/Dashboard/Annotation/annotation.html similarity index 87% rename from Samples-Typescript/Annotation/annotation.html rename to Samples-Typescript/Dashboard/Annotation/annotation.html index 6a014b0a..403f4efc 100644 --- a/Samples-Typescript/Annotation/annotation.html +++ b/Samples-Typescript/Dashboard/Annotation/annotation.html @@ -10,10 +10,10 @@ - + - +
diff --git a/Samples-Typescript/Annotation/annotation.ts b/Samples-Typescript/Dashboard/Annotation/annotation.ts similarity index 100% rename from Samples-Typescript/Annotation/annotation.ts rename to Samples-Typescript/Dashboard/Annotation/annotation.ts diff --git a/Samples-Typescript/DashboardLayout/DashboardLayout.trex b/Samples-Typescript/Dashboard/DashboardLayout/DashboardLayout.trex similarity index 96% rename from Samples-Typescript/DashboardLayout/DashboardLayout.trex rename to Samples-Typescript/Dashboard/DashboardLayout/DashboardLayout.trex index 39b11050..14085265 100644 --- a/Samples-Typescript/DashboardLayout/DashboardLayout.trex +++ b/Samples-Typescript/Dashboard/DashboardLayout/DashboardLayout.trex @@ -7,7 +7,7 @@ 1.7 - http://localhost:8765/Samples-Typescript/DashboardLayout/dashboardLayout.html + http://localhost:8765/Samples-Typescript/Dashboard/DashboardLayout/dashboardLayout.html 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 diff --git a/Samples-Typescript/DashboardLayout/dashboardLayout.html b/Samples-Typescript/Dashboard/DashboardLayout/dashboardLayout.html similarity index 86% rename from Samples-Typescript/DashboardLayout/dashboardLayout.html rename to Samples-Typescript/Dashboard/DashboardLayout/dashboardLayout.html index c2253baa..4e2b95c0 100644 --- a/Samples-Typescript/DashboardLayout/dashboardLayout.html +++ b/Samples-Typescript/Dashboard/DashboardLayout/dashboardLayout.html @@ -10,10 +10,10 @@ - + - +
diff --git a/Samples-Typescript/DashboardLayout/dashboardLayout.ts b/Samples-Typescript/Dashboard/DashboardLayout/dashboardLayout.ts similarity index 100% rename from Samples-Typescript/DashboardLayout/dashboardLayout.ts rename to Samples-Typescript/Dashboard/DashboardLayout/dashboardLayout.ts diff --git a/Samples-Typescript/DashboardObjectVisibility/DashboardObjectVisibility.trex b/Samples-Typescript/Dashboard/DashboardObjectVisibility/DashboardObjectVisibility.trex similarity index 96% rename from Samples-Typescript/DashboardObjectVisibility/DashboardObjectVisibility.trex rename to Samples-Typescript/Dashboard/DashboardObjectVisibility/DashboardObjectVisibility.trex index 14c8c3b8..d1b02e8c 100644 --- a/Samples-Typescript/DashboardObjectVisibility/DashboardObjectVisibility.trex +++ b/Samples-Typescript/Dashboard/DashboardObjectVisibility/DashboardObjectVisibility.trex @@ -7,7 +7,7 @@ 1.7 - http://localhost:8765/Samples-Typescript/DashboardObjectVisibility/dashboardObjectVisibility.html + http://localhost:8765/Samples-Typescript/Dashboard/DashboardObjectVisibility/dashboardObjectVisibility.html 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 diff --git a/Samples-Typescript/DashboardObjectVisibility/dashboardObjectVisibility.html b/Samples-Typescript/Dashboard/DashboardObjectVisibility/dashboardObjectVisibility.html similarity index 82% rename from Samples-Typescript/DashboardObjectVisibility/dashboardObjectVisibility.html rename to Samples-Typescript/Dashboard/DashboardObjectVisibility/dashboardObjectVisibility.html index 778d911e..0364caaa 100644 --- a/Samples-Typescript/DashboardObjectVisibility/dashboardObjectVisibility.html +++ b/Samples-Typescript/Dashboard/DashboardObjectVisibility/dashboardObjectVisibility.html @@ -9,10 +9,10 @@ - + - +
diff --git a/Samples-Typescript/DashboardObjectVisibility/dashboardObjectVisibility.tsx b/Samples-Typescript/Dashboard/DashboardObjectVisibility/dashboardObjectVisibility.tsx similarity index 100% rename from Samples-Typescript/DashboardObjectVisibility/dashboardObjectVisibility.tsx rename to Samples-Typescript/Dashboard/DashboardObjectVisibility/dashboardObjectVisibility.tsx diff --git a/Samples-Typescript/DataSources/DataSources.trex b/Samples-Typescript/Dashboard/DataSources/DataSources.trex similarity index 94% rename from Samples-Typescript/DataSources/DataSources.trex rename to Samples-Typescript/Dashboard/DataSources/DataSources.trex index 1bbdf172..18d89ee4 100644 --- a/Samples-Typescript/DataSources/DataSources.trex +++ b/Samples-Typescript/Dashboard/DataSources/DataSources.trex @@ -7,7 +7,7 @@ 0.8 - http://localhost:8765/Samples-Typescript/DataSources/datasources.html + http://localhost:8765/Samples-Typescript/Dashboard/DataSources/datasources.html iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAlhJREFUOI2Nkt9vy1EYh5/3bbsvRSySCZbIxI+ZCKsN2TKtSFyIrV2WuRCJuBiJWxfuxCVXbvwFgiEtposgLFJElnbU1SxIZIIRJDKTrdu+53Uhra4mce7Oe57Pcz7JOULFisViwZ+29LAzOSjQYDgz1ZcCvWuXV11MJpN+OS/lm6179teqH0yDqxPTCyKSA8DcDsyOmOprnCaeP7459pdgy969i0LTC3IO/RQMyoHcQN+3cnljW3dNIFC47qDaK3g7BwdTkwBaBELT4ZPOUVWgKl4ZBnjxJPUlMDnTDrp0pmr6RHFeEjjcUUXPDGeSEwDN0Xg8sivxMhJNjGzbHd8PkM3eHRfkrBM5NkcQaY2vUnTlrDIA0NoaX+KLXFFlowr14tvVpqb2MICzmQcKqxvbumv+NAhZGCCIPwEw6QWXKYRL/VUXO0+rAUJiPwAk5MIlgVfwPjjHLCL1APmHN94ZdqeYN+NW/mn6I4BvwQYchcLnwFhJMDiYmlRxAzjpKWZkYkUCcZ2I61wi37tLbYyjiN0fHk5Oz3nGSLSzBbNHCF35R7f6K1/hN9PRhek11FrymfQQQKB4+Gl05P2qNRtmETlXW7e+b2z01dfycGNbfFMAbqNyKp9Jp4rzOT8RYFs0njJkc2iqsCObvTsOsDWWqA5C1uFy+Uz/oXJeKwVT4h0RmPUXhi79vuC0Ku6yOffTK3g9lfxfDQAisY516sg5kfOCiJk7HoLt2cf9b/9LANAc7dznm98PagG1fUOZ9IP5uMB8Q4CPoyNvausapkTt3rNMuvdf3C/o6+czhtdwmwAAAABJRU5ErkJggg== diff --git a/Samples-Typescript/DataSources/datasources.html b/Samples-Typescript/Dashboard/DataSources/datasources.html similarity index 96% rename from Samples-Typescript/DataSources/datasources.html rename to Samples-Typescript/Dashboard/DataSources/datasources.html index 1179cafc..3a8a1126 100644 --- a/Samples-Typescript/DataSources/datasources.html +++ b/Samples-Typescript/Dashboard/DataSources/datasources.html @@ -15,10 +15,10 @@ - + - +
diff --git a/Samples-Typescript/DataSources/datasources.ts b/Samples-Typescript/Dashboard/DataSources/datasources.ts similarity index 100% rename from Samples-Typescript/DataSources/datasources.ts rename to Samples-Typescript/Dashboard/DataSources/datasources.ts diff --git a/Samples-Typescript/Filtering/Filtering.trex b/Samples-Typescript/Dashboard/Filtering/Filtering.trex similarity index 94% rename from Samples-Typescript/Filtering/Filtering.trex rename to Samples-Typescript/Dashboard/Filtering/Filtering.trex index e724c05e..a3286e95 100644 --- a/Samples-Typescript/Filtering/Filtering.trex +++ b/Samples-Typescript/Dashboard/Filtering/Filtering.trex @@ -7,7 +7,7 @@ 0.8 - http://localhost:8765/Samples-Typescript/Filtering/filtering.html + http://localhost:8765/Samples-Typescript/Dashboard/Filtering/filtering.html iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAlhJREFUOI2Nkt9vy1EYh5/3bbsvRSySCZbIxI+ZCKsN2TKtSFyIrV2WuRCJuBiJWxfuxCVXbvwFgiEtposgLFJElnbU1SxIZIIRJDKTrdu+53Uhra4mce7Oe57Pcz7JOULFisViwZ+29LAzOSjQYDgz1ZcCvWuXV11MJpN+OS/lm6179teqH0yDqxPTCyKSA8DcDsyOmOprnCaeP7459pdgy969i0LTC3IO/RQMyoHcQN+3cnljW3dNIFC47qDaK3g7BwdTkwBaBELT4ZPOUVWgKl4ZBnjxJPUlMDnTDrp0pmr6RHFeEjjcUUXPDGeSEwDN0Xg8sivxMhJNjGzbHd8PkM3eHRfkrBM5NkcQaY2vUnTlrDIA0NoaX+KLXFFlowr14tvVpqb2MICzmQcKqxvbumv+NAhZGCCIPwEw6QWXKYRL/VUXO0+rAUJiPwAk5MIlgVfwPjjHLCL1APmHN94ZdqeYN+NW/mn6I4BvwQYchcLnwFhJMDiYmlRxAzjpKWZkYkUCcZ2I61wi37tLbYyjiN0fHk5Oz3nGSLSzBbNHCF35R7f6K1/hN9PRhek11FrymfQQQKB4+Gl05P2qNRtmETlXW7e+b2z01dfycGNbfFMAbqNyKp9Jp4rzOT8RYFs0njJkc2iqsCObvTsOsDWWqA5C1uFy+Uz/oXJeKwVT4h0RmPUXhi79vuC0Ku6yOffTK3g9lfxfDQAisY516sg5kfOCiJk7HoLt2cf9b/9LANAc7dznm98PagG1fUOZ9IP5uMB8Q4CPoyNvausapkTt3rNMuvdf3C/o6+czhtdwmwAAAABJRU5ErkJggg== diff --git a/Samples-Typescript/Filtering/filtering.html b/Samples-Typescript/Dashboard/Filtering/filtering.html similarity index 93% rename from Samples-Typescript/Filtering/filtering.html rename to Samples-Typescript/Dashboard/Filtering/filtering.html index 6e7270b8..cf1571c0 100644 --- a/Samples-Typescript/Filtering/filtering.html +++ b/Samples-Typescript/Dashboard/Filtering/filtering.html @@ -15,10 +15,10 @@ - + - +
diff --git a/Samples-Typescript/Filtering/filtering.ts b/Samples-Typescript/Dashboard/Filtering/filtering.ts similarity index 100% rename from Samples-Typescript/Filtering/filtering.ts rename to Samples-Typescript/Dashboard/Filtering/filtering.ts diff --git a/Samples-Typescript/Formatting/formatting.html b/Samples-Typescript/Dashboard/Formatting/formatting.html similarity index 94% rename from Samples-Typescript/Formatting/formatting.html rename to Samples-Typescript/Dashboard/Formatting/formatting.html index 2bd43452..14ee412d 100644 --- a/Samples-Typescript/Formatting/formatting.html +++ b/Samples-Typescript/Dashboard/Formatting/formatting.html @@ -11,10 +11,10 @@ - + - + + + + +
+ + diff --git a/Samples/Viz/Sankey/sankey.js b/Samples/Viz/Sankey/sankey.js new file mode 100644 index 00000000..27762323 --- /dev/null +++ b/Samples/Viz/Sankey/sankey.js @@ -0,0 +1,728 @@ +/* global d3 */ +/* global tinycolor */ + +const backgroundColor = tinycolor('white'); + +async function Sankey (encodedData, encodingMap, width, height, selectedTupleIds, styles) { + const palette = ['#4e79a7', '#f28e2c', '#e15759', '#76b7b2', '#59a14f', '#edc949', '#af7aa1', '#ff9da7', '#9c755f', '#bab0ab']; + + const xPadding = 2; + const yPadding = 1; + const levelWidth = 100; + const top = 20; + + const layout = computeSankeyLayout( + d3.sankey, + encodedData, + top, + width, + height, + levelWidth + xPadding * 2, + yPadding, + palette + ); + + // Create an SVG container. + const svg = d3 + .create('svg') + .attr('class', tableau.ClassNameKey.Worksheet) + .attr('width', width) + .attr('height', height) + .attr('viewBox', [0, 0, width, height]) + .attr('style', 'max-width: 100%; height: auto; height: intrinsic;') + .attr('font-family', styles?.fontWeight) + .attr('font-weight', styles?.fontFamily) + .attr('font-size', styles?.fontSize) + .attr('font-style', styles?.fontStyle) + .attr('text-decoration', styles?.textDecoration); + + const selectedNodeIndexes = getSelectedNodes(layout.links, selectedTupleIds); + + // Create the rects that represent the nodes. + svg.append('g') + .selectAll() + .data(layout.nodes) + .join('rect') + .attr('x', d => d.x0 + xPadding) + .attr('y', d => d.y0) + .attr('height', d => d.y1 - d.y0) + .attr('width', d => d.x1 - d.x0 - xPadding * 2) + .attr('fill', (d, index) => getColor(d.color, selectedTupleIds, selectedNodeIndexes.has(index))); + + // Creates the paths that represent the links. + const links = svg.append('g') + .attr('fill-opacity', 0.5) + .style('cursor', 'pointer') + .selectAll() + .data(layout.links) + .join('path') + .attr('d', getLinkPath) + .attr('fill', d => getLinkColor(d, selectedTupleIds)); + + // Add labels on the nodes. + svg.append('g') + .selectAll() + .data(layout.nodes) + .join('text') + .attr('x', d => (d.x1 + d.x0) / 2) + .attr('y', d => (d.y1 + d.y0) / 2) + .attr('dy', '0.35em') + .attr('text-anchor', 'middle') + .text(d => d.name) + .attr('fill', (d, index) => getColor('black', selectedTupleIds, selectedNodeIndexes.has(index))); + + // Add top labels + if (encodingMap.level) { + // Pick one representetive node for each level + const levels = []; + for (const node of layout.nodes) { levels[node.layer] = node; } + + svg.append('g') + .selectAll() + .data(levels) + .join('text') + .attr('font-weight', 'bold') + .attr('x', d => (d.x1 + d.x0) / 2) + .attr('y', top / 2) + .attr('text-anchor', 'middle') + .text(d => encodingMap.level[d.layer].name) + .attr('fill', styles?.color); + } + + // Container for rendering selected elements (rendered last) + const selectionLayer = svg.append('g'); + const hoveringLayer = svg.append('g'); + + const linksPerTupleId = getLinksPerTupleId(links); + + renderSelection(selectedTupleIds, linksPerTupleId, selectionLayer, hoveringLayer); + + return { + hoveringLayer, + linksPerTupleId, + viz: svg.node() + }; +} + +function getLinksPerTupleId (links) { + const linksPerTupleId = new Map(); + links.each(function (d) { + let list = linksPerTupleId.get(d.tupleId); + if (!list) { + list = []; + linksPerTupleId.set(d.tupleId, list); + } + list.push(d3.select(this)); + }); + + return linksPerTupleId; +} + +function getSelectedNodes (links, selectedTupleIds) { + const selectedNodeIndexes = new Map(); + + for (const link of links) { + if (selectedTupleIds.has(link.tupleId)) { + selectedNodeIndexes.set(link.source.index); + selectedNodeIndexes.set(link.target.index); + } + } + + return selectedNodeIndexes; +} + +// Render selected elements on a separate top-level layer +function renderSelection (selectedTupleIds, linksPerTupleId, selectionLayer, highlightingLayer) { + selectionLayer.selectAll('*').remove(); + highlightingLayer.selectAll('*').remove(); + + const selectedLinks = []; + + for (const id of selectedTupleIds.keys()) { selectedLinks.push(...linksPerTupleId.get(id)); } + + let outline = selectionLayer.selectAll('g.selectionOutline'); + + // Render the outline first (to dissolve selected elemens borders) + if (outline.empty()) { + outline = selectionLayer + .append('g') + .attr('class', 'selectionOutline'); + } + + outline.selectAll() + .data(selectedLinks) + .join('path') + .attr('d', link => link.attr('d')) // Copy path geometry from the 'normal' element + .datum(link => link.datum()); // Bind data from the 'normal' elememt + + // Render filled elements without borders + let fill = selectionLayer.selectAll('g.selection'); + + if (fill.empty()) { + fill = selectionLayer + .append('g') + .attr('class', 'selection'); + } + + fill.selectAll() + .data(selectedLinks) + .join('path') + .attr('d', link => link.attr('d')) // Copy path geometry from the 'normal' element + .datum(link => link.datum()); // Bind data from the 'normal' elememt +} + +// Render hovered elements on a separate top-level layer +function renderHoveredElements (hoveredTupleIds, linksPerTupleId, hoveringLayer) { + if (!hoveringLayer) return; + + hoveringLayer.selectAll('*').remove(); + + const hoveredLinks = []; + for (const id of hoveredTupleIds.keys()) { hoveredLinks.push(...linksPerTupleId.get(id)); } + + hoveringLayer.selectAll() + .data(hoveredLinks) + .join('path') + .attr('d', (link) => link.attr('d')) + .attr('class', 'highlighting'); +} + +async function renderViz (rawData, encodingMap, selectedMarksIds, styles) { + const encodedData = getEncodedData(rawData, encodingMap); + + const content = document.getElementById('content'); + content.innerHTML = ''; + + const sankey = await Sankey( + encodedData, + encodingMap, + content.offsetWidth, + content.offsetHeight, + selectedMarksIds, + styles + ); + + content.appendChild(sankey.viz); + + return sankey; +} + +// Uses getVisualSpecificationAsync to build a map of encoding identifiers (specified in the .trex file) +// to fields that the user has placed on the encoding's shelf. +// Only encodings that have fields dropped on them will be part of the encodingMap. +async function getEncodingMap () { + const worksheet = tableau.extensions.worksheetContent.worksheet; + const visualSpec = await worksheet.getVisualSpecificationAsync(); + + const encodingMap = {}; + + if (visualSpec.activeMarksSpecificationIndex < 0) { return encodingMap; } + + const marksCard = visualSpec.marksSpecifications[visualSpec.activeMarksSpecificationIndex]; + for (const encoding of marksCard.encodings) { + if (!encodingMap[encoding.id]) { encodingMap[encoding.id] = []; } + + encodingMap[encoding.id].push(encoding.field); + } + + return encodingMap; +} + +window.onload = tableau.extensions.initializeAsync().then(async () => { + // Get the worksheet that the Viz Extension is running in + const worksheet = tableau.extensions.worksheetContent.worksheet; + + // Save these outside the scope below for handling resizing without refetching the data + let summaryData = {}; + let encodingMap = {}; + let selectedMarks = new Map(); + const hoveredMarks = new Map(); + let linksPerTupleId = new Map(); + let hoveringLayer; + + const styles = tableau.extensions.environment.workbookFormatting?.formattingSheets + ?.find(x => x.classNameKey === 'tableau-worksheet')?.cssProperties; + + // Use the extensions API to get the summary data and map of encodings to fields, + // and render the connected scatterplot. + const updateDataAndRender = async () => { + // Use extensions API to update the table of data and the map from encodings to fields + [summaryData, encodingMap] = await Promise.all([ + getSummaryDataTable(worksheet), + getEncodingMap(worksheet) + ]); + + // Selection can change on any data changes + selectedMarks = await getSelection(worksheet, summaryData); + ({ hoveringLayer, linksPerTupleId } = await renderViz(summaryData, encodingMap, selectedMarks, styles)); + }; + + // Handle re-rendering when the page is resized + onresize = async () => { + ({ hoveringLayer, linksPerTupleId } = await renderViz(summaryData, encodingMap, selectedMarks, styles)); + }; + + // Listen to event for when the summary data backing the worksheet has changed. + // This tells us that we should refresh the data and encoding map. + worksheet.addEventListener( + tableau.TableauEventType.SummaryDataChanged, updateDataAndRender); + + // Setup interactivity events + document.body.addEventListener('click', async (e) => { + onClick(e, selectedMarks, hoveredMarks); + ({ hoveringLayer, linksPerTupleId } = await renderViz(summaryData, encodingMap, selectedMarks, styles)); + }); + + document.body.addEventListener('mousemove', e => onMouseMove(e, hoveredMarks, linksPerTupleId, hoveringLayer)); + document.body.addEventListener('mouseout', e => onMouseMove(e, hoveredMarks, linksPerTupleId, hoveringLayer)); + + // Do the initial update and render + updateDataAndRender(); +}); + +function onClick (e, selectedTupleIds, hoveredTupleIds) { + const elem = d3.select(document.elementFromPoint(e.pageX, e.pageY)); + const data = elem?.datum(); + const tupleId = data === undefined ? null : data.tupleId; + + if (elem && tupleId !== null && tupleId !== undefined) { + if (selectedTupleIds.has(tupleId)) { + // User clicked on an already selected item + // Only one item is selected - deselect it + if (selectedTupleIds.size === 1) selectedTupleIds.clear(); + // Remove an item from selection + else if (e.ctrlKey) selectedTupleIds.delete(tupleId); + else { + selectedTupleIds.clear(); + selectedTupleIds.set(tupleId); + } + } else { + if (!e.ctrlKey) selectedTupleIds.clear(); + selectedTupleIds.set(tupleId); + } + } else if (!e.ctrlKey) { + // Clicking outside of any element will clear all element, unless CTRL is pressed + selectedTupleIds.clear(); + } + + selectTuples(e.pageX, e.pageY, selectedTupleIds, hoveredTupleIds); +} + +async function selectTuples (x, y, selectedTupleIds, hoveredTupleIds) { + clearHoveredMarks(hoveredTupleIds); + getWorksheet().selectTuplesAsync([...selectedTupleIds.keys()], tableau.SelectOptions.Simple, { tooltipAnchorPoint: { x, y } }); +} + +async function onMouseMove (e, hoveredTupleIds, linksPerTupleId, hoveringLayer) { + const elem = d3.select(document.elementFromPoint(e.pageX, e.pageY)); + const data = elem?.node() ? elem.datum() : undefined; + const tupleId = data === undefined ? null : data.tupleId; + + const hadHoveredTupleBefore = hoveredTupleIds.size !== 0; + + clearHoveredMarks(hoveredTupleIds); + + if (elem && tupleId !== null && tupleId !== undefined) { + hoveredTupleIds.set(tupleId); + getWorksheet().hoverTupleAsync(parseInt(tupleId), { tooltipAnchorPoint: { x: e.pageX, y: e.pageY } }); + } else if (hadHoveredTupleBefore) { getWorksheet().hoverTupleAsync(parseInt(tupleId), { tooltipAnchorPoint: { x: e.pageX, y: e.pageY } }); } + + renderHoveredElements(hoveredTupleIds, linksPerTupleId, hoveringLayer); +} + +function clearHoveredMarks (hoveredTupleIds) { + hoveredTupleIds.clear(); +} + +async function getSelection (worksheet, allMarks) { + const selectedMarks = await worksheet.getSelectedMarksAsync(); + + return findIdsOfSelectedMarks(allMarks, selectedMarks); +} + +// Go through all selected marks and find their exact match in the data table +// Use the index of the mark in the data table to compute tupleId +function findIdsOfSelectedMarks (allMarks, selectedMarks) { + const columns = selectedMarks.data[0].columns; + const selectedMarkMap = new Map(); + const selectedMarksIds = new Map(); + + for (const selectedMark of convertToListOfNamedRows(selectedMarks.data[0])) { + let key = ''; + for (const col of columns) { key += selectedMark[col.fieldName].value + '\x00'; } + + selectedMarkMap.set(key, selectedMark); + } + + let tupleId = 1; + for (const mark of allMarks) { + let key = ''; + for (const col of columns) { key += mark[col.fieldName].value + '\x00'; } + + if (selectedMarkMap.has(key)) { selectedMarksIds.set(tupleId); } + + tupleId++; + } + + return selectedMarksIds; +} + +// Takes a page of data, which has a list of DataValues (dataTablePage.data) +// and a list of columns and puts the data in a list where each entry is an +// object that maps from field names to DataValues +// (example of a row being: { SUM(Sales): ..., SUM(Profit): ..., Ship Mode: ..., }) +function convertToListOfNamedRows (dataTablePage) { + const rows = []; + const columns = dataTablePage.columns; + const data = dataTablePage.data; + for (let i = 0; i < data.length; ++i) { + const row = {}; + for (let j = 0; j < columns.length; ++j) { + row[columns[j].fieldName] = data[i][columns[j].index]; + } + row.tupleId = i + 1; + rows.push(row); + } + return rows; +} + +// Gets each page of data in the summary data and returns a list of rows of data +// associated with field names. +async function getSummaryDataTable (worksheet) { + let rows = []; + + // Fetch the summary data using the DataTableReader + const dataTableReader = await worksheet.getSummaryDataReaderAsync( + undefined, + { ignoreSelection: true } + ); + for ( + let currentPage = 0; + currentPage < dataTableReader.pageCount; + currentPage++ + ) { + const dataTablePage = await dataTableReader.getPageAsync(currentPage); + rows = rows.concat(convertToListOfNamedRows(dataTablePage)); + } + await dataTableReader.releaseAsync(); + + return rows; +} + +// Converts each data row from a object map to a object map +// For example, { SUM(Sales): 10.23, Ship Mode: 'Next Day', Category: 'Office Supplies' } will be converted to +// { edge: [10.23], levels: ['Next Day', 'Office Supplies'] } if SUM(Sales) is on the edge encoding and Ship Mode ad Category are on the level encoding +function getEncodedData (data, encodingMap) { + const encodedData = []; + + let tupleId = 1; + for (const row of data) { + const encodedRow = {}; + + for (const encName in encodingMap) { + const fields = encodingMap[encName]; + + encodedRow[encName] = []; + + for (const field of fields) { encodedRow[encName].push(row[field.name]); } + } + + encodedRow.tupleId = tupleId; + tupleId++; + + encodedData.push(encodedRow); + } + + return encodedData; +} + +//= ================= +// COLOR FUNCTIONS +//= ================= +function getLinkColor (link, selectedTupleIds) { + const color = link.color ?? 'lightgray'; + + return getColor(color, selectedTupleIds); +} + +function getColor (color, selectedTupleIds, doNotFog) { + return (selectedTupleIds.size > 0 && doNotFog !== true) ? calculateFogColor(color) : color; +} + +/* +function getLabelColor(color, selectedTupleIds) { + color = getAutoLabelColor(color ?? 'rgb(102, 102, 102)'); + return getColor(color, selectedTupleIds); +} + +// Takes two possible options for a color (a light and a dark color option) and returns the one with the ideal +// contrast to the background color. +function getAutoLabelColor (fgColorStr, bgColorStr) { + const Black = tinycolor('black'); + const White = tinycolor('white'); + + const fgColor = tinycolor(fgColorStr); + const bgColor = tinycolor(bgColorStr); + + const fgColorIsLight = isLuminanceAboveThreshold(fgColor); + const dark = fgColorIsLight ? Black : fgColor; + const light = fgColorIsLight ? fgColor : White; + + const autoColor = isLuminanceAboveThreshold(bgColor) ? dark : light; + + return autoColor.toHexString(); +} + +function isLuminanceAboveThreshold (color) { + return color.getLuminance() > 0.3149999976158142; +} +*/ + +const fogBlendFactor = getFogBlendFactor(backgroundColor); +const { foggedBackgroundRed, foggedBackgroundGreen, foggedBackgroundBlue } = computeFoggedBackgroundColor(backgroundColor, fogBlendFactor); + +// When one or more elements are selected, everything else is fogged out. +function computeFoggedBackgroundColor (color, fogBlendFactor) { + const CloseToWhite = 245; + + if (color.r >= CloseToWhite && color.g >= CloseToWhite && color.b >= CloseToWhite) { color = tinycolor({ r: CloseToWhite, g: CloseToWhite, b: CloseToWhite }); } + + color = color.toRgb(); + const foggedBackgroundRed = (1 - fogBlendFactor) * color.r >>> 0; + const foggedBackgroundGreen = (1 - fogBlendFactor) * color.g >>> 0; + const foggedBackgroundBlue = (1 - fogBlendFactor) * color.b >>> 0; + + return { foggedBackgroundRed, foggedBackgroundGreen, foggedBackgroundBlue }; +} + +function calculateFogColor (colorStr) { + const color = tinycolor(colorStr).toRgb(); + + const fogR = foggedBackgroundRed + color.r * fogBlendFactor >>> 0; + const fogG = foggedBackgroundGreen + color.g * fogBlendFactor >>> 0; + const fogB = foggedBackgroundBlue + color.b * fogBlendFactor >>> 0; + + return tinycolor({ r: fogR, g: fogG, b: fogB }).toHexString(); +} + +function getFogBlendFactor (color) { + color = color.toRgb(); + + const DefaultFogBlendFactor = 0.1850000023841858; + const DarkBgFogBlendFactor = 0.2750000059604645; + const DarkBgThreshold = 75; + const isDarkBackground = color.r <= DarkBgThreshold && color.g <= DarkBgThreshold && color.b <= DarkBgThreshold; + return (isDarkBackground ? DarkBgFogBlendFactor : DefaultFogBlendFactor); +} + +function getLinkPath (d) { + const midX = (d.source.x1 + d.target.x0) / 2; + let path = `M ${d.source.x1} ${d.y0 - d.width / 2}`; + path += ` C ${midX} ${d.y0 - d.width / 2} ${midX} ${d.y1 - d.width / 2} ${d.target.x0} ${d.y1 - d.width / 2}`; + path += ` L ${d.target.x0} ${d.y1 + d.width / 2}`; + path += ` C ${midX} ${d.y1 + d.width / 2} ${midX} ${d.y0 + d.width / 2} ${d.source.x1} ${d.y0 + d.width / 2}`; + path += ' Z'; // close the path + return path; +} + +function computeSankeyLayout ( + d3Sankey, + data, + top, + width, + height, + nodeWidth, + padding, + palette +) { + // `nodes` are `rectangles` in the UI + // `links` are what we call `edges` or `noodles` in the UI + if (data.length === 0) return { links: [], nodes: [] }; + + const firstRow = data[0]; + + const levelCount = Array.isArray(firstRow.level) ? firstRow.level.length : 0; + const hasLinks = firstRow.edge !== undefined; + + if (levelCount === 0) { + // Create a dummy link that follows the object schema returned by d3 + const link = { + y0: (height - top) / 2, + y1: (height - top) / 2, + source: { + x1: nodeWidth + }, + target: { + x0: width - nodeWidth + }, + width: 2, + color: null + }; + return { nodes: [], links: [link] }; + } + + let links = []; + let nodes = []; + + if (levelCount === 1) { + // Compute links for each pair of adjacent levels + for (const row of data) { + const link = { + source: { name: row.level[0].value }, + target: { name: row.level[0].value }, + value: getLinkValue(row, hasLinks), + tupleId: row.tupleId + }; + + links.push(link); + nodes.push(link.source); + nodes.push(link.target); + } + } else { + // Compute a map of nodes for each level + const nodesPerLevel = []; + + for (let i = 0; i < levelCount; i++) nodesPerLevel.push(new Map()); + + for (const row of data) { + for (let i = 0; i < levelCount; i++) nodesPerLevel[i].set(row.level[i].value, { name: row.level[i].value }); + } + nodes.push(...nodesPerLevel[0].values()); // initialize with the first level nodes + + // Compute links for each pair of adjacent levels + for (let i = 0; i < levelCount - 1; i++) { + for (const row of data) { + links.push({ + source: nodesPerLevel[i].get(row.level[i].value), + target: nodesPerLevel[i + 1].get(row.level[i + 1].value), + value: getLinkValue(row, hasLinks), + tupleId: row.tupleId + }); + } + + nodes.push(...nodesPerLevel[i + 1].values()); + } + + // We have two goals for our sorting of links. We want the links associated with a particular + // tuple to "meet up" at the nodes, so that they form a mostly continuous path end-to-end. We + // also don't want the links to be a complete webbed mess. We try to make sure that the links + // between the first two levels are pleasing, and then we let d3 do its best with the rest. + // To create a pleasing set of links between level 0 and 1, we sort the links so that all + // links between level-0/node-0 and level-1/node-0 are adjacent, followed by all links + // between level-0/node-0 and level-1/node-1, etc. This minimizes cross-over in the first + // set of links. We try to apply the same idea to the rest of the levels, but the sort on + // level-0 will almost always win in practice. The bands will leave level-1 at the same height + // as they entered, but who knows where they'll go after that! d3 will do its best by reordering + // nodes in later levels, which may also improve appearance. + + links.sort((lhs, rhs) => { + const isLevelNLink = (link, n) => link.source === nodesPerLevel[n].get(link.source.name); + for (let level = 0; level < nodesPerLevel.length; level++) { + const lhsLevelNLink = links.find((elem) => elem.tupleId === lhs.tupleId && isLevelNLink(elem, level)); + const rhsLevelNLink = links.find((elem) => elem.tupleId === rhs.tupleId && isLevelNLink(elem, level)); + + if (!lhsLevelNLink) { + return rhsLevelNLink ? -1 : 0; + } + if (!rhsLevelNLink) { + return 1; + } + + const lhsLevelNSourceNodeIndex = nodes.indexOf(lhsLevelNLink.source); + const rhsLevelNSourceNodeIndex = nodes.indexOf(rhsLevelNLink.source); + if (lhsLevelNSourceNodeIndex !== rhsLevelNSourceNodeIndex) { + return lhsLevelNSourceNodeIndex < rhsLevelNSourceNodeIndex ? -1 : 1; + } + + const lhsLevelNTargetNodeIndex = nodes.indexOf(lhsLevelNLink.target); + const rhsLevelNTargetNodeIndex = nodes.indexOf(rhsLevelNLink.target); + if (lhsLevelNTargetNodeIndex !== rhsLevelNTargetNodeIndex) { + return lhsLevelNTargetNodeIndex < rhsLevelNTargetNodeIndex ? -1 : 1; + } + } + + if (lhs.tupleId !== rhs.tupleId) { + return lhs.tupleId < rhs.tupleId ? -1 : 1; + } + + return 0; + }); + } + + // Set the sankey diagram properties + const sankey = d3Sankey() + .nodeWidth(nodeWidth) + .nodePadding(padding) + .linkSort(null) + .nodeSort(null) + .extent([ + [0, top], + [width, height] + ]) + .nodes(nodes) + .links(links); + + // Compute the layout + sankey({ nodes, links }); + + // If there are any NaN values in nodes or links, render will fail. + // Set both to [] so that we get an empty display instead. TFS 1481434. + if (elementOfArrayContainsNaNProperty(nodes) || elementOfArrayContainsNaNProperty(links)) { + nodes = []; + links = []; + return { nodes, links }; + } + + if (levelCount === 1) { + nodes = nodes.filter((node) => node.depth === 0); + } + + nodes = nodes.filter((node) => node.value); + links = links.filter((link) => nodes.includes(link.source) && nodes.includes(link.target)); + + // Add colors, this needs to be the very last thing done to ensure palette is applied correctly + for (let i = 0; i < nodes.length; i++) { + const node = nodes[i]; + node.color = palette[i % palette.length]; + for (const link of node.sourceLinks) { + link.color = node.color; + } + } + + return { nodes, links }; +} + +function elementOfArrayContainsNaNProperty (dataArray) { + // If any of these properties of a node or link element contain a NaN value, the viz will not render. + const propertiesToCheckForNaN = ['x', 'y', 'x0', 'y0', 'x1', 'y1', 'width', 'height']; + + for (const element of dataArray) { + if (!element) continue; + + for (const propertyName in element) { + if (!propertiesToCheckForNaN.includes(propertyName)) continue; + + if (Object.prototype.hasOwnProperty.call(element, propertyName)) { + const thisValue = element[propertyName]; + if (typeof thisValue === 'number' && isNaN(thisValue)) { + return true; + } + } + } + } + return false; +} + +function getLinkValue (row, hasLinks) { + if (!hasLinks) return 1; // If there's no field on edge, make all links the same weight + + const value = row.edge[0].value; + + return typeof value === 'number' && !isNaN(value) ? Math.max(0, value) : 0; +} + +function getWorksheet () { + return tableau.extensions.worksheetContent + ? tableau.extensions.worksheetContent.worksheet + : tableau.extensions.dashboardContent.dashboard.worksheets[0]; +} diff --git a/Samples/Viz/Sankey/sankey.trex b/Samples/Viz/Sankey/sankey.trex new file mode 100644 index 00000000..afbce1f3 --- /dev/null +++ b/Samples/Viz/Sankey/sankey.trex @@ -0,0 +1,35 @@ + + + + en_US + + Sankey + + 1.11 + + http://localhost:8765/Samples/Viz/Sankey/sankey.html + + + + Level + + discrete-dimension + discrete-measure + + + + + Edge + + continuous-measure + continuous-dimension + + + + + + + Sankey + + + diff --git a/Samples/Viz/Settings/Settings.trex b/Samples/Viz/Settings/Settings.trex new file mode 100644 index 00000000..12838d71 --- /dev/null +++ b/Samples/Viz/Settings/Settings.trex @@ -0,0 +1,19 @@ + + + + en_US + + Settings Sample + + 1.11 + + http://localhost:8765/Samples/Viz/Settings/settings.html + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAlhJREFUOI2Nkt9vy1EYh5/3bbsvRSySCZbIxI+ZCKsN2TKtSFyIrV2WuRCJuBiJWxfuxCVXbvwFgiEtposgLFJElnbU1SxIZIIRJDKTrdu+53Uhra4mce7Oe57Pcz7JOULFisViwZ+29LAzOSjQYDgz1ZcCvWuXV11MJpN+OS/lm6179teqH0yDqxPTCyKSA8DcDsyOmOprnCaeP7459pdgy969i0LTC3IO/RQMyoHcQN+3cnljW3dNIFC47qDaK3g7BwdTkwBaBELT4ZPOUVWgKl4ZBnjxJPUlMDnTDrp0pmr6RHFeEjjcUUXPDGeSEwDN0Xg8sivxMhJNjGzbHd8PkM3eHRfkrBM5NkcQaY2vUnTlrDIA0NoaX+KLXFFlowr14tvVpqb2MICzmQcKqxvbumv+NAhZGCCIPwEw6QWXKYRL/VUXO0+rAUJiPwAk5MIlgVfwPjjHLCL1APmHN94ZdqeYN+NW/mn6I4BvwQYchcLnwFhJMDiYmlRxAzjpKWZkYkUCcZ2I61wi37tLbYyjiN0fHk5Oz3nGSLSzBbNHCF35R7f6K1/hN9PRhek11FrymfQQQKB4+Gl05P2qNRtmETlXW7e+b2z01dfycGNbfFMAbqNyKp9Jp4rzOT8RYFs0njJkc2iqsCObvTsOsDWWqA5C1uFy+Uz/oXJeKwVT4h0RmPUXhi79vuC0Ku6yOffTK3g9lfxfDQAisY516sg5kfOCiJk7HoLt2cf9b/9LANAc7dznm98PagG1fUOZ9IP5uMB8Q4CPoyNvausapkTt3rNMuvdf3C/o6+czhtdwmwAAAABJRU5ErkJggg== + + + + Settings Sample + + + diff --git a/Samples/Viz/Settings/settings.html b/Samples/Viz/Settings/settings.html new file mode 100644 index 00000000..20ea384b --- /dev/null +++ b/Samples/Viz/Settings/settings.html @@ -0,0 +1,61 @@ + + + + + + + Settings Sample + + + + + + + + + + + + + + + +
+ +
+

Current Settings

+
+ + + + + + + + + + + + + + +
+
+ + +
+
+
+
+ +
+
+ +
+ +
+
+ +
+ + diff --git a/Samples/Viz/Settings/settings.js b/Samples/Viz/Settings/settings.js new file mode 100644 index 00000000..2c68f093 --- /dev/null +++ b/Samples/Viz/Settings/settings.js @@ -0,0 +1,82 @@ +'use strict'; + +// Wrap everything in an anonymous function to avoid polluting the global namespace +(function () { + $(document).ready(function () { + tableau.extensions.initializeAsync().then(function () { + // First, check for any saved settings and populate our UI based on them. + buildSettingsTable(tableau.extensions.settings.getAll()); + }, function (err) { + // Something went wrong in initialization + console.log('Error while Initializing: ' + err.toString()); + }); + + $('#save').click(saveSetting); + }); + + function eraseSetting (key, row) { + // This change won't be persisted until settings.saveAsync has been called. + tableau.extensions.settings.erase(key); + + // Remove the setting from the UI immediately. + row.remove(); + + // Save in the background, saveAsync results don't need to be handled immediately. + tableau.extensions.settings.saveAsync(); + + updateUIState(Object.keys(tableau.extensions.settings.getAll()).length > 0); + } + + function buildSettingsTable (settings) { + // Clear the table first. + $('#settingsTable > tbody tr').remove(); + const settingsTable = $('#settingsTable > tbody')[0]; + + // Add an entry to the settings table for each setting. + for (const settingKey in settings) { + const newRow = settingsTable.insertRow(settingsTable.rows.length); + const keyCell = newRow.insertCell(0); + const valueCell = newRow.insertCell(1); + const eraseCell = newRow.insertCell(2); + + const eraseSpan = document.createElement('span'); + eraseSpan.className = 'glyphicon glyphicon-trash'; + eraseSpan.addEventListener('click', function () { eraseSetting(settingKey, newRow); }); + + keyCell.innerHTML = settingKey; + valueCell.innerHTML = settings[settingKey]; + eraseCell.appendChild(eraseSpan); + } + + updateUIState(Object.keys(settings).length > 0); + } + + function saveSetting () { + const settingKey = $('#keyInput').val(); + const settingValue = $('#valueInput').val(); + + tableau.extensions.settings.set(settingKey, settingValue); + + // Save the newest settings via the settings API. + tableau.extensions.settings.saveAsync().then((currentSettings) => { + // This promise resolves to a list of the current settings. + // Rebuild the UI with that new list of settings. + buildSettingsTable(currentSettings); + + // Clears the settings of content. + $('#settingForm').get(0).reset(); + }); + } + + // This helper updates the UI depending on whether or not there are settings + // that exist in the worksheet. Accepts a boolean. + function updateUIState (settingsExist) { + if (settingsExist) { + $('#settingsTable').removeClass('hidden').addClass('show'); + $('#noSettingsWarning').removeClass('show').addClass('hidden'); + } else { + $('#noSettingsWarning').removeClass('hidden').addClass('show'); + $('#settingsTable').removeClass('show').addClass('hidden'); + } + } +})(); diff --git a/Samples/Viz/UINamespace/uiNamespace.html b/Samples/Viz/UINamespace/uiNamespace.html new file mode 100644 index 00000000..da1f9a05 --- /dev/null +++ b/Samples/Viz/UINamespace/uiNamespace.html @@ -0,0 +1,56 @@ + + + + + + + Settings Sample + + + + + + + + + + + + + + + +
+

+

+
+ Configure extension to proceed. +
+

+
+
Dialog Style
+
+ + +
+
+ + +
+
+ + +
+
+ +
+ + diff --git a/Samples/Viz/UINamespace/uiNamespace.js b/Samples/Viz/UINamespace/uiNamespace.js new file mode 100644 index 00000000..709fdc3a --- /dev/null +++ b/Samples/Viz/UINamespace/uiNamespace.js @@ -0,0 +1,111 @@ +'use strict'; + +/** + * UINamespace Sample Extension + * + * This sample extension demonstrates how to use the UI namespace + * to create a popup dialog with additional UI that the user can interact with. + * The content in this dialog is actually an extension as well (see the + * uiNamespaceDialog.js for details). + * + * This sample is an extension that auto refreshes datasources in a worksheet + */ + +// Wrap everything in an anonymous function to avoid polluting the global namespace +(function () { + const defaultIntervalInMin = '5'; + let activeDatasourceIdList = []; + + $(document).ready(function () { + tableau.extensions.initializeAsync().then(function () { + // This event allows for the parent extension and popup extension to keep their + // settings in sync. This event will be triggered any time a setting is + // changed for this extension, in the parent or popup (i.e. when settings.saveAsync is called). + tableau.extensions.settings.addEventListener(tableau.TableauEventType.SettingsChanged, (settingsEvent) => { + updateExtensionBasedOnSettings(settingsEvent.newSettings); + }); + + document.getElementById('configure').onclick = configure; + }); + }); + + function configure () { + // This uses the window.location.origin property to retrieve the scheme, hostname, and + // port where the parent extension is currently running, so this string doesn't have + // to be updated if the extension is deployed to a new location. + const popupUrl = `${window.location.origin}/Samples/Viz/UINamespace/uiNamespaceDialog.html`; + + // This checks for the selected dialog style in the radio form. + let dialogStyle; + const dialogStyleOptions = document.getElementsByName('dialogStyleRadio'); + if (dialogStyleOptions[0].checked) { + dialogStyle = tableau.DialogStyle.Modal; + } else if (dialogStyleOptions[1].checked) { + dialogStyle = tableau.DialogStyle.Modeless; + } else { + dialogStyle = tableau.DialogStyle.Window; + } + + /** + * This is the API call that actually displays the popup extension to the user. The + * popup is always a modal dialog. The only required parameter is the URL of the popup, + * which must be the same domain, port, and scheme as the parent extension. + * + * The developer can optionally control the initial size of the extension by passing in + * an object with height and width properties. The developer can also pass a string as the + * 'initial' payload to the popup extension. This payload is made available immediately to + * the popup extension. In this example, the value '5' is passed, which will serve as the + * default interval of refresh. + */ + tableau.extensions.ui + .displayDialogAsync(popupUrl, defaultIntervalInMin, { height: 500, width: 500, dialogStyle }) + .then((closePayload) => { + // The promise is resolved when the dialog has been expectedly closed, meaning that + // the popup extension has called tableau.extensions.ui.closeDialog. + $('#inactive').hide(); + $('#active').show(); + + // The close payload is returned from the popup extension via the closeDialog method. + $('#interval').text(closePayload); + setupRefreshInterval(closePayload); + }) + .catch((error) => { + // One expected error condition is when the popup is closed by the user (meaning the user + // clicks the 'X' in the top right of the dialog). This can be checked for like so: + switch (error.errorCode) { + case tableau.ErrorCodes.DialogClosedByUser: + console.log('Dialog was closed by user'); + break; + default: + console.error(error.message); + } + }); + } + + /** + * This function sets up a JavaScript interval based on the time interval selected + * by the user. This interval will refresh all selected datasources. + */ + function setupRefreshInterval (interval) { + setInterval(function () { + const worksheet = tableau.extensions.worksheetContent.worksheet; + worksheet.getDataSourcesAsync().then(function (datasources) { + datasources.forEach(function (datasource) { + if (activeDatasourceIdList.indexOf(datasource.id) >= 0) { + datasource.refreshAsync(); + } + }); + }); + }, interval * 60 * 1000); + } + + /** + * Helper that is called to set state anytime the settings are changed. + */ + function updateExtensionBasedOnSettings (settings) { + if (settings.selectedDatasources) { + activeDatasourceIdList = JSON.parse(settings.selectedDatasources); + $('#datasourceCount').text(activeDatasourceIdList.length); + } + } +})(); diff --git a/Samples/Viz/UINamespace/uiNamespace.trex b/Samples/Viz/UINamespace/uiNamespace.trex new file mode 100644 index 00000000..c5f0c059 --- /dev/null +++ b/Samples/Viz/UINamespace/uiNamespace.trex @@ -0,0 +1,19 @@ + + + + en_US + + UI Namespace Sample + + 1.11 + + http://localhost:8765/Samples/Viz/UINamespace/uinamespace.html + + iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEwAACxMBAJqcGAAAAlhJREFUOI2Nkt9vy1EYh5/3bbsvRSySCZbIxI+ZCKsN2TKtSFyIrV2WuRCJuBiJWxfuxCVXbvwFgiEtposgLFJElnbU1SxIZIIRJDKTrdu+53Uhra4mce7Oe57Pcz7JOULFisViwZ+29LAzOSjQYDgz1ZcCvWuXV11MJpN+OS/lm6179teqH0yDqxPTCyKSA8DcDsyOmOprnCaeP7459pdgy969i0LTC3IO/RQMyoHcQN+3cnljW3dNIFC47qDaK3g7BwdTkwBaBELT4ZPOUVWgKl4ZBnjxJPUlMDnTDrp0pmr6RHFeEjjcUUXPDGeSEwDN0Xg8sivxMhJNjGzbHd8PkM3eHRfkrBM5NkcQaY2vUnTlrDIA0NoaX+KLXFFlowr14tvVpqb2MICzmQcKqxvbumv+NAhZGCCIPwEw6QWXKYRL/VUXO0+rAUJiPwAk5MIlgVfwPjjHLCL1APmHN94ZdqeYN+NW/mn6I4BvwQYchcLnwFhJMDiYmlRxAzjpKWZkYkUCcZ2I61wi37tLbYyjiN0fHk5Oz3nGSLSzBbNHCF35R7f6K1/hN9PRhek11FrymfQQQKB4+Gl05P2qNRtmETlXW7e+b2z01dfycGNbfFMAbqNyKp9Jp4rzOT8RYFs0njJkc2iqsCObvTsOsDWWqA5C1uFy+Uz/oXJeKwVT4h0RmPUXhi79vuC0Ku6yOffTK3g9lfxfDQAisY516sg5kfOCiJk7HoLt2cf9b/9LANAc7dznm98PagG1fUOZ9IP5uMB8Q4CPoyNvausapkTt3rNMuvdf3C/o6+czhtdwmwAAAABJRU5ErkJggg== + + + + UI Namespace Sample + + + diff --git a/Samples/Viz/UINamespace/uiNamespaceDialog.html b/Samples/Viz/UINamespace/uiNamespaceDialog.html new file mode 100644 index 00000000..2b53b2ef --- /dev/null +++ b/Samples/Viz/UINamespace/uiNamespaceDialog.html @@ -0,0 +1,40 @@ + + + + + + + Settings Sample + + + + + + + + + + + + + + + +
+

Auto Data Source Refresh Extension

+

+ This Extension refreshes the selected datasources at the selected interval. +

+
+ +
Apply to these datasources:
+
+
+
Refresh interval in minutes:
+ + +
+ +
+ + diff --git a/Samples/Viz/UINamespace/uiNamespaceDialog.js b/Samples/Viz/UINamespace/uiNamespaceDialog.js new file mode 100644 index 00000000..c85635b1 --- /dev/null +++ b/Samples/Viz/UINamespace/uiNamespaceDialog.js @@ -0,0 +1,124 @@ +'use strict'; + +/** + * UINamespace Sample Extension + * + * This is the popup extension portion of the UINamespace sample, please see + * uiNamespace.js in addition to this for context. This extension is + * responsible for collecting configuration settings from the user and communicating + * that info back to the parent extension. + * + * This sample demonstrates two ways to do that: + * 1) The suggested and most common method is to store the information + * via the settings namespace. The parent can subscribe to notifications when + * the settings are updated, and collect the new info accordingly. + * 2) The popup extension can receive and send a string payload via the open + * and close payloads of initializeDialogAsync and closeDialog methods. This is useful + * for information that does not need to be persisted into settings. + */ + +// Wrap everything in an anonymous function to avoid polluting the global namespace +(function () { + /** + * This extension collects the IDs of each datasource the user is interested in + * and stores this information in settings when the popup is closed. + */ + const datasourcesSettingsKey = 'selectedDatasources'; + let selectedDatasources = []; + + $(document).ready(function () { + // The only difference between an extension in a worksheet and an extension + // running in a popup is that the popup extension must use the method + // initializeDialogAsync instead of initializeAsync for initialization. + // This has no affect on the development of the extension but is used internally. + tableau.extensions.initializeDialogAsync().then(function (openPayload) { + // The openPayload sent from the parent extension in this sample is the + // default time interval for the refreshes. This could alternatively be stored + // in settings, but is used in this sample to demonstrate open and close payloads. + $('#interval').val(openPayload); + $('#closeButton').click(closeDialog); + + const worksheet = tableau.extensions.worksheetContent.worksheet; + const visibleDatasources = []; + selectedDatasources = parseSettingsForActiveDataSources(); + + // Loop through datasources in this sheet and create a checkbox UI + // element for each one. The existing settings are used to + // determine whether a datasource is checked by default or not. + worksheet.getDataSourcesAsync().then(function (datasources) { + datasources.forEach(function (datasource) { + const isActive = selectedDatasources.indexOf(datasource.id) >= 0; + + if (visibleDatasources.indexOf(datasource.id) < 0) { + addDataSourceItemToUI(datasource, isActive); + visibleDatasources.push(datasource.id); + } + }); + }); + }); + }); + + /** + * Helper that parses the settings from the settings namesapce and + * returns a list of IDs of the datasources that were previously + * selected by the user. + */ + function parseSettingsForActiveDataSources () { + let activeDatasourceIdList = []; + const settings = tableau.extensions.settings.getAll(); + if (settings.selectedDatasources) { + activeDatasourceIdList = JSON.parse(settings.selectedDatasources); + } + + return activeDatasourceIdList; + } + + /** + * Helper that updates the internal storage of datasource IDs + * any time a datasource checkbox item is toggled. + */ + function updateDatasourceList (id) { + const idIndex = selectedDatasources.indexOf(id); + if (idIndex < 0) { + selectedDatasources.push(id); + } else { + selectedDatasources.splice(idIndex, 1); + } + } + + /** + * UI helper that adds a checkbox item to the UI for a datasource. + */ + function addDataSourceItemToUI (datasource, isActive) { + const containerDiv = $('
'); + + $('', { + type: 'checkbox', + id: datasource.id, + value: datasource.name, + checked: isActive, + click: function () { + updateDatasourceList(datasource.id); + } + }).appendTo(containerDiv); + + $('
@@ -129,6 +140,9 @@

Discrete

  • Discrete
    • +
  • + Unknown +
    • diff --git a/docs/enums/tableau.dashboardlayoutchange.html b/docs/enums/tableau.dashboardlayoutchange.html index fa60b4dd..e0be1f82 100644 --- a/docs/enums/tableau.dashboardlayoutchange.html +++ b/docs/enums/tableau.dashboardlayoutchange.html @@ -104,7 +104,7 @@

    Added

    Added: = "added"
    @@ -119,7 +119,7 @@

    DashboardChanged

    DashboardChanged: = "dashboard-changed"
    @@ -134,7 +134,7 @@

    Deselected

    Deselected: = "deselected"
    @@ -149,7 +149,7 @@

    IsFloatingChanged

    IsFloatingChanged: = "is-floating-changed"
    @@ -164,7 +164,7 @@

    IsVisibleChanged

    IsVisibleChanged: = "is-visible-changed"
    @@ -179,7 +179,7 @@

    NameChanged

    NameChanged: = "name-changed"
    @@ -194,7 +194,7 @@

    PositionChanged

    PositionChanged: = "position-changed"
    @@ -209,7 +209,7 @@

    Removed

    Removed: = "removed"
    @@ -224,7 +224,7 @@

    Selected

    Selected: = "selected"
    @@ -239,7 +239,7 @@

    SizeChanged

    SizeChanged: = "size-changed"
    diff --git a/docs/enums/tableau.dashboardobjecttype.html b/docs/enums/tableau.dashboardobjecttype.html index d3ec7f50..4f89958d 100644 --- a/docs/enums/tableau.dashboardobjecttype.html +++ b/docs/enums/tableau.dashboardobjecttype.html @@ -105,7 +105,7 @@

    Blank

    Blank: = "blank"
    @@ -115,7 +115,7 @@

    Extension

    Extension: = "extension"
    @@ -125,7 +125,7 @@

    Image

    Image: = "image"
    @@ -135,7 +135,7 @@

    Legend

    Legend: = "legend"
    @@ -145,7 +145,7 @@

    PageFilter

    PageFilter: = "page-filter"
    @@ -155,7 +155,7 @@

    ParameterControl

    ParameterControl: = "parameter-control"
    @@ -165,7 +165,7 @@

    QuickFilter

    QuickFilter: = "quick-filter"
    @@ -175,7 +175,7 @@

    Text

    Text: = "text"
    @@ -185,7 +185,7 @@

    Title

    Title: = "title"
    @@ -195,7 +195,7 @@

    WebPage

    WebPage: = "web-page"
    @@ -205,7 +205,7 @@

    Worksheet

    Worksheet: = "worksheet"
    diff --git a/docs/enums/tableau.dashboardobjectvisibilitytype.html b/docs/enums/tableau.dashboardobjectvisibilitytype.html index 2d035c56..b2ee1945 100644 --- a/docs/enums/tableau.dashboardobjectvisibilitytype.html +++ b/docs/enums/tableau.dashboardobjectvisibilitytype.html @@ -101,7 +101,7 @@

    Hide

    Hide: = "hide"
    @@ -116,7 +116,7 @@

    Show

    Show: = "show"
    diff --git a/docs/enums/tableau.datatype.html b/docs/enums/tableau.datatype.html index a6d7e532..3c1b1ea8 100644 --- a/docs/enums/tableau.datatype.html +++ b/docs/enums/tableau.datatype.html @@ -102,7 +102,7 @@

    Bool

    Bool: = "bool"
    @@ -112,7 +112,7 @@

    Date

    Date: = "date"
    @@ -122,7 +122,7 @@

    DateTime

    DateTime: = "date-time"
    @@ -132,7 +132,7 @@

    Float

    Float: = "float"
    @@ -142,7 +142,7 @@

    Int

    Int: = "int"
    @@ -152,7 +152,7 @@

    Spatial

    Spatial: = "spatial"
    @@ -162,7 +162,7 @@

    String

    String: = "string"
    @@ -172,7 +172,7 @@

    Unknown

    Unknown: = "unknown"
    diff --git a/docs/enums/tableau.daterangetype.html b/docs/enums/tableau.daterangetype.html index bad2fc8e..2aabec23 100644 --- a/docs/enums/tableau.daterangetype.html +++ b/docs/enums/tableau.daterangetype.html @@ -100,7 +100,7 @@

    Current

    Current: = "current"
    @@ -110,7 +110,7 @@

    Last

    Last: = "last"
    @@ -120,7 +120,7 @@

    LastN

    LastN: = "last-n"
    @@ -130,7 +130,7 @@

    Next

    Next: = "next"
    @@ -140,7 +140,7 @@

    NextN

    NextN: = "next-n"
    @@ -150,7 +150,7 @@

    ToDate

    ToDate: = "to-date"
    diff --git a/docs/enums/tableau.dialogstyle.html b/docs/enums/tableau.dialogstyle.html index d222b6bd..25e02133 100644 --- a/docs/enums/tableau.dialogstyle.html +++ b/docs/enums/tableau.dialogstyle.html @@ -97,7 +97,7 @@

    Modal

    Modal: = "modal"
    @@ -107,7 +107,7 @@

    Modeless

    Modeless: = "modeless"
    @@ -117,7 +117,7 @@

    Window

    Window: = "window"
    diff --git a/docs/enums/tableau.encodingtype.html b/docs/enums/tableau.encodingtype.html index cfd76ca0..f3b64919 100644 --- a/docs/enums/tableau.encodingtype.html +++ b/docs/enums/tableau.encodingtype.html @@ -103,7 +103,7 @@

    Angle

    Angle: = "angle"
    @@ -113,7 +113,7 @@

    Color

    Color: = "color"
    @@ -123,7 +123,7 @@

    Column

    Column: = "column"
    @@ -133,7 +133,7 @@

    Custom

    Custom: = "custom"
    @@ -143,7 +143,7 @@

    Detail

    Detail: = "detail"
    @@ -153,7 +153,7 @@

    Filter

    Filter: = "filter"
    @@ -163,7 +163,7 @@

    Geometry

    Geometry: = "geometry"
    @@ -173,7 +173,7 @@

    Label

    Label: = "label"
    @@ -183,7 +183,7 @@

    MarksType

    MarksType: = "marks-type"
    @@ -193,7 +193,7 @@

    MeasureValues

    MeasureValues: = "measure-values"
    @@ -203,7 +203,7 @@

    Page

    Page: = "page"
    @@ -213,7 +213,7 @@

    Path

    Path: = "path"
    @@ -223,7 +223,7 @@

    Row

    Row: = "row"
    @@ -233,7 +233,7 @@

    Shape

    Shape: = "shape"
    @@ -243,7 +243,7 @@

    Size

    Size: = "size"
    @@ -253,7 +253,7 @@

    Tooltip

    Tooltip: = "tooltip"
    diff --git a/docs/enums/tableau.fieldaggregationtype.html b/docs/enums/tableau.fieldaggregationtype.html index da8f5623..85a32613 100644 --- a/docs/enums/tableau.fieldaggregationtype.html +++ b/docs/enums/tableau.fieldaggregationtype.html @@ -134,7 +134,7 @@

    Attr

    Attr: = "attr"
    @@ -144,7 +144,7 @@

    Avg

    Avg: = "avg"
    @@ -154,7 +154,7 @@

    Collect

    Collect: = "collect"
    @@ -164,7 +164,7 @@

    Count

    Count: = "count"
    @@ -174,7 +174,7 @@

    Countd

    Countd: = "countd"
    @@ -184,7 +184,7 @@

    Day

    Day: = "day"
    @@ -194,7 +194,7 @@

    End

    End: = "end"
    @@ -204,7 +204,7 @@

    Hour

    Hour: = "hour"
    @@ -214,7 +214,7 @@

    InOut

    InOut: = "in-out"
    @@ -224,7 +224,7 @@

    Kurtosis

    Kurtosis: = "kurtosis"
    @@ -234,7 +234,7 @@

    Max

    Max: = "max"
    @@ -244,7 +244,7 @@

    Mdy

    Mdy: = "mdy"
    @@ -254,7 +254,7 @@

    Median

    Median: = "median"
    @@ -264,7 +264,7 @@

    Min

    Min: = "min"
    @@ -274,7 +274,7 @@

    Minute

    Minute: = "minute"
    @@ -284,7 +284,7 @@

    Month

    Month: = "month"
    @@ -294,7 +294,7 @@

    MonthYear

    MonthYear: = "month-year"
    @@ -304,7 +304,7 @@

    None

    None: = "none"
    @@ -314,7 +314,7 @@

    Qtr

    Qtr: = "qtr"
    @@ -324,7 +324,7 @@

    Quart1

    Quart1: = "quart1"
    @@ -334,7 +334,7 @@

    Quart3

    Quart3: = "quart3"
    @@ -344,7 +344,7 @@

    Second

    Second: = "second"
    @@ -354,7 +354,7 @@

    Skewness

    Skewness: = "skewness"
    @@ -364,7 +364,7 @@

    Stdev

    Stdev: = "stdev"
    @@ -374,7 +374,7 @@

    Stdevp

    Stdevp: = "stdevp"
    @@ -384,7 +384,7 @@

    Sum

    Sum: = "sum"
    @@ -394,7 +394,7 @@

    TruncDay

    TruncDay: = "trunc-day"
    @@ -404,7 +404,7 @@

    TruncHour

    TruncHour: = "trunc-hour"
    @@ -414,7 +414,7 @@

    TruncMinute

    TruncMinute: = "trunc-minute"
    @@ -424,7 +424,7 @@

    TruncMonth

    TruncMonth: = "trunc-month"
    @@ -434,7 +434,7 @@

    TruncQtr

    TruncQtr: = "trunc-qtr"
    @@ -444,7 +444,7 @@

    TruncSecond

    TruncSecond: = "trunc-second"
    @@ -454,7 +454,7 @@

    TruncWeek

    TruncWeek: = "trunc-week"
    @@ -464,7 +464,7 @@

    TruncYear

    TruncYear: = "trunc-year"
    @@ -474,7 +474,7 @@

    User

    User: = "user"
    @@ -484,7 +484,7 @@

    Var

    Var: = "var"
    @@ -494,7 +494,7 @@

    Varp

    Varp: = "varp"
    @@ -504,7 +504,7 @@

    Week

    Week: = "week"
    @@ -514,7 +514,7 @@

    Weekday

    Weekday: = "weekday"
    @@ -524,7 +524,7 @@

    Year

    Year: = "year"
    diff --git a/docs/enums/tableau.fieldroletype.html b/docs/enums/tableau.fieldroletype.html index 5a71fc33..c4a2baf7 100644 --- a/docs/enums/tableau.fieldroletype.html +++ b/docs/enums/tableau.fieldroletype.html @@ -97,7 +97,7 @@

    Dimension

    Dimension: = "dimension"
    @@ -107,7 +107,7 @@

    Measure

    Measure: = "measure"
    @@ -117,7 +117,7 @@

    Unknown

    Unknown: = "unknown"
    diff --git a/docs/enums/tableau.filterdomaintype.html b/docs/enums/tableau.filterdomaintype.html index b7e5b416..e71cfe15 100644 --- a/docs/enums/tableau.filterdomaintype.html +++ b/docs/enums/tableau.filterdomaintype.html @@ -96,7 +96,7 @@

    Database

    Database: = "database"
    @@ -111,7 +111,7 @@

    Relevant

    Relevant: = "relevant"
    diff --git a/docs/enums/tableau.filternulloption.html b/docs/enums/tableau.filternulloption.html index d327c724..0cc8546c 100644 --- a/docs/enums/tableau.filternulloption.html +++ b/docs/enums/tableau.filternulloption.html @@ -98,7 +98,7 @@

    AllValues

    AllValues: = "all-values"
    @@ -108,7 +108,7 @@

    NonNullValues

    NonNullValues: = "non-null-values"
    @@ -118,7 +118,7 @@

    NullValues

    NullValues: = "null-values"
    diff --git a/docs/enums/tableau.filtertype.html b/docs/enums/tableau.filtertype.html index c3b14c80..f54c0e7d 100644 --- a/docs/enums/tableau.filtertype.html +++ b/docs/enums/tableau.filtertype.html @@ -98,7 +98,7 @@

    Categorical

    Categorical: = "categorical"
    @@ -108,7 +108,7 @@

    Hierarchical

    Hierarchical: = "hierarchical"
    @@ -118,7 +118,7 @@

    Range

    Range: = "range"
    @@ -128,7 +128,7 @@

    RelativeDate

    RelativeDate: = "relative-date"
    diff --git a/docs/enums/tableau.filterupdatetype.html b/docs/enums/tableau.filterupdatetype.html index fe24156e..6d8dc7c8 100644 --- a/docs/enums/tableau.filterupdatetype.html +++ b/docs/enums/tableau.filterupdatetype.html @@ -98,7 +98,7 @@

    Add

    Add: = "add"
    @@ -108,7 +108,7 @@

    All

    All: = "all"
    @@ -118,7 +118,7 @@

    Remove

    Remove: = "remove"
    @@ -128,7 +128,7 @@

    Replace

    Replace: = "replace"
    diff --git a/docs/enums/tableau.hierarchicallevelselectionstate.html b/docs/enums/tableau.hierarchicallevelselectionstate.html index d2954a47..bb2721e3 100644 --- a/docs/enums/tableau.hierarchicallevelselectionstate.html +++ b/docs/enums/tableau.hierarchicallevelselectionstate.html @@ -103,7 +103,7 @@

    AllSelected

    AllSelected: = "all-selected"
    @@ -113,7 +113,7 @@

    NoneSelected

    NoneSelected: = "none-selected"
    @@ -123,7 +123,7 @@

    SomeSelected

    SomeSelected: = "some-selected"
    @@ -133,7 +133,7 @@

    UnknownSelected

    UnknownSelected: = "unknown-selected"
    diff --git a/docs/enums/tableau.includedatavaluesoption.html b/docs/enums/tableau.includedatavaluesoption.html index 0c3bb475..38b83772 100644 --- a/docs/enums/tableau.includedatavaluesoption.html +++ b/docs/enums/tableau.includedatavaluesoption.html @@ -106,7 +106,7 @@

    AllValues

    AllValues: = "all-values"
    @@ -121,7 +121,7 @@

    OnlyFormattedValues

    OnlyFormattedValues: = "only-formatted-values"
    @@ -136,7 +136,7 @@

    OnlyNativeValues

    OnlyNativeValues: = "only-native-values"
    diff --git a/docs/enums/tableau.marktype.html b/docs/enums/tableau.marktype.html index ab565fcb..13b38284 100644 --- a/docs/enums/tableau.marktype.html +++ b/docs/enums/tableau.marktype.html @@ -107,7 +107,7 @@

    Area

    Area: = "area"
    @@ -117,7 +117,7 @@

    Bar

    Bar: = "bar"
    @@ -127,7 +127,7 @@

    Circle

    Circle: = "circle"
    @@ -137,7 +137,7 @@

    GanttBar

    GanttBar: = "gantt-bar"
    @@ -147,7 +147,7 @@

    Heatmap

    Heatmap: = "heatmap"
    @@ -157,7 +157,7 @@

    Line

    Line: = "line"
    @@ -167,7 +167,7 @@

    Map

    Map: = "map"
    @@ -177,7 +177,7 @@

    Pie

    Pie: = "pie"
    @@ -187,7 +187,7 @@

    Polygon

    Polygon: = "polygon"
    @@ -197,7 +197,7 @@

    Shape

    Shape: = "shape"
    @@ -207,7 +207,7 @@

    Square

    Square: = "square"
    @@ -217,7 +217,7 @@

    Text

    Text: = "text"
    @@ -227,7 +227,7 @@

    VizExtension

    VizExtension: = "viz-extension"
    diff --git a/docs/enums/tableau.parametervaluetype.html b/docs/enums/tableau.parametervaluetype.html index a363ebd6..2aab62f9 100644 --- a/docs/enums/tableau.parametervaluetype.html +++ b/docs/enums/tableau.parametervaluetype.html @@ -98,7 +98,7 @@

    All

    All: = "all"
    @@ -108,7 +108,7 @@

    List

    List: = "list"
    @@ -118,7 +118,7 @@

    Range

    Range: = "range"
    diff --git a/docs/enums/tableau.periodtype.html b/docs/enums/tableau.periodtype.html index 43f3c6a3..78f6546c 100644 --- a/docs/enums/tableau.periodtype.html +++ b/docs/enums/tableau.periodtype.html @@ -102,7 +102,7 @@

    Days

    Days: = "days"
    @@ -112,7 +112,7 @@

    Hours

    Hours: = "hours"
    @@ -122,7 +122,7 @@

    Minutes

    Minutes: = "minutes"
    @@ -132,7 +132,7 @@

    Months

    Months: = "months"
    @@ -142,7 +142,7 @@

    Quarters

    Quarters: = "quarters"
    @@ -152,7 +152,7 @@

    Seconds

    Seconds: = "seconds"
    @@ -162,7 +162,7 @@

    Weeks

    Weeks: = "weeks"
    @@ -172,7 +172,7 @@

    Years

    Years: = "years"
    diff --git a/docs/enums/tableau.quicktablecalctype.html b/docs/enums/tableau.quicktablecalctype.html index 114a1a22..e31d19bb 100644 --- a/docs/enums/tableau.quicktablecalctype.html +++ b/docs/enums/tableau.quicktablecalctype.html @@ -99,7 +99,7 @@

    CompoundGrowthRate

    CompoundGrowthRate: = "compound-growth-rate"
    @@ -109,7 +109,7 @@

    Difference

    Difference: = "difference"
    @@ -119,7 +119,7 @@

    MovingAverage

    MovingAverage: = "moving-average"
    @@ -129,7 +129,7 @@

    PercentDifference

    PercentDifference: = "percent-difference"
    @@ -139,7 +139,7 @@

    PercentOfTotal

    PercentOfTotal: = "percent-of-total"
    @@ -149,7 +149,7 @@

    Percentile

    Percentile: = "percentile"
    @@ -159,7 +159,7 @@

    Rank

    Rank: = "rank"
    @@ -169,7 +169,7 @@

    RunningTotal

    RunningTotal: = "running-total"
    @@ -179,7 +179,7 @@

    Undefined

    Undefined: = "undefined"
    @@ -189,7 +189,7 @@

    YTDGrowth

    YTDGrowth: = "ytd-growth"
    @@ -199,7 +199,7 @@

    YTDTotal

    YTDTotal: = "ytd-total"
    @@ -209,7 +209,7 @@

    YearOverYearGrowth

    YearOverYearGrowth: = "year-over-year-growth"
    diff --git a/docs/enums/tableau.replayspeedtype.html b/docs/enums/tableau.replayspeedtype.html index d6c0e6b7..affe102e 100644 --- a/docs/enums/tableau.replayspeedtype.html +++ b/docs/enums/tableau.replayspeedtype.html @@ -102,7 +102,7 @@

    Fast

    Fast: = "fast"
    @@ -117,7 +117,7 @@

    Normal

    Normal: = "normal"
    @@ -132,7 +132,7 @@

    Slow

    Slow: = "slow"
    diff --git a/docs/enums/tableau.selectionupdatetype.html b/docs/enums/tableau.selectionupdatetype.html index 0d7fba3a..37ad20ac 100644 --- a/docs/enums/tableau.selectionupdatetype.html +++ b/docs/enums/tableau.selectionupdatetype.html @@ -97,7 +97,7 @@

    Add

    Add: = "select-add"
    @@ -107,7 +107,7 @@

    Remove

    Remove: = "select-remove"
    @@ -117,7 +117,7 @@

    Replace

    Replace: = "select-replace"
    diff --git a/docs/enums/tableau.selectoptions.html b/docs/enums/tableau.selectoptions.html index fcc2db12..b19f2fa5 100644 --- a/docs/enums/tableau.selectoptions.html +++ b/docs/enums/tableau.selectoptions.html @@ -70,7 +70,7 @@

    Enumeration SelectOptions

    -

    Enum for specifying the select option for the Worksheet.selectTuplesAsync method.

    +

    Enum for specifying the select option for the extensions.Worksheet.selectTuplesAsync method.

    @@ -96,7 +96,7 @@

    Simple

    Simple: = "select-options-simple"
    @@ -111,7 +111,7 @@

    Toggle

    Toggle: = "select-options-toggle"
    diff --git a/docs/enums/tableau.sheettype.html b/docs/enums/tableau.sheettype.html index f9991a72..d87abb88 100644 --- a/docs/enums/tableau.sheettype.html +++ b/docs/enums/tableau.sheettype.html @@ -97,7 +97,7 @@

    Dashboard

    Dashboard: = "dashboard"
    @@ -107,7 +107,7 @@

    Story

    Story: = "story"
    @@ -117,7 +117,7 @@

    Worksheet

    Worksheet: = "worksheet"
    diff --git a/docs/enums/tableau.sortdirection.html b/docs/enums/tableau.sortdirection.html index a58ad064..1a47f449 100644 --- a/docs/enums/tableau.sortdirection.html +++ b/docs/enums/tableau.sortdirection.html @@ -89,7 +89,7 @@

    Decreasing

    Decreasing: = "decreasing"
    @@ -99,7 +99,7 @@

    Increasing

    Increasing: = "increasing"
    diff --git a/docs/enums/tableau.trendlinemodeltype.html b/docs/enums/tableau.trendlinemodeltype.html index a2dbc312..5aaaf691 100644 --- a/docs/enums/tableau.trendlinemodeltype.html +++ b/docs/enums/tableau.trendlinemodeltype.html @@ -91,7 +91,7 @@

    Exponential

    Exponential: = "exponential"
    @@ -101,7 +101,7 @@

    Linear

    Linear: = "linear"
    @@ -111,7 +111,7 @@

    Logarithmic

    Logarithmic: = "logarithmic"
    @@ -121,7 +121,7 @@

    Polynomial

    Polynomial: = "polynomial"
    diff --git a/docs/globals.html b/docs/globals.html index 0c025f41..b6ca1287 100644 --- a/docs/globals.html +++ b/docs/globals.html @@ -290,7 +290,7 @@

    DashboardObjectPositionAndSizeUpdateArray

    DashboardObjectPositionAndSizeUpdateArray: Array<DashboardObjectPositionAndSizeUpdate>
    @@ -305,7 +305,7 @@

    DashboardObjectVisibilityMap

    DashboardObjectVisibilityMap: Map<number, DashboardObjectVisibilityType>
    @@ -320,7 +320,7 @@

    ZoneVisibilityMap

    ZoneVisibilityMap: Map<number, ZoneVisibilityType> | object
    diff --git a/docs/interfaces/column.html b/docs/interfaces/column.html index bcd09bb0..522a243d 100644 --- a/docs/interfaces/column.html +++ b/docs/interfaces/column.html @@ -104,7 +104,7 @@

    dataType

    returns

    The data type of the column. Possible values are - float, integer, string, boolean, date, and datetime.

    + float, integer, string, boolean, date, datetime and spatial

    diff --git a/docs/interfaces/connectionsummary.html b/docs/interfaces/connectionsummary.html index cfb38d83..db2fa7d4 100644 --- a/docs/interfaces/connectionsummary.html +++ b/docs/interfaces/connectionsummary.html @@ -104,7 +104,7 @@

    id

    id: string
    @@ -121,7 +121,7 @@

    name

    name: string
    @@ -138,7 +138,7 @@

    serverURI

    serverURI: string | undefined
    @@ -157,7 +157,7 @@

    type

    type: string
    diff --git a/docs/interfaces/dashboard.html b/docs/interfaces/dashboard.html index 0e42e447..00acf240 100644 --- a/docs/interfaces/dashboard.html +++ b/docs/interfaces/dashboard.html @@ -127,7 +127,7 @@

    activeDashboardName

    activeDashboardName: string
    @@ -144,7 +144,7 @@

    activeDashboardObjectId

    activeDashboardObjectId: number
    @@ -179,7 +179,7 @@

    objects

    objects: Array<DashboardObject>
    @@ -232,7 +232,7 @@

    worksheets

    worksheets: Array<Worksheet>
    @@ -350,7 +350,7 @@

    applyFilterAsync

  • @@ -440,7 +440,7 @@

    getDashboardObjectById

  • @@ -480,7 +480,7 @@

    getFiltersAsync

  • @@ -526,7 +526,7 @@

    moveAndResizeDashboardObjectsAsync

  • @@ -618,7 +618,7 @@

    replayAnimationAsync

  • @@ -658,7 +658,7 @@

    setDashboardObjectVisibilityAsync

  • @@ -705,7 +705,7 @@

    setZoneVisibilityAsync

  • diff --git a/docs/interfaces/dashboardobject.html b/docs/interfaces/dashboardobject.html index 0b581f4d..864f4b6b 100644 --- a/docs/interfaces/dashboardobject.html +++ b/docs/interfaces/dashboardobject.html @@ -87,6 +87,7 @@

    Index

    Properties

    • dashboard
      • +
    • fieldId
    • id
    • isFloating
    • isVisible
      • @@ -108,7 +109,7 @@

      dashboard

      dashboard: Dashboard
      @@ -119,13 +120,30 @@

      dashboard

      +
      + +

      fieldId

      +
      fieldId: string | undefined
      + +
      +
      +
      returns
      +

      The field id of the dashboard object if it is a QuickFilter

      +
      +
      +
      +

      id

      id: number
      @@ -145,7 +163,7 @@

      isFloating

      isFloating: boolean
      @@ -165,7 +183,7 @@

      isVisible

      isVisible: boolean
      @@ -185,7 +203,7 @@

      name

      name: string
      @@ -205,7 +223,7 @@

      position

      position: Point
      @@ -222,7 +240,7 @@

      size

      size: Size
      @@ -239,7 +257,7 @@

      type

      type: DashboardObjectType
      @@ -256,13 +274,13 @@

      worksheet

      worksheet: Worksheet | undefined
      returns
      -

      If type returns WORKSHEET, this returns a Worksheet object, undefined otherwise.

      +

      If type returns WORKSHEET or QUICKFILTER, this returns a Worksheet object, undefined otherwise.

      @@ -287,6 +305,9 @@

      worksheet

    • dashboard
      • +
    • + fieldId +
    • id
      • diff --git a/docs/interfaces/dashboardobjectpositionandsizeupdate.html b/docs/interfaces/dashboardobjectpositionandsizeupdate.html index 0fd8b58f..18a38733 100644 --- a/docs/interfaces/dashboardobjectpositionandsizeupdate.html +++ b/docs/interfaces/dashboardobjectpositionandsizeupdate.html @@ -104,7 +104,7 @@

      dashboardObjectID

      dashboardObjectID: number
      @@ -121,7 +121,7 @@

      height

      height: number
      @@ -138,7 +138,7 @@

      width

      width: number
      @@ -155,7 +155,7 @@

      x

      x: number
      @@ -172,7 +172,7 @@

      y

      y: number
      diff --git a/docs/interfaces/datasourceunderlyingdataoptions.html b/docs/interfaces/datasourceunderlyingdataoptions.html index bb85bd11..ddd40051 100644 --- a/docs/interfaces/datasourceunderlyingdataoptions.html +++ b/docs/interfaces/datasourceunderlyingdataoptions.html @@ -104,7 +104,7 @@

      Optional columnsToInclude
      columnsToInclude: Array<string>
      @@ -119,7 +119,7 @@

      Optional columnsToInclude
      columnsToIncludeById: Array<string>
      @@ -140,7 +140,7 @@

      Optional ignoreAliasesignoreAliases: undefined | false | true

      @@ -155,7 +155,7 @@

      Optional includeData
      includeDataValuesOption: IncludeDataValuesOption
      @@ -177,7 +177,7 @@

      Optional maxRows

      maxRows: undefined | number
      diff --git a/docs/interfaces/extensions.html b/docs/interfaces/extensions.html index 4595f703..872c52bc 100644 --- a/docs/interfaces/extensions.html +++ b/docs/interfaces/extensions.html @@ -250,8 +250,9 @@

      Optional worksheetContent To access the objects in this name space, specify tableau.extensions.worksheetContent.

      -
      beta
      -
      +
      since
      +

      1.12.0 and Tableau 2024.2

      +

      diff --git a/docs/interfaces/field.html b/docs/interfaces/field.html index b590efd5..372a5be4 100644 --- a/docs/interfaces/field.html +++ b/docs/interfaces/field.html @@ -93,7 +93,7 @@

      Index

      Properties

      • aggregation
        • -
      • columnType
        • +
      • columnType
      • dataSource
      • dataType
      • description
        • @@ -101,7 +101,8 @@

        Properties

      • isCalculatedField
      • isCombinedField
      • isGenerated
        • -
      • isHidden
        • +
      • isGeospatial
        • +
      • isHidden
      • isPresentOnPublishedDatasource
      • name
      • role
        • @@ -119,7 +120,7 @@

        aggregation

        @@ -130,21 +131,20 @@

        aggregation

        -
        +

        columnType

        columnType: ColumnType
        -
        notimplemented
        -
        returns
        -

        The type of the column, either discrete or continuous.

        +

        The type of the column, either discrete or continuous. Could hold value 'Unknown'.

        @@ -155,7 +155,7 @@

        dataSource

        dataSource: DataSource
        @@ -208,7 +208,7 @@

        id

        id: string
        @@ -226,7 +226,7 @@

        isCalculatedField

        @@ -244,7 +244,7 @@

        isCombinedField

        @@ -262,7 +262,7 @@

        isGenerated

        @@ -277,13 +277,32 @@

        isGenerated

        -
        +
        + +

        isGeospatial

        +
        isGeospatial: boolean
        + +
        +
        +
        returns
        +

        True if this role has a semantic type of geospatial: e.g latitude, longitude, zipcode, City name...

        +
        +
        +
        +
        +

        isHidden

        isHidden: boolean
        @@ -301,7 +320,7 @@

        isPresentOnPublishedDatasource

        @@ -368,7 +387,7 @@

        role

      • aggregation
        • -
      • +
      • columnType
      • @@ -392,7 +411,10 @@

        role

      • isGenerated
        • -
      • +
      • + isGeospatial +
        • +
      • isHidden
      • diff --git a/docs/interfaces/fieldinstance.html b/docs/interfaces/fieldinstance.html index a95d59db..4d72d632 100644 --- a/docs/interfaces/fieldinstance.html +++ b/docs/interfaces/fieldinstance.html @@ -95,13 +95,15 @@

        Index

        Properties

        • -
        +

        columnType

        columnType: ColumnType
        returns
        -

        The type of the column, either discrete or continuous.

        +

        The type of the column, either discrete or continuous. Could hold value 'Unknown'.

        @@ -210,7 +213,7 @@

        isCalculatedField

        @@ -228,7 +231,7 @@

        isCombinedField

        @@ -246,7 +249,7 @@

        isGenerated

        @@ -261,6 +264,42 @@

        isGenerated

        +
        + +

        isGeospatial

        +
        isGeospatial: boolean
        + +
        +
        +
        returns
        +

        True if this role has a semantic type of geospatial: e.g latitude, longitude, zipcode, City name...

        +
        +
        +
        +
        +
        + +

        isHidden

        +
        isHidden: boolean
        + +
        +
        +
        returns
        +

        True if this field is hidden, false otherwise.

        +
        +
        +
        +

        isPresentOnPublishedDatasource

        @@ -268,7 +307,7 @@

        isPresentOnPublishedDatasource

        @@ -335,7 +374,7 @@

        role

      • aggregation
        • -
      • +
      • columnType
      • @@ -356,6 +395,12 @@

        role

      • isGenerated
        • +
      • + isGeospatial +
        • +
      • + isHidden +
      • isPresentOnPublishedDatasource
        • diff --git a/docs/interfaces/hierarchicallevels.html b/docs/interfaces/hierarchicallevels.html index b2a09143..7ea973ba 100644 --- a/docs/interfaces/hierarchicallevels.html +++ b/docs/interfaces/hierarchicallevels.html @@ -105,7 +105,7 @@

        levels

        levels: Array<string>
        diff --git a/docs/interfaces/logicaltable.html b/docs/interfaces/logicaltable.html index bb5bf32b..6b80bd4a 100644 --- a/docs/interfaces/logicaltable.html +++ b/docs/interfaces/logicaltable.html @@ -104,7 +104,7 @@

        caption

        caption: string
        @@ -114,7 +114,7 @@

        id

        id: string
        diff --git a/docs/interfaces/point.html b/docs/interfaces/point.html index ae4f536d..9d852ba5 100644 --- a/docs/interfaces/point.html +++ b/docs/interfaces/point.html @@ -101,7 +101,7 @@

        x

        x: number
        @@ -118,7 +118,7 @@

        y

        y: number
        diff --git a/docs/interfaces/tablesummary.html b/docs/interfaces/tablesummary.html index fd3395ad..ab89ed48 100644 --- a/docs/interfaces/tablesummary.html +++ b/docs/interfaces/tablesummary.html @@ -103,7 +103,7 @@

        connectionId

        connectionId: string
        @@ -120,7 +120,7 @@

        customSQL

        customSQL: string | undefined
        @@ -137,7 +137,7 @@

        id

        id: string
        @@ -154,7 +154,7 @@

        name

        name: string
        diff --git a/docs/interfaces/tooltipcontext.html b/docs/interfaces/tooltipcontext.html index 7731fc79..ac57c182 100644 --- a/docs/interfaces/tooltipcontext.html +++ b/docs/interfaces/tooltipcontext.html @@ -70,8 +70,9 @@

        Interface TooltipContext

        Provides the necessary information for how to display a Tableau tooltip.

        -
        experimental
        -
        +
        since
        +

        1.12.0 and Tableau 2024.2

        +
        diff --git a/docs/interfaces/worksheet.html b/docs/interfaces/worksheet.html index 8af5b6ac..797c3cbd 100644 --- a/docs/interfaces/worksheet.html +++ b/docs/interfaces/worksheet.html @@ -125,7 +125,9 @@

        All Extensions Methods

      Viz Extensions Methods

      @@ -1309,24 +1311,95 @@

      Returns Promise

      Viz Extensions Methods

      +
      + +

      getTooltipTextAsync

      +
        +
      • getTooltipTextAsync(tupleId: number): Promise<String>
        • +
      +
        +
      • + +
        +
        +

        Method to get the text of the tooltip that would be displayed for a given tuple id. Currently supported for web only.

        +
        +

        You can find the tuple id for a row of data by subtracting the index of the row from the total number of rows. + For example, if you have 10 rows, and want to know the tuple id associated with the third row, it will be 7 (10 - 3 = 7). The last row of data will always have the tuple id of 1.

        +

        Passing in an invalid tuple id will not throw. +

        + 
        let navigatedTuple = -1;
+let updateScreenReaderElement = (screenReadertext) => {
+  // updates an element to be read out by screen readers
+};
+
+let updateNavigatedTuple = (keyboardEvent) => {
+  switch (keyboardEvent.key) {
+    case 'ArrowLeft':
+      navigatedTuple = navigatedTuple - 1;
+      break;
+    case 'ArrowRight':
+      navigatedTuple = navigatedTuple + 1;
+      break;
+    default:
+      break;
+  }
+  // do any work to show visual indication of a mark being navigated to
+};
+
+svg.on('keydown', (keyboardEvent) => {
+  updateNavigatedTuple(keyboardEvent);
+  tableau.extensions.worksheetContent.worksheet
+    .getTooltipTextAsync(navigatedTuple)
+    .then((response) => {
+      console.log(response.result);
+      updateScreenReaderElement(response.result);
+    })
+    .catch((error) => console.log('Failed to get tooltip text because of: ', error));
+});
        +
        +
        since
        +

        1.12.0 and Tableau 2024.2

        +
        +
        +
        +

        Parameters

        +
          +
        • +
          tupleId: number
          +
          • +
        +

        Returns Promise<String>

        +

        Returns promise that resolves to a string describing the tooltip text for a given tuple id and rejects on error

        +
        • +
      +

      hoverTupleAsync

        -
      • hoverTupleAsync(hoveredTuple: number, tooltip?: TooltipContext): Promise<void>
        • +
      • hoverTupleAsync(hoveredTuple: number, tooltip?: TooltipContext | null, allowHoverActions?: undefined | false | true): Promise<void>

      • Method to execute hover actions and render tooltip for a given tuple representing a mark in the visualization. - If the tooltip parameter is included it will show the tooltip when the mark is hovered over. If not, no tooltip is shown.

        + If the tooltip parameter is included it will show the tooltip when the mark is hovered over. + If null or no tooltip parameter is passed, no tooltip is shown. + Hover actions are run by default, but passing false for the allowHoverActions parameter will prevent their execution.

        +

        The hoveredTuple parameter is a tuple id. You can find the tuple id for a row of data by subtracting the index of the row from the total number of rows. + For example, if you have 10 rows, and want to know the tuple id associated with the third row, it will be 7 (10 - 3 = 7). The last row of data will always have the tuple id of 1.

        Passing in an invalid tuple id will not throw and will clear the tooltip. 

        svg.on('mousemove', (mouseEvent) => {
@@ -1336,8 +1409,9 @@ 
        hoverTupleAsync
        
    .catch((error) => console.log('Failed to hover because of: ', error));
  });
        -
        experimental
        -
        +
        since
        +

        1.12.0 and Tableau 2024.2

        +

        Parameters

        @@ -1346,7 +1420,10 @@

        Parameters

        hoveredTuple: number
      • -
        Optional tooltip: TooltipContext
        +
        Optional tooltip: TooltipContext | null
        +
        • +
      • +
        Optional allowHoverActions: undefined | false | true

      Returns Promise<void>

      @@ -1354,6 +1431,45 @@

      Returns Promise

    +
    + +

    leaveMarkNavigationAsync

    +
      +
    • leaveMarkNavigationAsync(): Promise<void>
      • +
    +
      +
    • + +
      +
      +

      Notifies the scene of a desire to leave mark-level keyboard navigation and return to scene-level keyboard navigation. + Used when implementing keyboard navigation within a visualization, an integral part of building accessibility into a visualization. + Currently supported for the web only. +

      +
      + 
      svg.on('keyup', (keyboardEvent) => {
+  if (keyboardEvent.key == "Escape") {
+    tableau.extensions.worksheetContent.worksheet
+      .leaveMarkNavigationAsync()
+      .then(() => console.log('Done'))
+      .catch((error) => console.log('Failed to leave mark-level keyboard navigation because of: ', error));
+  }
+});
      +
      +
      since
      +

      1.12.0 and Tableau 2024.2

      +
      +
      +
      +

      Returns Promise<void>

      +

      Returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error

      +
      • +
    +

    selectTuplesAsync

    @@ -1364,7 +1480,7 @@

    selectTuplesAsync

  • @@ -1372,6 +1488,8 @@

    selectTuplesAsync

    Method to modify selection, execute select actions, and render tooltip for a given list of tuples representing a mark or marks in the visualization. If the tooltip parameter is included it will show the tooltip when the mark or marks are selected. If not, no tooltip is shown.

    +

    The selectedTuples parameter is an array of tuple ids. You can find the tuple id for a row of data by subtracting the index of the row from the total number of rows. + For example, if you have 10 rows, and want to know the tuple id associated with the third row, it will be 7 (10 - 3 = 7). The last row of data will always have the tuple id of 1.

    Passing in an invalid tuple id will not throw and will clear the tooltip. 

    svg.on('click', (mouseEvent) => {
@@ -1384,8 +1502,9 @@ 
    selectTuplesAsync
    
    .catch((error) => console.log('Failed to select because of: ', error));
 });
    -
    experimental
    -
    +
    since
    +

    1.12.0 and Tableau 2024.2

    +

    • Parameters

    @@ -1488,6 +1607,9 @@

    Returns Promise getSummaryDataReaderAsync

    • +
  • + getTooltipTextAsync +
  • getUnderlyingDataAsync
    • @@ -1506,6 +1628,9 @@

    Returns Promise hoverTupleAsync +
  • + leaveMarkNavigationAsync +
  • removeAnnotationAsync
    • diff --git a/docs/interfaces/worksheetcontent.html b/docs/interfaces/worksheetcontent.html index 522623c6..d36b33e6 100644 --- a/docs/interfaces/worksheetcontent.html +++ b/docs/interfaces/worksheetcontent.html @@ -72,8 +72,9 @@

    Interface WorksheetContent

    access worksheet objects and to add or remove event listeners.

    -
    beta
    -
    +
    since
    +

    1.12.0 and Tableau 2024.2

    +
    diff --git a/docs/modules/tableau.html b/docs/modules/tableau.html index e1711016..92e10582 100644 --- a/docs/modules/tableau.html +++ b/docs/modules/tableau.html @@ -148,7 +148,7 @@

    ZoneVisibilityType

    ZoneVisibilityType: DashboardObjectVisibilityType
    @@ -184,7 +184,7 @@

    Const ZoneVisibilityTyp
    ZoneVisibilityType: object
    diff --git a/lib/tableau.extensions.1.11.0-pre.63.min.js.map b/lib/previous/tableau.extensions.1.11.0-pre.63.min.js.map similarity index 100% rename from lib/tableau.extensions.1.11.0-pre.63.min.js.map rename to lib/previous/tableau.extensions.1.11.0-pre.63.min.js.map diff --git a/lib/tableau.extensions.1.11.0.js b/lib/previous/tableau.extensions.1.11.0.js similarity index 100% rename from lib/tableau.extensions.1.11.0.js rename to lib/previous/tableau.extensions.1.11.0.js diff --git a/lib/tableau.extensions.1.11.0.min.js b/lib/previous/tableau.extensions.1.11.0.min.js similarity index 100% rename from lib/tableau.extensions.1.11.0.min.js rename to lib/previous/tableau.extensions.1.11.0.min.js diff --git a/lib/tableau.extensions.1.12.0-pre.16.min.js.map b/lib/tableau.extensions.1.12.0-pre.16.min.js.map new file mode 100644 index 00000000..9e584714 --- /dev/null +++ b/lib/tableau.extensions.1.12.0-pre.16.min.js.map @@ -0,0 +1 @@ +{"version":3,"file":"tableau.extensions.1.12.0-pre.16.min.js","mappings":"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","sources":["webpack://tableau/../../node_modules/core-js/es/array/find.js","webpack://tableau/../../node_modules/core-js/es/array/from.js","webpack://tableau/../../node_modules/core-js/es/map/index.js","webpack://tableau/../../node_modules/core-js/es/number/is-integer.js","webpack://tableau/../../node_modules/core-js/es/number/is-nan.js","webpack://tableau/../../node_modules/core-js/es/number/parse-float.js","webpack://tableau/../../node_modules/core-js/es/number/parse-int.js","webpack://tableau/../../node_modules/core-js/es/object/assign.js","webpack://tableau/../../node_modules/core-js/es/object/entries.js","webpack://tableau/../../node_modules/core-js/es/object/set-prototype-of.js","webpack://tableau/../../node_modules/core-js/es/promise/index.js","webpack://tableau/../../node_modules/core-js/internals/a-callable.js","webpack://tableau/../../node_modules/core-js/internals/a-constructor.js","webpack://tableau/../../node_modules/core-js/internals/a-possible-prototype.js","webpack://tableau/../../node_modules/core-js/internals/add-to-unscopables.js","webpack://tableau/../../node_modules/core-js/internals/an-instance.js","webpack://tableau/../../node_modules/core-js/internals/an-object.js","webpack://tableau/../../node_modules/core-js/internals/array-from.js","webpack://tableau/../../node_modules/core-js/internals/array-includes.js","webpack://tableau/../../node_modules/core-js/internals/array-iteration.js","webpack://tableau/../../node_modules/core-js/internals/array-slice.js","webpack://tableau/../../node_modules/core-js/internals/array-species-constructor.js","webpack://tableau/../../node_modules/core-js/internals/array-species-create.js","webpack://tableau/../../node_modules/core-js/internals/call-with-safe-iteration-closing.js","webpack://tableau/../../node_modules/core-js/internals/check-correctness-of-iteration.js","webpack://tableau/../../node_modules/core-js/internals/classof-raw.js","webpack://tableau/../../node_modules/core-js/internals/classof.js","webpack://tableau/../../node_modules/core-js/internals/clear-error-stack.js","webpack://tableau/../../node_modules/core-js/internals/collection-strong.js","webpack://tableau/../../node_modules/core-js/internals/collection.js","webpack://tableau/../../node_modules/core-js/internals/copy-constructor-properties.js","webpack://tableau/../../node_modules/core-js/internals/correct-prototype-getter.js","webpack://tableau/../../node_modules/core-js/internals/create-iterator-constructor.js","webpack://tableau/../../node_modules/core-js/internals/create-non-enumerable-property.js","webpack://tableau/../../node_modules/core-js/internals/create-property-descriptor.js","webpack://tableau/../../node_modules/core-js/internals/create-property.js","webpack://tableau/../../node_modules/core-js/internals/define-iterator.js","webpack://tableau/../../node_modules/core-js/internals/descriptors.js","webpack://tableau/../../node_modules/core-js/internals/document-create-element.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-browser.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-ios-pebble.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-ios.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-node.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-webos-webkit.js","webpack://tableau/../../node_modules/core-js/internals/engine-user-agent.js","webpack://tableau/../../node_modules/core-js/internals/engine-v8-version.js","webpack://tableau/../../node_modules/core-js/internals/entry-unbind.js","webpack://tableau/../../node_modules/core-js/internals/enum-bug-keys.js","webpack://tableau/../../node_modules/core-js/internals/error-stack-installable.js","webpack://tableau/../../node_modules/core-js/internals/export.js","webpack://tableau/../../node_modules/core-js/internals/fails.js","webpack://tableau/../../node_modules/core-js/internals/freezing.js","webpack://tableau/../../node_modules/core-js/internals/function-apply.js","webpack://tableau/../../node_modules/core-js/internals/function-bind-context.js","webpack://tableau/../../node_modules/core-js/internals/function-call.js","webpack://tableau/../../node_modules/core-js/internals/function-name.js","webpack://tableau/../../node_modules/core-js/internals/function-uncurry-this.js","webpack://tableau/../../node_modules/core-js/internals/get-built-in.js","webpack://tableau/../../node_modules/core-js/internals/get-iterator-method.js","webpack://tableau/../../node_modules/core-js/internals/get-iterator.js","webpack://tableau/../../node_modules/core-js/internals/get-method.js","webpack://tableau/../../node_modules/core-js/internals/global.js","webpack://tableau/../../node_modules/core-js/internals/has-own-property.js","webpack://tableau/../../node_modules/core-js/internals/hidden-keys.js","webpack://tableau/../../node_modules/core-js/internals/host-report-errors.js","webpack://tableau/../../node_modules/core-js/internals/html.js","webpack://tableau/../../node_modules/core-js/internals/ie8-dom-define.js","webpack://tableau/../../node_modules/core-js/internals/indexed-object.js","webpack://tableau/../../node_modules/core-js/internals/inherit-if-required.js","webpack://tableau/../../node_modules/core-js/internals/inspect-source.js","webpack://tableau/../../node_modules/core-js/internals/install-error-cause.js","webpack://tableau/../../node_modules/core-js/internals/internal-metadata.js","webpack://tableau/../../node_modules/core-js/internals/internal-state.js","webpack://tableau/../../node_modules/core-js/internals/is-array-iterator-method.js","webpack://tableau/../../node_modules/core-js/internals/is-array.js","webpack://tableau/../../node_modules/core-js/internals/is-callable.js","webpack://tableau/../../node_modules/core-js/internals/is-constructor.js","webpack://tableau/../../node_modules/core-js/internals/is-forced.js","webpack://tableau/../../node_modules/core-js/internals/is-integral-number.js","webpack://tableau/../../node_modules/core-js/internals/is-object.js","webpack://tableau/../../node_modules/core-js/internals/is-pure.js","webpack://tableau/../../node_modules/core-js/internals/is-symbol.js","webpack://tableau/../../node_modules/core-js/internals/iterate.js","webpack://tableau/../../node_modules/core-js/internals/iterator-close.js","webpack://tableau/../../node_modules/core-js/internals/iterators-core.js","webpack://tableau/../../node_modules/core-js/internals/iterators.js","webpack://tableau/../../node_modules/core-js/internals/length-of-array-like.js","webpack://tableau/../../node_modules/core-js/internals/microtask.js","webpack://tableau/../../node_modules/core-js/internals/native-promise-constructor.js","webpack://tableau/../../node_modules/core-js/internals/native-symbol.js","webpack://tableau/../../node_modules/core-js/internals/native-weak-map.js","webpack://tableau/../../node_modules/core-js/internals/new-promise-capability.js","webpack://tableau/../../node_modules/core-js/internals/normalize-string-argument.js","webpack://tableau/../../node_modules/core-js/internals/number-parse-float.js","webpack://tableau/../../node_modules/core-js/internals/number-parse-int.js","webpack://tableau/../../node_modules/core-js/internals/object-assign.js","webpack://tableau/../../node_modules/core-js/internals/object-create.js","webpack://tableau/../../node_modules/core-js/internals/object-define-properties.js","webpack://tableau/../../node_modules/core-js/internals/object-define-property.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-descriptor.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-names-external.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-names.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-symbols.js","webpack://tableau/../../node_modules/core-js/internals/object-get-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-is-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-keys-internal.js","webpack://tableau/../../node_modules/core-js/internals/object-keys.js","webpack://tableau/../../node_modules/core-js/internals/object-property-is-enumerable.js","webpack://tableau/../../node_modules/core-js/internals/object-set-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-to-array.js","webpack://tableau/../../node_modules/core-js/internals/object-to-string.js","webpack://tableau/../../node_modules/core-js/internals/ordinary-to-primitive.js","webpack://tableau/../../node_modules/core-js/internals/own-keys.js","webpack://tableau/../../node_modules/core-js/internals/path.js","webpack://tableau/../../node_modules/core-js/internals/perform.js","webpack://tableau/../../node_modules/core-js/internals/promise-resolve.js","webpack://tableau/../../node_modules/core-js/internals/redefine-all.js","webpack://tableau/../../node_modules/core-js/internals/redefine.js","webpack://tableau/../../node_modules/core-js/internals/require-object-coercible.js","webpack://tableau/../../node_modules/core-js/internals/set-global.js","webpack://tableau/../../node_modules/core-js/internals/set-species.js","webpack://tableau/../../node_modules/core-js/internals/set-to-string-tag.js","webpack://tableau/../../node_modules/core-js/internals/shared-key.js","webpack://tableau/../../node_modules/core-js/internals/shared-store.js","webpack://tableau/../../node_modules/core-js/internals/shared.js","webpack://tableau/../../node_modules/core-js/internals/species-constructor.js","webpack://tableau/../../node_modules/core-js/internals/string-multibyte.js","webpack://tableau/../../node_modules/core-js/internals/string-trim.js","webpack://tableau/../../node_modules/core-js/internals/task.js","webpack://tableau/../../node_modules/core-js/internals/to-absolute-index.js","webpack://tableau/../../node_modules/core-js/internals/to-indexed-object.js","webpack://tableau/../../node_modules/core-js/internals/to-integer-or-infinity.js","webpack://tableau/../../node_modules/core-js/internals/to-length.js","webpack://tableau/../../node_modules/core-js/internals/to-object.js","webpack://tableau/../../node_modules/core-js/internals/to-primitive.js","webpack://tableau/../../node_modules/core-js/internals/to-property-key.js","webpack://tableau/../../node_modules/core-js/internals/to-string-tag-support.js","webpack://tableau/../../node_modules/core-js/internals/to-string.js","webpack://tableau/../../node_modules/core-js/internals/try-to-string.js","webpack://tableau/../../node_modules/core-js/internals/uid.js","webpack://tableau/../../node_modules/core-js/internals/use-symbol-as-uid.js","webpack://tableau/../../node_modules/core-js/internals/well-known-symbol.js","webpack://tableau/../../node_modules/core-js/internals/whitespaces.js","webpack://tableau/../../node_modules/core-js/modules/es.aggregate-error.js","webpack://tableau/../../node_modules/core-js/modules/es.array.find.js","webpack://tableau/../../node_modules/core-js/modules/es.array.from.js","webpack://tableau/../../node_modules/core-js/modules/es.array.iterator.js","webpack://tableau/../../node_modules/core-js/modules/es.map.js","webpack://tableau/../../node_modules/core-js/modules/es.number.is-integer.js","webpack://tableau/../../node_modules/core-js/modules/es.number.is-nan.js","webpack://tableau/../../node_modules/core-js/modules/es.number.parse-float.js","webpack://tableau/../../node_modules/core-js/modules/es.number.parse-int.js","webpack://tableau/../../node_modules/core-js/modules/es.object.assign.js","webpack://tableau/../../node_modules/core-js/modules/es.object.entries.js","webpack://tableau/../../node_modules/core-js/modules/es.object.set-prototype-of.js","webpack://tableau/../../node_modules/core-js/modules/es.object.to-string.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.all-settled.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.any.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.finally.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.js","webpack://tableau/../../node_modules/core-js/modules/es.string.iterator.js","webpack://tableau/../../node_modules/guid/guid.js","webpack://tableau/./lib/src/ExtensionsApi/Events/DashboardLayoutChangedEvent.js","webpack://tableau/./lib/src/ExtensionsApi/Events/FilterChangedEvent.js","webpack://tableau/./lib/src/ExtensionsApi/Events/MarksSelectedEvent.js","webpack://tableau/./lib/src/ExtensionsApi/Events/ParameterChangedEvent.js","webpack://tableau/./lib/src/ExtensionsApi/Events/SummaryDataChangedEvent.js","webpack://tableau/./lib/src/ExtensionsApi/Events/TableauEvent.js","webpack://tableau/./lib/src/ExtensionsApi/Events/TableauSheetEvent.js","webpack://tableau/./lib/src/ExtensionsApi/Events/TableauWorksheetEvent.js","webpack://tableau/./lib/src/ExtensionsApi/Events/WorkbookFormattingChangedEvent.js","webpack://tableau/./lib/src/ExtensionsApi/Impl/BentonSansFontNameConstants.js","webpack://tableau/./lib/src/ExtensionsApi/Impl/ConnectedServer.js","webpack://tableau/./lib/src/ExtensionsApi/Impl/ExtensionWorkbookImpl.js","webpack://tableau/./lib/src/ExtensionsApi/Impl/ExtensionsImpl.js","webpack://tableau/./lib/src/ExtensionsApi/Impl/LegacyInternalApiDispatcherHolder.js","webpack://tableau/./lib/src/ExtensionsApi/Impl/SettingsImpl.js","webpack://tableau/./lib/src/ExtensionsApi/Impl/TableauBookFontNameConstants.js","webpack://tableau/./lib/src/ExtensionsApi/Impl/UIImpl.js","webpack://tableau/./lib/src/ExtensionsApi/Models/Dashboard.js","webpack://tableau/./lib/src/ExtensionsApi/Models/DashboardObject.js","webpack://tableau/./lib/src/ExtensionsApi/Models/Parameter.js","webpack://tableau/./lib/src/ExtensionsApi/Models/Sheet.js","webpack://tableau/./lib/src/ExtensionsApi/Models/Workbook.js","webpack://tableau/./lib/src/ExtensionsApi/Models/Worksheet.js","webpack://tableau/./lib/src/ExtensionsApi/Namespaces/DashboardContent.js","webpack://tableau/./lib/src/ExtensionsApi/Namespaces/Environment.js","webpack://tableau/./lib/src/ExtensionsApi/Namespaces/Extensions.js","webpack://tableau/./lib/src/ExtensionsApi/Namespaces/Settings.js","webpack://tableau/./lib/src/ExtensionsApi/Namespaces/UI.js","webpack://tableau/./lib/src/ExtensionsApi/Namespaces/WorkbookFormattingEnvUtil.js","webpack://tableau/./lib/src/ExtensionsApi/Namespaces/WorksheetContent.js","webpack://tableau/./lib/src/ExtensionsApi/Services/Impl/InitializationServiceImpl.js","webpack://tableau/./lib/src/ExtensionsApi/Services/Impl/SettingsServiceImpl.js","webpack://tableau/./lib/src/ExtensionsApi/Services/Impl/UIServiceImpl.js","webpack://tableau/./lib/src/ExtensionsApi/Services/RegisterAllExtensionsServices.js","webpack://tableau/./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js","webpack://tableau/../api-external-contract-js/lib/src/EmbeddingApiExternalContract.js","webpack://tableau/../api-external-contract-js/lib/src/ExtensionsApiExternalContract.js","webpack://tableau/../api-external-contract-js/lib/src/ExternalContract.js","webpack://tableau/../api-external-contract-js/lib/src/ExternalContract/Embedding/AskDataInterfaces.js","webpack://tableau/../api-external-contract-js/lib/src/ExternalContract/Embedding/Enums.js","webpack://tableau/../api-external-contract-js/lib/src/ExternalContract/Embedding/PulseInterfaces.js","webpack://tableau/../api-external-contract-js/lib/src/ExternalContract/Embedding/VizInterfaces.js","webpack://tableau/../api-external-contract-js/lib/src/ExternalContract/Embedding/WebComponentInterfaces.js","webpack://tableau/../api-external-contract-js/lib/src/ExternalContract/Extensions/Namespaces/Tableau.js","webpack://tableau/../api-external-contract-js/lib/src/ExternalContract/Shared/Enums.js","webpack://tableau/../api-external-contract-js/lib/src/ExternalContract/Shared/Namespaces/Tableau.js","webpack://tableau/../api-external-contract-js/lib/src/SharedApiExternalContract.js","webpack://tableau/../api-internal-contract-js/lib/src/JsApiInternalContract.js","webpack://tableau/../api-internal-contract-js/lib/src/contract/DataTypeConverter.js","webpack://tableau/../api-internal-contract-js/lib/src/contract/Enums.js","webpack://tableau/../api-internal-contract-js/lib/src/contract/Notifications.js","webpack://tableau/../api-internal-contract-js/lib/src/contract/Parameters.js","webpack://tableau/../api-internal-contract-js/lib/src/contract/Verbs.js","webpack://tableau/../api-internal-contract-js/lib/src/interface/AskDataInterface.js","webpack://tableau/../api-internal-contract-js/lib/src/interface/PulseInterface.js","webpack://tableau/../api-internal-contract-js/lib/src/interface/VqlInterface.js","webpack://tableau/../api-internal-contract-js/lib/src/messaging/CrossFrameMessenger.js","webpack://tableau/../api-internal-contract-js/lib/src/messaging/CrossFramePreparedMessage.js","webpack://tableau/../api-internal-contract-js/lib/src/messaging/MessageTypeChecks.js","webpack://tableau/../api-internal-contract-js/lib/src/messaging/interface/MessageTypes.js","webpack://tableau/../api-internal-contract-js/lib/src/versioning/IdentityVersionConverter.js","webpack://tableau/../api-internal-contract-js/lib/src/versioning/StackingVersionConverter.js","webpack://tableau/../api-internal-contract-js/lib/src/versioning/VersionConverterFactory.js","webpack://tableau/../api-internal-contract-js/lib/src/versioning/VersionTranslations.js","webpack://tableau/../api-internal-contract-js/lib/src/versioning/external/ExternalIdentityVersionConverter.js","webpack://tableau/../api-internal-contract-js/lib/src/versioning/external/ExternalStackingVersionConverter.js","webpack://tableau/../api-internal-contract-js/lib/src/versioning/external/ExternalVersionConverterFactory.js","webpack://tableau/../api-internal-contract-js/lib/src/versioning/external/ExternalVersionTranslations.js","webpack://tableau/../api-shared-js/lib/src/ApiShared.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/ApiVersion.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/ConnectionSummary.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/CrossFrame/CrossFrameBootstrap.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/CrossFrame/CrossFrameDispatcher.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/DataSource.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/EventListenerManager.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Field.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/CustomViewImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/DashboardImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/DashboardObjectImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/DataSourceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/FieldImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/ParameterImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/SheetImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/SheetInfoImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/SingleEventManagerImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/StoryImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/StoryPointImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/StoryPointInfoImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/WorkbookImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Impl/WorksheetImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/LogicalTable.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Models/AccessibilityModels.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Models/FilterModels.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Models/GetDataModels.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Models/GetDataTableReaderModels.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Models/SelectionModels.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Point.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/GetDataService.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/RegisterAllSharedServices.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/AccessibilityServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/AnimationServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/AnnotationServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/ClientInfoServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/DataSourceServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/ExportServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/ExternalContextMenuServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/FilterServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/GetDataServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/NotificationServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/NotificationServiceImplBase.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/ParametersServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/SelectionServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/SizeServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/StoryActivationServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/VisualModelServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/VizServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Services/impl/ZoneServiceImpl.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/TableSummary.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/TableauError.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Utils/DataValueFactory.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Utils/Deferred.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Utils/EnumConverter.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Utils/ExportHelpers.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Utils/Param.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Utils/SheetUtils.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/Utils/ShortLivedDeferred.js","webpack://tableau/../api-shared-js/lib/src/ApiShared/VersionNumber.js","webpack://tableau/../api-shared-js/lib/src/VersionedExternalApiDispatcher.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/rng.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/regex.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/validate.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v1.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/parse.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v35.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/md5.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v3.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v4.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/sha1.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v5.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/nil.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/version.js","webpack://tableau/webpack/bootstrap","webpack://tableau/webpack/runtime/define property getters","webpack://tableau/webpack/runtime/global","webpack://tableau/webpack/runtime/hasOwnProperty shorthand","webpack://tableau/webpack/runtime/make namespace object","webpack://tableau/./lib/src/ExtensionsApi.js"],"sourcesContent":["require('../../modules/es.array.find');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('Array', 'find');\n","require('../../modules/es.string.iterator');\nrequire('../../modules/es.array.from');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Array.from;\n","require('../../modules/es.array.iterator');\nrequire('../../modules/es.map');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Map;\n","require('../../modules/es.number.is-integer');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.isInteger;\n","require('../../modules/es.number.is-nan');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.isNaN;\n","require('../../modules/es.number.parse-float');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.parseFloat;\n","require('../../modules/es.number.parse-int');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.parseInt;\n","require('../../modules/es.object.assign');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.assign;\n","require('../../modules/es.object.entries');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.entries;\n","require('../../modules/es.object.set-prototype-of');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.setPrototypeOf;\n","require('../../modules/es.aggregate-error');\nrequire('../../modules/es.array.iterator');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.promise');\nrequire('../../modules/es.promise.all-settled');\nrequire('../../modules/es.promise.any');\nrequire('../../modules/es.promise.finally');\nrequire('../../modules/es.string.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Promise;\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar TypeError = global.TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw TypeError(tryToString(argument) + ' is not a function');\n};\n","var global = require('../internals/global');\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar TypeError = global.TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw TypeError(tryToString(argument) + ' is not a constructor');\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar String = global.String;\nvar TypeError = global.TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw TypeError(\"Can't set \" + String(argument) + ' as a prototype');\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n configurable: true,\n value: create(null)\n });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","var global = require('../internals/global');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar TypeError = global.TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw TypeError('Incorrect invocation');\n};\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar String = global.String;\nvar TypeError = global.TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw TypeError(String(argument) + ' is not an object');\n};\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar toObject = require('../internals/to-object');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar isConstructor = require('../internals/is-constructor');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar Array = global.Array;\n\n// `Array.from` method implementation\n// https://tc39.es/ecma262/#sec-array.from\nmodule.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n var O = toObject(arrayLike);\n var IS_CONSTRUCTOR = isConstructor(this);\n var argumentsLength = arguments.length;\n var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n var mapping = mapfn !== undefined;\n if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);\n var iteratorMethod = getIteratorMethod(O);\n var index = 0;\n var length, result, step, iterator, next, value;\n // if the target is not iterable or it's an array with the default iterator - use a simple case\n if (iteratorMethod && !(this == Array && isArrayIteratorMethod(iteratorMethod))) {\n iterator = getIterator(O, iteratorMethod);\n next = iterator.next;\n result = IS_CONSTRUCTOR ? new this() : [];\n for (;!(step = call(next, iterator)).done; index++) {\n value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;\n createProperty(result, index, value);\n }\n } else {\n length = lengthOfArrayLike(O);\n result = IS_CONSTRUCTOR ? new this(length) : Array(length);\n for (;length > index; index++) {\n value = mapping ? mapfn(O[index], index) : O[index];\n createProperty(result, index, value);\n }\n }\n result.length = index;\n return result;\n};\n","var toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el != el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value != value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","var bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n var IS_MAP = TYPE == 1;\n var IS_FILTER = TYPE == 2;\n var IS_SOME = TYPE == 3;\n var IS_EVERY = TYPE == 4;\n var IS_FIND_INDEX = TYPE == 6;\n var IS_FILTER_REJECT = TYPE == 7;\n var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;\n return function ($this, callbackfn, that, specificCreate) {\n var O = toObject($this);\n var self = IndexedObject(O);\n var boundFunction = bind(callbackfn, that);\n var length = lengthOfArrayLike(self);\n var index = 0;\n var create = specificCreate || arraySpeciesCreate;\n var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n var value, result;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n value = self[index];\n result = boundFunction(value, index, O);\n if (TYPE) {\n if (IS_MAP) target[index] = result; // map\n else if (result) switch (TYPE) {\n case 3: return true; // some\n case 5: return value; // find\n case 6: return index; // findIndex\n case 2: push(target, value); // filter\n } else switch (TYPE) {\n case 4: return false; // every\n case 7: push(target, value); // filterReject\n }\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.forEach` method\n // https://tc39.es/ecma262/#sec-array.prototype.foreach\n forEach: createMethod(0),\n // `Array.prototype.map` method\n // https://tc39.es/ecma262/#sec-array.prototype.map\n map: createMethod(1),\n // `Array.prototype.filter` method\n // https://tc39.es/ecma262/#sec-array.prototype.filter\n filter: createMethod(2),\n // `Array.prototype.some` method\n // https://tc39.es/ecma262/#sec-array.prototype.some\n some: createMethod(3),\n // `Array.prototype.every` method\n // https://tc39.es/ecma262/#sec-array.prototype.every\n every: createMethod(4),\n // `Array.prototype.find` method\n // https://tc39.es/ecma262/#sec-array.prototype.find\n find: createMethod(5),\n // `Array.prototype.findIndex` method\n // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n findIndex: createMethod(6),\n // `Array.prototype.filterReject` method\n // https://github.com/tc39/proposal-array-filtering\n filterReject: createMethod(7)\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","var global = require('../internals/global');\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar Array = global.Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n var C;\n if (isArray(originalArray)) {\n C = originalArray.constructor;\n // cross-realm fallback\n if (isConstructor(C) && (C === Array || isArray(C.prototype))) C = undefined;\n else if (isObject(C)) {\n C = C[SPECIES];\n if (C === null) C = undefined;\n }\n } return C === undefined ? Array : C;\n};\n","var arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","var anObject = require('../internals/an-object');\nvar iteratorClose = require('../internals/iterator-close');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n try {\n return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","var global = require('../internals/global');\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar Object = global.Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar arraySlice = require('../internals/array-slice');\n\nvar replace = uncurryThis(''.replace);\nvar split = uncurryThis(''.split);\nvar join = uncurryThis([].join);\n\nvar TEST = (function (arg) { return String(Error(arg).stack); })('zxcasd');\nvar V8_OR_CHAKRA_STACK_ENTRY = /\\n\\s*at [^:]*:[^\\n]*/;\nvar IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);\nvar IS_FIREFOX_OR_SAFARI_STACK = /@[^\\n]*\\n/.test(TEST) && !/zxcasd/.test(TEST);\n\nmodule.exports = function (stack, dropEntries) {\n if (typeof stack != 'string') return stack;\n if (IS_V8_OR_CHAKRA_STACK) {\n while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');\n } else if (IS_FIREFOX_OR_SAFARI_STACK) {\n return join(arraySlice(split(stack, '\\n'), dropEntries), '\\n');\n } return stack;\n};\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar create = require('../internals/object-create');\nvar redefineAll = require('../internals/redefine-all');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/define-iterator');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n index: create(null),\n first: undefined,\n last: undefined,\n size: 0\n });\n if (!DESCRIPTORS) that.size = 0;\n if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n var previous, index;\n // change existing entry\n if (entry) {\n entry.value = value;\n // create new entry\n } else {\n state.last = entry = {\n index: index = fastKey(key, true),\n key: key,\n value: value,\n previous: previous = state.last,\n next: undefined,\n removed: false\n };\n if (!state.first) state.first = entry;\n if (previous) previous.next = entry;\n if (DESCRIPTORS) state.size++;\n else that.size++;\n // add to index\n if (index !== 'F') state.index[index] = entry;\n } return that;\n };\n\n var getEntry = function (that, key) {\n var state = getInternalState(that);\n // fast case\n var index = fastKey(key);\n var entry;\n if (index !== 'F') return state.index[index];\n // frozen object case\n for (entry = state.first; entry; entry = entry.next) {\n if (entry.key == key) return entry;\n }\n };\n\n redefineAll(Prototype, {\n // `{ Map, Set }.prototype.clear()` methods\n // https://tc39.es/ecma262/#sec-map.prototype.clear\n // https://tc39.es/ecma262/#sec-set.prototype.clear\n clear: function clear() {\n var that = this;\n var state = getInternalState(that);\n var data = state.index;\n var entry = state.first;\n while (entry) {\n entry.removed = true;\n if (entry.previous) entry.previous = entry.previous.next = undefined;\n delete data[entry.index];\n entry = entry.next;\n }\n state.first = state.last = undefined;\n if (DESCRIPTORS) state.size = 0;\n else that.size = 0;\n },\n // `{ Map, Set }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.delete\n // https://tc39.es/ecma262/#sec-set.prototype.delete\n 'delete': function (key) {\n var that = this;\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n if (entry) {\n var next = entry.next;\n var prev = entry.previous;\n delete state.index[entry.index];\n entry.removed = true;\n if (prev) prev.next = next;\n if (next) next.previous = prev;\n if (state.first == entry) state.first = next;\n if (state.last == entry) state.last = prev;\n if (DESCRIPTORS) state.size--;\n else that.size--;\n } return !!entry;\n },\n // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.foreach\n // https://tc39.es/ecma262/#sec-set.prototype.foreach\n forEach: function forEach(callbackfn /* , that = undefined */) {\n var state = getInternalState(this);\n var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n var entry;\n while (entry = entry ? entry.next : state.first) {\n boundFunction(entry.value, entry.key, this);\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n }\n },\n // `{ Map, Set}.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.has\n // https://tc39.es/ecma262/#sec-set.prototype.has\n has: function has(key) {\n return !!getEntry(this, key);\n }\n });\n\n redefineAll(Prototype, IS_MAP ? {\n // `Map.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-map.prototype.get\n get: function get(key) {\n var entry = getEntry(this, key);\n return entry && entry.value;\n },\n // `Map.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-map.prototype.set\n set: function set(key, value) {\n return define(this, key === 0 ? 0 : key, value);\n }\n } : {\n // `Set.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-set.prototype.add\n add: function add(value) {\n return define(this, value = value === 0 ? 0 : value, value);\n }\n });\n if (DESCRIPTORS) defineProperty(Prototype, 'size', {\n get: function () {\n return getInternalState(this).size;\n }\n });\n return Constructor;\n },\n setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {\n var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods\n // https://tc39.es/ecma262/#sec-map.prototype.entries\n // https://tc39.es/ecma262/#sec-map.prototype.keys\n // https://tc39.es/ecma262/#sec-map.prototype.values\n // https://tc39.es/ecma262/#sec-map.prototype-@@iterator\n // https://tc39.es/ecma262/#sec-set.prototype.entries\n // https://tc39.es/ecma262/#sec-set.prototype.keys\n // https://tc39.es/ecma262/#sec-set.prototype.values\n // https://tc39.es/ecma262/#sec-set.prototype-@@iterator\n defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {\n setInternalState(this, {\n type: ITERATOR_NAME,\n target: iterated,\n state: getInternalCollectionState(iterated),\n kind: kind,\n last: undefined\n });\n }, function () {\n var state = getInternalIteratorState(this);\n var kind = state.kind;\n var entry = state.last;\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n // get next entry\n if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n // or finish the iteration\n state.target = undefined;\n return { value: undefined, done: true };\n }\n // return step by kind\n if (kind == 'keys') return { value: entry.key, done: false };\n if (kind == 'values') return { value: entry.value, done: false };\n return { value: [entry.key, entry.value], done: false };\n }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n // `{ Map, Set }.prototype[@@species]` accessors\n // https://tc39.es/ecma262/#sec-get-map-@@species\n // https://tc39.es/ecma262/#sec-get-set-@@species\n setSpecies(CONSTRUCTOR_NAME);\n }\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar redefine = require('../internals/redefine');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n var ADDER = IS_MAP ? 'set' : 'add';\n var NativeConstructor = global[CONSTRUCTOR_NAME];\n var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n var Constructor = NativeConstructor;\n var exported = {};\n\n var fixMethod = function (KEY) {\n var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n redefine(NativePrototype, KEY,\n KEY == 'add' ? function add(value) {\n uncurriedNativeMethod(this, value === 0 ? 0 : value);\n return this;\n } : KEY == 'delete' ? function (key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY == 'get' ? function get(key) {\n return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY == 'has' ? function has(key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : function set(key, value) {\n uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n return this;\n }\n );\n };\n\n var REPLACE = isForced(\n CONSTRUCTOR_NAME,\n !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n new NativeConstructor().entries().next();\n }))\n );\n\n if (REPLACE) {\n // create collection constructor\n Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n InternalMetadataModule.enable();\n } else if (isForced(CONSTRUCTOR_NAME, true)) {\n var instance = new Constructor();\n // early implementations not supports chaining\n var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n // most early implementations doesn't supports iterables, most modern - not close it correctly\n // eslint-disable-next-line no-new -- required for testing\n var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n // for early implementations -0 and +0 not the same\n var BUGGY_ZERO = !IS_WEAK && fails(function () {\n // V8 ~ Chromium 42- fails only with 5+ elements\n var $instance = new NativeConstructor();\n var index = 5;\n while (index--) $instance[ADDER](index, index);\n return !$instance.has(-0);\n });\n\n if (!ACCEPT_ITERABLES) {\n Constructor = wrapper(function (dummy, iterable) {\n anInstance(dummy, NativePrototype);\n var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n return that;\n });\n Constructor.prototype = NativePrototype;\n NativePrototype.constructor = Constructor;\n }\n\n if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n fixMethod('delete');\n fixMethod('has');\n IS_MAP && fixMethod('get');\n }\n\n if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n // weak collections should not contains .clear method\n if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n }\n\n exported[CONSTRUCTOR_NAME] = Constructor;\n $({ global: true, forced: Constructor != NativeConstructor }, exported);\n\n setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n return Constructor;\n};\n","var hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n function F() { /* empty */ }\n F.prototype.constructor = null;\n // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next) {\n var TO_STRING_TAG = NAME + ' Iterator';\n IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });\n setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n Iterators[TO_STRING_TAG] = returnThis;\n return IteratorConstructor;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","module.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n var propertyKey = toPropertyKey(key);\n if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n else object[propertyKey] = value;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n createIteratorConstructor(IteratorConstructor, NAME, next);\n\n var getIterationMethod = function (KIND) {\n if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];\n switch (KIND) {\n case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n } return function () { return new IteratorConstructor(this); };\n };\n\n var TO_STRING_TAG = NAME + ' Iterator';\n var INCORRECT_VALUES_NAME = false;\n var IterablePrototype = Iterable.prototype;\n var nativeIterator = IterablePrototype[ITERATOR]\n || IterablePrototype['@@iterator']\n || DEFAULT && IterablePrototype[DEFAULT];\n var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n var CurrentIteratorPrototype, methods, KEY;\n\n // fix native\n if (anyNativeIterator) {\n CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n if (setPrototypeOf) {\n setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n redefine(CurrentIteratorPrototype, ITERATOR, returnThis);\n }\n }\n // Set @@toStringTag to native iterators\n setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n }\n }\n\n // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n } else {\n INCORRECT_VALUES_NAME = true;\n defaultIterator = function values() { return call(nativeIterator, this); };\n }\n }\n\n // export additional methods\n if (DEFAULT) {\n methods = {\n values: getIterationMethod(VALUES),\n keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n entries: getIterationMethod(ENTRIES)\n };\n if (FORCED) for (KEY in methods) {\n if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n redefine(IterablePrototype, KEY, methods[KEY]);\n }\n } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n }\n\n // define iterator\n if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n redefine(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n }\n Iterators[NAME] = defaultIterator;\n\n return methods;\n};\n","var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","module.exports = typeof window == 'object';\n","var userAgent = require('../internals/engine-user-agent');\nvar global = require('../internals/global');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && global.Pebble !== undefined;\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","var classof = require('../internals/classof-raw');\nvar global = require('../internals/global');\n\nmodule.exports = classof(global.process) == 'process';\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\n","var global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","var global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (CONSTRUCTOR, METHOD) {\n return uncurryThis(global[CONSTRUCTOR].prototype[METHOD]);\n};\n","// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","var fails = require('../internals/fails');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = !fails(function () {\n var error = Error('a');\n if (!('stack' in error)) return true;\n // eslint-disable-next-line es/no-object-defineproperty -- safe\n Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));\n return error.stack !== 7;\n});\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.noTargetGet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || setGlobal(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.noTargetGet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n // extend global\n redefine(target, key, sourceProperty, options);\n }\n};\n","module.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n return Object.isExtensible(Object.preventExtensions({}));\n});\n","var FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar bind = FunctionPrototype.bind;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (bind ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : bind ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","var call = Function.prototype.call;\n\nmodule.exports = call.bind ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","var FunctionPrototype = Function.prototype;\nvar bind = FunctionPrototype.bind;\nvar call = FunctionPrototype.call;\nvar callBind = bind && bind.bind(call);\n\nmodule.exports = bind ? function (fn) {\n return fn && callBind(call, fn);\n} : function (fn) {\n return fn && function () {\n return call.apply(fn, arguments);\n };\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","var classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (it != undefined) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar TypeError = global.TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw TypeError(tryToString(argument) + ' is not iterable');\n};\n","var aCallable = require('../internals/a-callable');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return func == null ? undefined : aCallable(func);\n};\n","var check = function (it) {\n return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","module.exports = {};\n","var global = require('../internals/global');\n\nmodule.exports = function (a, b) {\n var console = global.console;\n if (console && console.error) {\n arguments.length == 1 ? console.error(a) : console.error(a, b);\n }\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- requied for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a != 7;\n});\n","var global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar Object = global.Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) == 'String' ? split(it, '') : Object(it);\n} : Object;\n","var isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n var NewTarget, NewTargetPrototype;\n if (\n // it can work only with native `setPrototypeOf`\n setPrototypeOf &&\n // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n isCallable(NewTarget = dummy.constructor) &&\n NewTarget !== Wrapper &&\n isObject(NewTargetPrototype = NewTarget.prototype) &&\n NewTargetPrototype !== Wrapper.prototype\n ) setPrototypeOf($this, NewTargetPrototype);\n return $this;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","var isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\n// `InstallErrorCause` abstract operation\n// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause\nmodule.exports = function (O, options) {\n if (isObject(options) && 'cause' in options) {\n createNonEnumerableProperty(O, 'cause', options.cause);\n }\n};\n","var $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar isExtensible = Object.isExtensible || function () {\n return true;\n};\n\nvar setMetadata = function (it) {\n defineProperty(it, METADATA, { value: {\n objectID: 'O' + id++, // object ID\n weakData: {} // weak collections IDs\n } });\n};\n\nvar fastKey = function (it, create) {\n // return a primitive with prefix\n if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return 'F';\n // not necessary to add metadata\n if (!create) return 'E';\n // add missing metadata\n setMetadata(it);\n // return object ID\n } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return true;\n // not necessary to add metadata\n if (!create) return false;\n // add missing metadata\n setMetadata(it);\n // return the store of weak collections IDs\n } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n return it;\n};\n\nvar enable = function () {\n meta.enable = function () { /* empty */ };\n REQUIRED = true;\n var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n var splice = uncurryThis([].splice);\n var test = {};\n test[METADATA] = 1;\n\n // prevent exposing of metadata key\n if (getOwnPropertyNames(test).length) {\n getOwnPropertyNamesModule.f = function (it) {\n var result = getOwnPropertyNames(it);\n for (var i = 0, length = result.length; i < length; i++) {\n if (result[i] === METADATA) {\n splice(result, i, 1);\n break;\n }\n } return result;\n };\n\n $({ target: 'Object', stat: true, forced: true }, {\n getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n });\n }\n};\n\nvar meta = module.exports = {\n enable: enable,\n fastKey: fastKey,\n getWeakData: getWeakData,\n onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n var wmget = uncurryThis(store.get);\n var wmhas = uncurryThis(store.has);\n var wmset = uncurryThis(store.set);\n set = function (it, metadata) {\n if (wmhas(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n wmset(store, it, metadata);\n return metadata;\n };\n get = function (it) {\n return wmget(store, it) || {};\n };\n has = function (it) {\n return wmhas(store, it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","var classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n return classof(argument) == 'Array';\n};\n","// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = function (argument) {\n return typeof argument == 'function';\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.exec(noop);\n\nvar isConstructorModern = function (argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function (argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n // we can't check .prototype since constructors produced by .bind haven't it\n } return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n};\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","var fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value == POLYFILL ? true\n : value == NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","var isObject = require('../internals/is-object');\n\nvar floor = Math.floor;\n\n// `IsIntegralNumber` abstract operation\n// https://tc39.es/ecma262/#sec-isintegralnumber\n// eslint-disable-next-line es/no-number-isinteger -- safe\nmodule.exports = Number.isInteger || function isInteger(it) {\n return !isObject(it) && isFinite(it) && floor(it) === it;\n};\n","var isCallable = require('../internals/is-callable');\n\nmodule.exports = function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","module.exports = false;\n","var global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Object = global.Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, Object(it));\n};\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar TypeError = global.TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","var call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n arrayIterator = [].keys();\n // Safari 8 has buggy iterators w/o `next`\n if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n else {\n PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () {\n var test = {};\n // FF44- legacy iterators case\n return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n redefine(IteratorPrototype, ITERATOR, function () {\n return this;\n });\n}\n\nmodule.exports = {\n IteratorPrototype: IteratorPrototype,\n BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","module.exports = {};\n","var toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\n\nvar flush, head, last, notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!queueMicrotask) {\n flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (head) {\n fn = head.fn;\n head = head.next;\n try {\n fn();\n } catch (error) {\n if (head) notify();\n else last = undefined;\n throw error;\n }\n } last = undefined;\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessag\n // - onreadystatechange\n // - setTimeout\n } else {\n // strange IE + webpack dev server bug - use .bind(global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n}\n\nmodule.exports = queueMicrotask || function (fn) {\n var task = { fn: fn, next: undefined };\n if (last) last.next = task;\n if (!head) {\n head = task;\n notify();\n } last = task;\n};\n","var global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol();\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n return !String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(inspectSource(WeakMap));\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","var toString = require('../internals/to-string');\n\nmodule.exports = function (argument, $default) {\n return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);\n};\n","var global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toString = require('../internals/to-string');\nvar trim = require('../internals/string-trim').trim;\nvar whitespaces = require('../internals/whitespaces');\n\nvar charAt = uncurryThis(''.charAt);\nvar n$ParseFloat = global.parseFloat;\nvar Symbol = global.Symbol;\nvar ITERATOR = Symbol && Symbol.iterator;\nvar FORCED = 1 / n$ParseFloat(whitespaces + '-0') !== -Infinity\n // MS Edge 18- broken with boxed symbols\n || (ITERATOR && !fails(function () { n$ParseFloat(Object(ITERATOR)); }));\n\n// `parseFloat` method\n// https://tc39.es/ecma262/#sec-parsefloat-string\nmodule.exports = FORCED ? function parseFloat(string) {\n var trimmedString = trim(toString(string));\n var result = n$ParseFloat(trimmedString);\n return result === 0 && charAt(trimmedString, 0) == '-' ? -0 : result;\n} : n$ParseFloat;\n","var global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toString = require('../internals/to-string');\nvar trim = require('../internals/string-trim').trim;\nvar whitespaces = require('../internals/whitespaces');\n\nvar $parseInt = global.parseInt;\nvar Symbol = global.Symbol;\nvar ITERATOR = Symbol && Symbol.iterator;\nvar hex = /^[+-]?0x/i;\nvar exec = uncurryThis(hex.exec);\nvar FORCED = $parseInt(whitespaces + '08') !== 8 || $parseInt(whitespaces + '0x16') !== 22\n // MS Edge 18- broken with boxed symbols\n || (ITERATOR && !fails(function () { $parseInt(Object(ITERATOR)); }));\n\n// `parseInt` method\n// https://tc39.es/ecma262/#sec-parseint-string-radix\nmodule.exports = FORCED ? function parseInt(string, radix) {\n var S = trim(toString(string));\n return $parseInt(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10));\n} : $parseInt;\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol();\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar defineProperties = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n activeXDocument.write(scriptTag(''));\n activeXDocument.close();\n var temp = activeXDocument.parentWindow.Object;\n activeXDocument = null; // avoid memory leak\n return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = documentCreateElement('iframe');\n var JS = 'java' + SCRIPT + ':';\n var iframeDocument;\n iframe.style.display = 'none';\n html.appendChild(iframe);\n // https://github.com/zloirock/core-js/issues/475\n iframe.src = String(JS);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(scriptTag('document.F=Object'));\n iframeDocument.close();\n return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n try {\n activeXDocument = new ActiveXObject('htmlfile');\n } catch (error) { /* ignore */ }\n NullProtoObject = typeof document != 'undefined'\n ? document.domain && activeXDocument\n ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n : NullProtoObjectViaIFrame()\n : NullProtoObjectViaActiveX(activeXDocument); // WSH\n var length = enumBugKeys.length;\n while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n EmptyConstructor[PROTOTYPE] = anObject(O);\n result = new EmptyConstructor();\n EmptyConstructor[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = NullProtoObject();\n return Properties === undefined ? result : defineProperties(result, Properties);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var props = toIndexedObject(Properties);\n var keys = objectKeys(Properties);\n var length = keys.length;\n var index = 0;\n var key;\n while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n return O;\n};\n","var global = require('../internals/global');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar TypeError = global.TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n try {\n return $getOwnPropertyNames(it);\n } catch (error) {\n return arraySlice(windowNames);\n }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n return windowNames && classof(it) == 'Window'\n ? getWindowNames(it)\n : $getOwnPropertyNames(toIndexedObject(it));\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","var global = require('../internals/global');\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar Object = global.Object;\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n var object = toObject(O);\n if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n var constructor = object.constructor;\n if (isCallable(constructor) && object instanceof constructor) {\n return constructor.prototype;\n } return object instanceof Object ? ObjectPrototype : null;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","/* eslint-disable no-proto -- safe */\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n setter = uncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","var DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\nvar propertyIsEnumerable = uncurryThis($propertyIsEnumerable);\nvar push = uncurryThis([].push);\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n return function (it) {\n var O = toIndexedObject(it);\n var keys = objectKeys(O);\n var length = keys.length;\n var i = 0;\n var result = [];\n var key;\n while (length > i) {\n key = keys[i++];\n if (!DESCRIPTORS || propertyIsEnumerable(O, key)) {\n push(result, TO_ENTRIES ? [key, O[key]] : O[key]);\n }\n }\n return result;\n };\n};\n\nmodule.exports = {\n // `Object.entries` method\n // https://tc39.es/ecma262/#sec-object.entries\n entries: createMethod(true),\n // `Object.values` method\n // https://tc39.es/ecma262/#sec-object.values\n values: createMethod(false)\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar TypeError = global.TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw TypeError(\"Can't convert object to primitive value\");\n};\n","var getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","module.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","var anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","var redefine = require('../internals/redefine');\n\nmodule.exports = function (target, src, options) {\n for (var key in src) redefine(target, key, src[key], options);\n return target;\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n var unsafe = options ? !!options.unsafe : false;\n var simple = options ? !!options.enumerable : false;\n var noTargetGet = options ? !!options.noTargetGet : false;\n var name = options && options.name !== undefined ? options.name : key;\n var state;\n if (isCallable(value)) {\n if (String(name).slice(0, 7) === 'Symbol(') {\n name = '[' + String(name).replace(/^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n createNonEnumerableProperty(value, 'name', name);\n }\n state = enforceInternalState(value);\n if (!state.source) {\n state.source = TEMPLATE.join(typeof name == 'string' ? name : '');\n }\n }\n if (O === global) {\n if (simple) O[key] = value;\n else setGlobal(key, value);\n return;\n } else if (!unsafe) {\n delete O[key];\n } else if (!noTargetGet && O[key]) {\n simple = true;\n }\n if (simple) O[key] = value;\n else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n});\n","var global = require('../internals/global');\n\nvar TypeError = global.TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n return it;\n};\n","var global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar definePropertyModule = require('../internals/object-define-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n var defineProperty = definePropertyModule.f;\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineProperty(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","var defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (it, TAG, STATIC) {\n if (it && !hasOwn(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {\n defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n","var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.19.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\n});\n","var anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aConstructor(S);\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n return function ($this, pos) {\n var S = toString(requireObjectCoercible($this));\n var position = toIntegerOrInfinity(pos);\n var size = S.length;\n var first, second;\n if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n first = charCodeAt(S, position);\n return first < 0xD800 || first > 0xDBFF || position + 1 === size\n || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n ? CONVERT_TO_STRING\n ? charAt(S, position)\n : first\n : CONVERT_TO_STRING\n ? stringSlice(S, position, position + 2)\n : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n };\n};\n\nmodule.exports = {\n // `String.prototype.codePointAt` method\n // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n codeAt: createMethod(false),\n // `String.prototype.at` method\n // https://github.com/mathiasbynens/String.prototype.at\n charAt: createMethod(true)\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\nvar whitespaces = require('../internals/whitespaces');\n\nvar replace = uncurryThis(''.replace);\nvar whitespace = '[' + whitespaces + ']';\nvar ltrim = RegExp('^' + whitespace + whitespace + '*');\nvar rtrim = RegExp(whitespace + whitespace + '*$');\n\n// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation\nvar createMethod = function (TYPE) {\n return function ($this) {\n var string = toString(requireObjectCoercible($this));\n if (TYPE & 1) string = replace(string, ltrim, '');\n if (TYPE & 2) string = replace(string, rtrim, '');\n return string;\n };\n};\n\nmodule.exports = {\n // `String.prototype.{ trimLeft, trimStart }` methods\n // https://tc39.es/ecma262/#sec-string.prototype.trimstart\n start: createMethod(1),\n // `String.prototype.{ trimRight, trimEnd }` methods\n // https://tc39.es/ecma262/#sec-string.prototype.trimend\n end: createMethod(2),\n // `String.prototype.trim` method\n // https://tc39.es/ecma262/#sec-string.prototype.trim\n trim: createMethod(3)\n};\n","var global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar location, defer, channel, port;\n\ntry {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n location = global.location;\n} catch (error) { /* empty */ }\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar listener = function (event) {\n run(event.data);\n};\n\nvar post = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), location.protocol + '//' + location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(fn) {\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(isCallable(fn) ? fn : Function(fn), undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = listener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n location && location.protocol !== 'file:' &&\n !fails(post)\n ) {\n defer = post;\n global.addEventListener('message', listener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- safe\n return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number);\n};\n","var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","var global = require('../internals/global');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar Object = global.Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return Object(requireObjectCoercible(argument));\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TypeError = global.TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","var toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","var global = require('../internals/global');\nvar classof = require('../internals/classof');\n\nvar String = global.String;\n\nmodule.exports = function (argument) {\n if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');\n return String(argument);\n};\n","var global = require('../internals/global');\n\nvar String = global.String;\n\nmodule.exports = function (argument) {\n try {\n return String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar symbolFor = Symbol && Symbol['for'];\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {\n var description = 'Symbol.' + name;\n if (NATIVE_SYMBOL && hasOwn(Symbol, name)) {\n WellKnownSymbolsStore[name] = Symbol[name];\n } else if (USE_SYMBOL_AS_UID && symbolFor) {\n WellKnownSymbolsStore[name] = symbolFor(description);\n } else {\n WellKnownSymbolsStore[name] = createWellKnownSymbol(description);\n }\n } return WellKnownSymbolsStore[name];\n};\n","// a string of all valid unicode whitespaces\nmodule.exports = '\\u0009\\u000A\\u000B\\u000C\\u000D\\u0020\\u00A0\\u1680\\u2000\\u2001\\u2002' +\n '\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF';\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar create = require('../internals/object-create');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar clearErrorStack = require('../internals/clear-error-stack');\nvar installErrorCause = require('../internals/install-error-cause');\nvar iterate = require('../internals/iterate');\nvar normalizeStringArgument = require('../internals/normalize-string-argument');\nvar ERROR_STACK_INSTALLABLE = require('../internals/error-stack-installable');\n\nvar Error = global.Error;\nvar push = [].push;\n\nvar $AggregateError = function AggregateError(errors, message /* , options */) {\n var that = isPrototypeOf(AggregateErrorPrototype, this) ? this : create(AggregateErrorPrototype);\n var options = arguments.length > 2 ? arguments[2] : undefined;\n if (setPrototypeOf) {\n that = setPrototypeOf(new Error(undefined), getPrototypeOf(that));\n }\n createNonEnumerableProperty(that, 'message', normalizeStringArgument(message, ''));\n if (ERROR_STACK_INSTALLABLE) createNonEnumerableProperty(that, 'stack', clearErrorStack(that.stack, 1));\n installErrorCause(that, options);\n var errorsArray = [];\n iterate(errors, push, { that: errorsArray });\n createNonEnumerableProperty(that, 'errors', errorsArray);\n return that;\n};\n\nif (setPrototypeOf) setPrototypeOf($AggregateError, Error);\nelse copyConstructorProperties($AggregateError, Error);\n\nvar AggregateErrorPrototype = $AggregateError.prototype = create(Error.prototype, {\n constructor: createPropertyDescriptor(1, $AggregateError),\n message: createPropertyDescriptor(1, ''),\n name: createPropertyDescriptor(1, 'AggregateError')\n});\n\n// `AggregateError` constructor\n// https://tc39.es/ecma262/#sec-aggregate-error-constructor\n$({ global: true }, {\n AggregateError: $AggregateError\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar $find = require('../internals/array-iteration').find;\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\nvar FIND = 'find';\nvar SKIPS_HOLES = true;\n\n// Shouldn't skip holes\nif (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });\n\n// `Array.prototype.find` method\n// https://tc39.es/ecma262/#sec-array.prototype.find\n$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {\n find: function find(callbackfn /* , that = undefined */) {\n return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables(FIND);\n","var $ = require('../internals/export');\nvar from = require('../internals/array-from');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\n\nvar INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {\n // eslint-disable-next-line es/no-array-from -- required for testing\n Array.from(iterable);\n});\n\n// `Array.from` method\n// https://tc39.es/ecma262/#sec-array.from\n$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {\n from: from\n});\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n setInternalState(this, {\n type: ARRAY_ITERATOR,\n target: toIndexedObject(iterated), // target\n index: 0, // next index\n kind: kind // kind\n });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n var state = getInternalState(this);\n var target = state.target;\n var kind = state.kind;\n var index = state.index++;\n if (!target || index >= target.length) {\n state.target = undefined;\n return { value: undefined, done: true };\n }\n if (kind == 'keys') return { value: index, done: false };\n if (kind == 'values') return { value: target[index], done: false };\n return { value: [index, target[index]], done: false };\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.es/ecma262/#sec-map-objects\ncollection('Map', function (init) {\n return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","var $ = require('../internals/export');\nvar isIntegralNumber = require('../internals/is-integral-number');\n\n// `Number.isInteger` method\n// https://tc39.es/ecma262/#sec-number.isinteger\n$({ target: 'Number', stat: true }, {\n isInteger: isIntegralNumber\n});\n","var $ = require('../internals/export');\n\n// `Number.isNaN` method\n// https://tc39.es/ecma262/#sec-number.isnan\n$({ target: 'Number', stat: true }, {\n isNaN: function isNaN(number) {\n // eslint-disable-next-line no-self-compare -- NaN check\n return number != number;\n }\n});\n","var $ = require('../internals/export');\nvar parseFloat = require('../internals/number-parse-float');\n\n// `Number.parseFloat` method\n// https://tc39.es/ecma262/#sec-number.parseFloat\n// eslint-disable-next-line es/no-number-parsefloat -- required for testing\n$({ target: 'Number', stat: true, forced: Number.parseFloat != parseFloat }, {\n parseFloat: parseFloat\n});\n","var $ = require('../internals/export');\nvar parseInt = require('../internals/number-parse-int');\n\n// `Number.parseInt` method\n// https://tc39.es/ecma262/#sec-number.parseint\n// eslint-disable-next-line es/no-number-parseint -- required for testing\n$({ target: 'Number', stat: true, forced: Number.parseInt != parseInt }, {\n parseInt: parseInt\n});\n","var $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, forced: Object.assign !== assign }, {\n assign: assign\n});\n","var $ = require('../internals/export');\nvar $entries = require('../internals/object-to-array').entries;\n\n// `Object.entries` method\n// https://tc39.es/ecma262/#sec-object.entries\n$({ target: 'Object', stat: true }, {\n entries: function entries(O) {\n return $entries(O);\n }\n});\n","var $ = require('../internals/export');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n$({ target: 'Object', stat: true }, {\n setPrototypeOf: setPrototypeOf\n});\n","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar redefine = require('../internals/redefine');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n redefine(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-promise.allsettled\n$({ target: 'Promise', stat: true }, {\n allSettled: function allSettled(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call(promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = { status: 'fulfilled', value: value };\n --remaining || resolve(values);\n }, function (error) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = { status: 'rejected', reason: error };\n --remaining || resolve(values);\n });\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar aCallable = require('../internals/a-callable');\nvar getBuiltIn = require('../internals/get-built-in');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\nvar PROMISE_ANY_ERROR = 'No one promise resolved';\n\n// `Promise.any` method\n// https://tc39.es/ecma262/#sec-promise.any\n$({ target: 'Promise', stat: true }, {\n any: function any(iterable) {\n var C = this;\n var AggregateError = getBuiltIn('AggregateError');\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var promiseResolve = aCallable(C.resolve);\n var errors = [];\n var counter = 0;\n var remaining = 1;\n var alreadyResolved = false;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyRejected = false;\n remaining++;\n call(promiseResolve, C, promise).then(function (value) {\n if (alreadyRejected || alreadyResolved) return;\n alreadyResolved = true;\n resolve(value);\n }, function (error) {\n if (alreadyRejected || alreadyResolved) return;\n alreadyRejected = true;\n errors[index] = error;\n --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));\n });\n });\n --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar fails = require('../internals/fails');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar speciesConstructor = require('../internals/species-constructor');\nvar promiseResolve = require('../internals/promise-resolve');\nvar redefine = require('../internals/redefine');\n\n// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829\nvar NON_GENERIC = !!NativePromise && fails(function () {\n NativePromise.prototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });\n});\n\n// `Promise.prototype.finally` method\n// https://tc39.es/ecma262/#sec-promise.prototype.finally\n$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {\n 'finally': function (onFinally) {\n var C = speciesConstructor(this, getBuiltIn('Promise'));\n var isFunction = isCallable(onFinally);\n return this.then(\n isFunction ? function (x) {\n return promiseResolve(C, onFinally()).then(function () { return x; });\n } : onFinally,\n isFunction ? function (e) {\n return promiseResolve(C, onFinally()).then(function () { throw e; });\n } : onFinally\n );\n }\n});\n\n// makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromise)) {\n var method = getBuiltIn('Promise').prototype['finally'];\n if (NativePromise.prototype['finally'] !== method) {\n redefine(NativePromise.prototype, 'finally', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar call = require('../internals/function-call');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar redefine = require('../internals/redefine');\nvar redefineAll = require('../internals/redefine-all');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar inspectSource = require('../internals/inspect-source');\nvar iterate = require('../internals/iterate');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar promiseResolve = require('../internals/promise-resolve');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar InternalStateModule = require('../internals/internal-state');\nvar isForced = require('../internals/is-forced');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_NODE = require('../internals/engine-is-node');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\nvar PROMISE = 'Promise';\n\nvar getInternalState = InternalStateModule.get;\nvar setInternalState = InternalStateModule.set;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar NativePromisePrototype = NativePromise && NativePromise.prototype;\nvar PromiseConstructor = NativePromise;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar NATIVE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\nvar SUBCLASSING = false;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\nvar FORCED = isForced(PROMISE, function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#finally in the pure version for preventing prototype pollution\n if (IS_PURE && !PromisePrototype['finally']) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (V8_VERSION >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false;\n // Detect correctness of subclassing with @@species support\n var promise = new PromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;\n});\n\nvar INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {\n PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });\n});\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n var chain = state.reactions;\n microtask(function () {\n var value = state.value;\n var ok = state.state == FULFILLED;\n var index = 0;\n // variable length - can't use forEach\n while (chain.length > index) {\n var reaction = chain[index++];\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n }\n state.reactions = [];\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n PromisePrototype = PromiseConstructor.prototype;\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: [],\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n Internal.prototype = redefineAll(PromisePrototype, {\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n then: function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reactions = state.reactions;\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n state.parent = true;\n reactions[reactions.length] = reaction;\n if (state.state != PENDING) notify(state, false);\n return reaction.promise;\n },\n // `Promise.prototype.catch` method\n // https://tc39.es/ecma262/#sec-promise.prototype.catch\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n });\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromise) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n redefine(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n\n // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\n redefine(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, wrap: true, forced: FORCED }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n\nPromiseWrapper = getBuiltIn(PROMISE);\n\n// statics\n$({ target: PROMISE, stat: true, forced: FORCED }, {\n // `Promise.reject` method\n // https://tc39.es/ecma262/#sec-promise.reject\n reject: function reject(r) {\n var capability = newPromiseCapability(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n\n$({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, {\n // `Promise.resolve` method\n // https://tc39.es/ecma262/#sec-promise.resolve\n resolve: function resolve(x) {\n return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);\n }\n});\n\n$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {\n // `Promise.all` method\n // https://tc39.es/ecma262/#sec-promise.all\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapability(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n },\n // `Promise.race` method\n // https://tc39.es/ecma262/#sec-promise.race\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapability(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n setInternalState(this, {\n type: STRING_ITERATOR,\n string: toString(iterated),\n index: 0\n });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n var state = getInternalState(this);\n var string = state.string;\n var index = state.index;\n var point;\n if (index >= string.length) return { value: undefined, done: true };\n point = charAt(string, index);\n state.index += point.length;\n return { value: point, done: false };\n});\n","(function () {\n var validator = new RegExp(\"^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$\", \"i\");\n\n function gen(count) {\n var out = \"\";\n for (var i=0; i 0) {\n stylesheet.deleteRule(stylesheet.cssRules.length - 1);\n }\n formattingModel.formattingSheets.map(function (currentFormattingSheet) {\n _this.applyFormattingSheetToStyleSheet(currentFormattingSheet, stylesheet);\n });\n };\n ExtensionsImpl.prototype.applyFormattingSheetToStyleSheet = function (currentFormattingSheet, stylesheet) {\n var styleInfo = '';\n var cssProperties = currentFormattingSheet.cssProperties;\n if (cssProperties.fontFamily) {\n styleInfo += 'font-family: ' + cssProperties.fontFamily.toString() + '; ';\n }\n if (cssProperties.fontSize) {\n styleInfo += 'font-size: ' + cssProperties.fontSize.toString() + '; ';\n }\n if (cssProperties.fontWeight) {\n styleInfo += 'font-weight: ' + cssProperties.fontWeight.toString() + '; ';\n }\n if (cssProperties.fontStyle) {\n styleInfo += 'font-style: ' + cssProperties.fontStyle.toString() + '; ';\n }\n if (cssProperties.textDecoration) {\n styleInfo += 'text-decoration: ' + cssProperties.textDecoration.toString() + '; ';\n }\n if (cssProperties.color) {\n styleInfo += 'color: ' + cssProperties.color + '; ';\n }\n var selector = '.' + currentFormattingSheet.classNameKey;\n var rule = selector + ' { ' + styleInfo + ' }';\n stylesheet.insertRule(rule, stylesheet.cssRules.length);\n };\n ExtensionsImpl.prototype.initializeWorkbookFormattingChangedEventCallback = function (dispatcher) {\n var _this = this;\n var notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService(\"notification-service\" /* Notification */);\n // Unregister function not used since these notifications should be\n // observed for the full lifetime of the extension.\n notificationService.registerHandler(api_internal_contract_js_1.NotificationId.WorkbookFormattingChanged, function () { return true; }, function (eventFormatting) {\n if (eventFormatting) {\n _this.initializeTableauFonts(dispatcher, eventFormatting);\n _this.applyAllFormatting(eventFormatting);\n }\n });\n };\n ExtensionsImpl.prototype.initializeTableauFonts = function (dispatcher, workbookFormatting) {\n var _a;\n var _this = this;\n var fontNames = __spreadArrays(BentonSansFontNameConstants_1.SupportedBentonSansFontFaces, TableauBookFontNameConstants_1.SupportedTableauFontFaces);\n workbookFormatting.formattingSheets.forEach(function (formattingSheet) {\n if (formattingSheet.cssProperties.fontFamily) {\n fontNames.push(formattingSheet.cssProperties.fontFamily);\n }\n });\n if (fontNames.length > 0) {\n var parameters = (_a = {}, _a[api_internal_contract_js_1.ParameterId.FontNameListItems] = fontNames, _a);\n dispatcher\n .execute(api_internal_contract_js_1.VerbId.GetFonts, parameters)\n .then(function (response) {\n _this.loadFonts(response.result);\n })\n .catch();\n }\n };\n ExtensionsImpl.prototype.loadFonts = function (fonts) {\n var _this = this;\n fonts.forEach(function (fontNameAndInfo) {\n if (TableauBookFontNameConstants_1.SupportedTableauFontFaces.includes(fontNameAndInfo.fontName)) {\n _this.loadTableauFonts(fontNameAndInfo);\n }\n else if (BentonSansFontNameConstants_1.SupportedBentonSansFontFaces.includes(fontNameAndInfo.fontName)) {\n _this.loadBentonSansFonts(fontNameAndInfo);\n }\n else {\n document.fonts.add(new FontFace(fontNameAndInfo.fontName, fontNameAndInfo.fontBinaryInfo));\n }\n });\n };\n ExtensionsImpl.prototype.initializeDashboardContent = function (info, sheetPath) {\n // sheets are always active for Extensions\n var sheetInfoImpl = new api_shared_js_1.SheetInfoImpl(info.name, api_external_contract_js_1.SheetType.Dashboard, { width: info.size.w, height: info.size.h }, undefined, true);\n var dashboardImpl = new api_shared_js_1.DashboardImpl(sheetInfoImpl, info.zones, sheetPath, ServiceRegistryUtil_1.ExtensionsRegistryId, null, info.activeDashboardObjectId);\n var dashboard = new Dashboard_1.Dashboard(dashboardImpl);\n return new DashboardContent_1.DashboardContent(dashboard);\n };\n ExtensionsImpl.prototype.initializeWorksheetContent = function (info) {\n var sheetInfoImpl = new api_shared_js_1.SheetInfoImpl(info.visualId.worksheet, api_external_contract_js_1.SheetType.Worksheet, { width: info.size.w, height: info.size.h }, undefined, // index property is embedding specific\n true);\n var worksheetImpl = new api_shared_js_1.WorksheetImpl(sheetInfoImpl, ServiceRegistryUtil_1.ExtensionsRegistryId, info.visualId, null, // parentDashboard is always null for worksheet in WorksheetContent\n null);\n var worksheet = new Worksheet_1.Worksheet(worksheetImpl);\n return new WorksheetContent_1.WorksheetContent(worksheet);\n };\n ExtensionsImpl.prototype.initializeSettings = function (settingsInfo) {\n var settingsImpl = new SettingsImpl_1.SettingsImpl(settingsInfo);\n return new Settings_1.Settings(settingsImpl);\n };\n ExtensionsImpl.prototype.initializeContextMenuCallbacks = function (contextMenuFunctions) {\n var notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService(\"notification-service\" /* Notification */);\n // Unregister function not used since these notifications should be\n // observed for the full lifetime of the extension.\n notificationService.registerHandler(api_internal_contract_js_1.NotificationId.ContextMenuClick, function () {\n // Let through any context menu event, these are already filtered on api-core\n // based on the extension locator.\n return true;\n }, function (event) {\n // Execute the function associated with this context menu ID\n if (contextMenuFunctions) {\n if (!contextMenuFunctions[event.id]) {\n throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, \"Received unexpected context menu Id from event: \" + event.id);\n }\n contextMenuFunctions[event.id]();\n }\n });\n };\n ExtensionsImpl.prototype.loadTableauFonts = function (fontNameAndInfo) {\n switch (fontNameAndInfo.fontName) {\n case TableauBookFontNameConstants_1.TableauBookFontFaceName:\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauBookFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n break;\n case TableauBookFontNameConstants_1.TableauLightFontFaceName:\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauLightFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n break;\n case TableauBookFontNameConstants_1.TableauRegularFontFaceName:\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauRegularFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n break;\n case TableauBookFontNameConstants_1.TableauSemiBoldFontFaceName:\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauSemiboldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauRegularFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n break;\n case TableauBookFontNameConstants_1.TableauBoldFontFaceName:\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauBoldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauBoldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauMediumFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauSemiboldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n break;\n case TableauBookFontNameConstants_1.TableauMediumFontFaceName:\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauMediumFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauLightFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauBookFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n break;\n default:\n throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, \"'attempted to load unsupported font: \" + fontNameAndInfo.fontName + \".'\");\n }\n };\n ExtensionsImpl.prototype.loadBentonSansFonts = function (fontNameAndInfo) {\n switch (fontNameAndInfo.fontName) {\n case BentonSansFontNameConstants_1.BentonSansBookFontFaceName:\n document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: '100', style: 'normal' }));\n break;\n case BentonSansFontNameConstants_1.BentonSansLightFontFaceName:\n document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: '100', style: 'normal' }));\n break;\n case BentonSansFontNameConstants_1.BentonSansMediumFontFaceName:\n document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n break;\n case BentonSansFontNameConstants_1.BentonSansSemiDemiFontFaceName:\n document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n break;\n case BentonSansFontNameConstants_1.BentonSansBookItalicFontFaceName:\n document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { style: 'italic' }));\n break;\n case BentonSansFontNameConstants_1.BentonSansSemiDemiItalicFontFaceName:\n document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { style: 'italic' }));\n break;\n default:\n throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, \"'attempted to load unsupported font: \" + fontNameAndInfo.fontName + \".'\");\n }\n };\n return ExtensionsImpl;\n}());\nexports.ExtensionsImpl = ExtensionsImpl;\n//# sourceMappingURL=ExtensionsImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\n/**\n * LegacyInternalApiDispatcherHolder has been moved (and renamed) from api-internal-contract.\n * It supports running a newer external library against a pre 2019.3 desktop.\n * Starting in 2019.3, we have a merged bootstrap style for both desktop and server.\n * In addition, the alpha checking that is happening here is not necessary in external-api-js\n * after 2019.3 because that checking happens in api-platform-js (ApiDispatcherTest.ts)\n * TFSID: 1091561 tracks an improvement to this system to make it less complex and tie it directly to\n * tableau beta release versions.\n * @deprecated\n */\n// eslint-disable-next-line @typescript-eslint/no-namespace\nvar LegacyInternalApiDispatcherHolder;\n(function (LegacyInternalApiDispatcherHolder) {\n /**\n * @param options\n */\n function getDesktopDispatcherPromise(options) {\n var _a;\n if ((!options || typeof options.isAlpha === 'undefined') && !window.__warningIssued) {\n // tslint:disable-next-line:no-console\n console.warn('This is a beta version of the Extensions API. Please upgrade to an official release.');\n window.__warningIssued = true;\n }\n else if (((_a = options) === null || _a === void 0 ? void 0 : _a.isAlpha) && window.__platformIsOfficialRelease) {\n window.__tableauDesktopDispatcher\n .then(function (dispatcherFactory) {\n var dispatcher = dispatcherFactory(api_internal_contract_js_1.INTERNAL_CONTRACT_VERSION);\n dispatcher.execute(api_internal_contract_js_1.VerbId.BlockExtension, {}).catch();\n })\n .catch();\n }\n // this will be undefined if promise is rejected or throws\n return window.__tableauDesktopDispatcher;\n }\n LegacyInternalApiDispatcherHolder.getDesktopDispatcherPromise = getDesktopDispatcherPromise;\n /**\n * @param options\n */\n function hasDesktopApiDispatcherPromise(options) {\n return !!getDesktopDispatcherPromise(options);\n }\n LegacyInternalApiDispatcherHolder.hasDesktopApiDispatcherPromise = hasDesktopApiDispatcherPromise;\n})(LegacyInternalApiDispatcherHolder = exports.LegacyInternalApiDispatcherHolder || (exports.LegacyInternalApiDispatcherHolder = {}));\n//# sourceMappingURL=LegacyInternalApiDispatcherHolder.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar TableauEvent_1 = require(\"../Events/TableauEvent\");\nvar ServiceRegistryUtil_1 = require(\"../Services/ServiceRegistryUtil\");\nvar SettingsChangedEvent = /** @class */ (function (_super) {\n __extends(SettingsChangedEvent, _super);\n function SettingsChangedEvent(_newSettings) {\n var _this = _super.call(this, Contract.TableauEventType.SettingsChanged) || this;\n _this._newSettings = _newSettings;\n return _this;\n }\n Object.defineProperty(SettingsChangedEvent.prototype, \"newSettings\", {\n get: function () {\n return this._newSettings;\n },\n enumerable: true,\n configurable: true\n });\n return SettingsChangedEvent;\n}(TableauEvent_1.TableauEvent));\nvar SettingsImpl = /** @class */ (function () {\n function SettingsImpl(settingsInfo) {\n // Since promises can't be introspected for state, keep a variable that\n // indicates a save is in progress, so that set/erase can't be called during a save.\n this._saveInProgress = false;\n this.initializeSettings(settingsInfo);\n }\n SettingsImpl.prototype.erase = function (key) {\n api_shared_js_1.ErrorHelpers.verifyParameter(key, 'key');\n // Only make a modification if we have the key already\n if (this._currentSettings[key]) {\n this.verifySettingsAreUnlocked();\n delete this._currentSettings[key];\n this._isModified = true;\n }\n };\n SettingsImpl.prototype.get = function (key) {\n api_shared_js_1.ErrorHelpers.verifyParameter(key, 'key');\n return this._currentSettings[key];\n };\n SettingsImpl.prototype.getAll = function () {\n // Returns a mutable copy of the settings\n return Object.assign({}, this._currentSettings);\n };\n Object.defineProperty(SettingsImpl.prototype, \"isModified\", {\n get: function () {\n return this._isModified;\n },\n enumerable: true,\n configurable: true\n });\n SettingsImpl.prototype.saveAsync = function () {\n var _this = this;\n this.verifySettingsAreUnlocked();\n // Just resolve immediately if settings are unchanged\n if (!this._isModified) {\n return Promise.resolve(this._currentSettings);\n }\n this._saveInProgress = true;\n // Use the settings service to save settings to twb\n var settingsService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService(\"SettingsService\" /* SettingsService */);\n return settingsService.saveSettingsAsync(this._currentSettings).then(function (newSettings) {\n _this._saveInProgress = false;\n _this._isModified = false;\n if (_this._currentSettings === undefined) {\n _this._currentSettings = newSettings;\n }\n else {\n Object.assign(_this._currentSettings, newSettings);\n }\n return newSettings;\n }, function (reason) {\n _this._saveInProgress = false;\n return Promise.reject(reason);\n });\n };\n SettingsImpl.prototype.set = function (key, value) {\n api_shared_js_1.ErrorHelpers.verifyStringParameter(key, 'key'); // Key shouldn't be an empty string.\n api_shared_js_1.ErrorHelpers.verifyParameter(value, 'value'); // Empty string value is allowed.\n this.verifySettingsAreUnlocked();\n this._currentSettings[key] = value;\n this._isModified = true;\n };\n /**\n * Initializes all events relevant to settings object. This is only a settingsUpdate event currently.\n *\n * @returns {Array} Collection of event managers to pass to an EventListenerManager.\n */\n SettingsImpl.prototype.initializeEvents = function () {\n var _this = this;\n var results = new Array();\n var notificationService;\n try {\n notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService(\"notification-service\" /* Notification */);\n }\n catch (e) {\n // If we don't have this service registered, just return\n return results;\n }\n var settingsChangedEvent = new api_shared_js_1.SingleEventManagerImpl(Contract.TableauEventType.SettingsChanged);\n notificationService.registerHandler(api_internal_contract_js_1.NotificationId.SettingsChanged, function () { return true; }, function (event) {\n _this._currentSettings = event.newSettings;\n settingsChangedEvent.triggerEvent(function () { return new SettingsChangedEvent(event.newSettings); });\n });\n results.push(settingsChangedEvent);\n return results;\n };\n SettingsImpl.prototype.initializeSettings = function (settingsInfo) {\n api_shared_js_1.ErrorHelpers.verifyParameter(settingsInfo, 'settingsInfo');\n api_shared_js_1.ErrorHelpers.verifyParameter(settingsInfo.settingsValues, 'settingsInfo.SettingsValues');\n this._currentSettings = settingsInfo.settingsValues;\n // Reset the isModified flag\n this._isModified = false;\n };\n /**\n * This helper should be called before any local update to this.currentSettings.\n * Checks if a current save call is still in progress and throws an error if so.\n */\n SettingsImpl.prototype.verifySettingsAreUnlocked = function () {\n if (this._saveInProgress) {\n throw new api_shared_js_1.TableauError(Contract.ErrorCodes.SettingSaveInProgress, SettingsImpl.ASYNC_SAVE_IN_PROGRESS);\n }\n };\n SettingsImpl.ASYNC_SAVE_IN_PROGRESS = 'Async Save is in progress, updating settings is not allowed.';\n return SettingsImpl;\n}());\nexports.SettingsImpl = SettingsImpl;\n//# sourceMappingURL=SettingsImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TableauBookFontFamilyName = 'Tableau Book';\nexports.TableauLightFontFamilyName = 'Tableau Light';\nexports.TableauRegularFontFamilyName = 'Tableau Regular';\nexports.TableauMediumFontFamilyName = 'Tableau Medium';\nexports.TableauSemiboldFontFamilyName = 'Tableau Semibold';\nexports.TableauBoldFontFamilyName = 'Tableau Bold';\nexports.TableauBookFontFaceName = 'Tableau Book';\nexports.TableauBoldFontFaceName = 'Tableau Bold';\nexports.TableauLightFontFaceName = 'Tableau Light';\nexports.TableauMediumFontFaceName = 'Tableau Medium';\nexports.TableauRegularFontFaceName = 'Tableau Regular';\nexports.TableauSemiBoldFontFaceName = 'Tableau Semi Bold';\nexports.SupportedTableauFontFaces = [\n exports.TableauBookFontFaceName,\n exports.TableauBoldFontFaceName,\n exports.TableauLightFontFaceName,\n exports.TableauMediumFontFaceName,\n exports.TableauRegularFontFaceName,\n exports.TableauSemiBoldFontFaceName,\n];\n//# sourceMappingURL=TableauBookFontNameConstants.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar ServiceRegistryUtil_1 = require(\"../Services/ServiceRegistryUtil\");\nvar UIImpl = /** @class */ (function () {\n function UIImpl() {\n }\n UIImpl.prototype.displayDialogAsync = function (url, payload, options) {\n var uiService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService(\"UIService\" /* UIService */);\n var notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService(\"notification-service\" /* Notification */);\n return new Promise(function (resolve, reject) {\n uiService\n .displayDialogAsync(url, payload || '', options)\n .then(function () {\n var unregisterFn = notificationService.registerHandler(api_internal_contract_js_1.NotificationId.ExtensionDialogUpdate, function () {\n // Let through any dialog update event\n return true;\n }, function (event) {\n if (event.isCloseEvent) {\n if (event.closePayload === undefined) {\n throw new api_shared_js_1.TableauError(Contract.ErrorCodes.InternalError, 'closePayload is undefined');\n }\n resolve(event.closePayload);\n }\n else {\n reject(new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.DialogClosedByUser, 'Extension dialog closed by user.'));\n }\n unregisterFn();\n });\n })\n .catch(function (error) {\n reject(error);\n });\n });\n };\n UIImpl.prototype.closeDialog = function (payload) {\n var uiService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService(\"UIService\" /* UIService */);\n uiService.closeDialog(payload);\n };\n return UIImpl;\n}());\nexports.UIImpl = UIImpl;\n//# sourceMappingURL=UIImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar DashboardLayoutChangedEvent_1 = require(\"../Events/DashboardLayoutChangedEvent\");\nvar WorkbookFormattingChangedEvent_1 = require(\"../Events/WorkbookFormattingChangedEvent\");\nvar ServiceRegistryUtil_1 = require(\"../Services/ServiceRegistryUtil\");\nvar DashboardObject_1 = require(\"./DashboardObject\");\nvar Sheet_1 = require(\"./Sheet\");\nvar Worksheet_1 = require(\"./Worksheet\");\nvar Dashboard = /** @class */ (function (_super) {\n __extends(Dashboard, _super);\n function Dashboard(_dashboardImpl) {\n var _this = _super.call(this, _dashboardImpl) || this;\n _this._dashboardImpl = _dashboardImpl;\n _dashboardImpl.initializeWithPublicInterfaces();\n _this.initializeEvents().forEach(function (e) { return _this.addNewEventType(e); });\n return _this;\n }\n Object.defineProperty(Dashboard.prototype, \"worksheets\", {\n get: function () {\n return this._dashboardImpl.worksheetsImpl.map(function (worksheetImpl) {\n return new Worksheet_1.Worksheet(worksheetImpl);\n });\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Dashboard.prototype, \"objects\", {\n get: function () {\n return this._dashboardImpl.objects.map(function (dashboardObjectImpl) {\n return new DashboardObject_1.DashboardObject(dashboardObjectImpl);\n });\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Dashboard.prototype, \"activeDashboardObjectId\", {\n get: function () {\n return this._dashboardImpl.activeDashboardObjectId;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Dashboard.prototype, \"activeDashboardName\", {\n get: function () {\n return this._dashboardImpl.activeDashboardName;\n },\n enumerable: true,\n configurable: true\n });\n Dashboard.prototype.setZoneVisibilityAsync = function (zoneVisibilityMap) {\n return this._dashboardImpl.setDashboardObjectVisibilityAsync(zoneVisibilityMap);\n };\n Dashboard.prototype.setDashboardObjectVisibilityAsync = function (dashboardObjectVisibilityMap) {\n return this._dashboardImpl.setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap);\n };\n Dashboard.prototype.getDashboardObjectById = function (dashboardObjectId) {\n var zone = this._dashboardImpl.getDashboardObjectById(dashboardObjectId);\n return zone && new DashboardObject_1.DashboardObject(zone);\n };\n Dashboard.prototype.initializeEvents = function () {\n var _this = this;\n var results = new Array();\n // Initializing events and registering notification service\n var notificationService;\n try {\n notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService(\"notification-service\" /* Notification */);\n }\n catch (e) {\n // If we don't have this service registered, just return (allows unit testing without NotificationService mock)\n return results;\n }\n var dashboardLayoutChangedEvent = new api_shared_js_1.SingleEventManagerImpl(api_external_contract_js_1.TableauEventType.DashboardLayoutChanged);\n notificationService.registerHandler(api_internal_contract_js_1.NotificationId.DashboardLayoutChanged, function () { return true; }, function (event) {\n var dashboardObjectChanges = _this._dashboardImpl.updateZones(event.zones, event.activeZoneId, event.activeDashboardName);\n dashboardLayoutChangedEvent.triggerEvent(function () { return new DashboardLayoutChangedEvent_1.DashboardLayoutChangedEvent(dashboardObjectChanges); });\n });\n results.push(dashboardLayoutChangedEvent);\n var workbookFormattingChangedEvent = new api_shared_js_1.SingleEventManagerImpl(api_external_contract_js_1.TableauEventType.WorkbookFormattingChanged);\n notificationService.registerHandler(api_internal_contract_js_1.NotificationId.WorkbookFormattingChanged, function () { return true; }, function (eventFormatting) {\n workbookFormattingChangedEvent.triggerEvent(function () { return new WorkbookFormattingChangedEvent_1.WorkbookFormattingChangedEvent(eventFormatting); });\n });\n results.push(workbookFormattingChangedEvent);\n return results;\n };\n Dashboard.prototype.moveAndResizeDashboardObjectsAsync = function (dashboardObjectPositionAndSizeUpdateArray) {\n return this._dashboardImpl.moveAndResizeDashboardObjectsAsync(dashboardObjectPositionAndSizeUpdateArray);\n };\n Dashboard.prototype.replayAnimationAsync = function (replaySpeed) {\n return this._dashboardImpl.replayAnimationAsync(replaySpeed);\n };\n Dashboard.prototype.getFiltersAsync = function () {\n return this._dashboardImpl.getFiltersAsync();\n };\n Dashboard.prototype.applyFilterAsync = function (fieldName, values, updateType, options) {\n return this._dashboardImpl.applyFilterAsync(fieldName, values, updateType, options);\n };\n return Dashboard;\n}(Sheet_1.Sheet));\nexports.Dashboard = Dashboard;\n//# sourceMappingURL=Dashboard.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Dashboard_1 = require(\"./Dashboard\");\nvar Worksheet_1 = require(\"./Worksheet\");\n/**\n * Implementation of the dashboard objects - the zones in a dashboard.\n */\nvar DashboardObject = /** @class */ (function () {\n function DashboardObject(_dashboardObjectImpl) {\n this._dashboardObjectImpl = _dashboardObjectImpl;\n }\n Object.defineProperty(DashboardObject.prototype, \"dashboard\", {\n get: function () {\n return new Dashboard_1.Dashboard(this._dashboardObjectImpl.dashboardImpl);\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObject.prototype, \"type\", {\n get: function () {\n return this._dashboardObjectImpl.type;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObject.prototype, \"position\", {\n get: function () {\n return this._dashboardObjectImpl.position;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObject.prototype, \"size\", {\n get: function () {\n return this._dashboardObjectImpl.size;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObject.prototype, \"worksheet\", {\n get: function () {\n if (this._dashboardObjectImpl.worksheetImpl) {\n return new Worksheet_1.Worksheet(this._dashboardObjectImpl.worksheetImpl);\n }\n return undefined;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObject.prototype, \"name\", {\n get: function () {\n return this._dashboardObjectImpl.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObject.prototype, \"isFloating\", {\n get: function () {\n return this._dashboardObjectImpl.isFloating;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObject.prototype, \"isVisible\", {\n get: function () {\n return this._dashboardObjectImpl.isVisible;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObject.prototype, \"id\", {\n get: function () {\n return this._dashboardObjectImpl.id;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObject.prototype, \"fieldId\", {\n get: function () {\n return this._dashboardObjectImpl.fieldId;\n },\n enumerable: true,\n configurable: true\n });\n return DashboardObject;\n}());\nexports.DashboardObject = DashboardObject;\n//# sourceMappingURL=DashboardObject.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar ParameterChangedEvent_1 = require(\"../Events/ParameterChangedEvent\");\nvar ServiceRegistryUtil_1 = require(\"../Services/ServiceRegistryUtil\");\n/**\n * Implementation of the Parameter contract. Calls down to the impl\n * class for almost all of the work it does.\n */\nvar Parameter = /** @class */ (function (_super) {\n __extends(Parameter, _super);\n function Parameter(parameterImpl, sheet) {\n var _this = _super.call(this) || this;\n _this.parameterImpl = parameterImpl;\n // Initialize our event handling for this class\n _this.initializeEvents(sheet).forEach(function (e) { return _this.addNewEventType(e); });\n return _this;\n }\n Object.defineProperty(Parameter.prototype, \"name\", {\n get: function () {\n return this.parameterImpl.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Parameter.prototype, \"currentValue\", {\n get: function () {\n return this.parameterImpl.currentValue;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Parameter.prototype, \"dataType\", {\n get: function () {\n return this.parameterImpl.dataType;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Parameter.prototype, \"allowableValues\", {\n get: function () {\n return this.parameterImpl.allowableValues;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Parameter.prototype, \"id\", {\n get: function () {\n return this.parameterImpl.id;\n },\n enumerable: true,\n configurable: true\n });\n Parameter.prototype.changeValueAsync = function (newValue) {\n return this.parameterImpl.changeValueAsync(newValue);\n };\n /**\n * Helper method which goes through and registers each event type this impl knows about\n * with the NotificationService. It returns an array of SingleEventManager objects which\n * can then be passed to an EventListenerManager to handle user registration / unregistration.\n *\n * @param sheet The sheet object which will be included with the event notifications\n * @returns {Array} Collection of event managers to pass to an EventListenerManager\n */\n Parameter.prototype.initializeEvents = function (sheet) {\n var _this = this;\n api_shared_js_1.ErrorHelpers.verifyInternalValue(sheet, 'sheet');\n var results = new Array();\n var notificationService;\n try {\n notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService(\"notification-service\" /* Notification */);\n }\n catch (e) {\n // If we don't have this service registered, just return\n return results;\n }\n // Initialize all of the event managers we'll need (one for each event type)\n var parameterEvent = new api_shared_js_1.SingleEventManagerImpl(Contract.TableauEventType.ParameterChanged);\n notificationService.registerHandler(api_internal_contract_js_1.NotificationId.ParameterChanged, function (model) {\n var fieldName = model;\n return fieldName === _this.parameterImpl.id;\n }, function (fieldName) {\n parameterEvent.triggerEvent(function () { return new ParameterChangedEvent_1.ParameterChangedEvent(fieldName, sheet); });\n });\n results.push(parameterEvent);\n return results;\n };\n return Parameter;\n}(api_shared_js_1.EventListenerManager));\nexports.Parameter = Parameter;\n//# sourceMappingURL=Parameter.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar Parameter_1 = require(\"./Parameter\");\nvar Sheet = /** @class */ (function (_super) {\n __extends(Sheet, _super);\n function Sheet(_sheetImpl) {\n var _this = _super.call(this) || this;\n _this._sheetImpl = _sheetImpl;\n return _this;\n }\n Object.defineProperty(Sheet.prototype, \"name\", {\n get: function () {\n return this._sheetImpl.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Sheet.prototype, \"sheetType\", {\n get: function () {\n return this._sheetImpl.sheetType;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Sheet.prototype, \"size\", {\n get: function () {\n if (this.isValidSize(this._sheetImpl.size)) {\n return this._sheetImpl.size;\n }\n throw new api_shared_js_1.TableauError(Contract.EmbeddingErrorCodes.ImplementationError, 'Size not implemented');\n },\n enumerable: true,\n configurable: true\n });\n Sheet.prototype.isValidSize = function (size) {\n var testSize = size;\n if (testSize.width !== undefined && testSize.height !== undefined) {\n return true;\n }\n return false;\n };\n Sheet.prototype.findParameterAsync = function (parameterName) {\n var _this = this;\n return this._sheetImpl.findParameterAsync(parameterName).then(function (parameterImpl) {\n if (parameterImpl) {\n return new Promise(function (resolve) { return resolve(new Parameter_1.Parameter(parameterImpl, _this)); });\n }\n else {\n return new Promise(function (resolve) { return resolve(undefined); });\n }\n });\n };\n Sheet.prototype.getParametersAsync = function () {\n var _this = this;\n return this._sheetImpl.getParametersAsync().then(function (parametersImpl) {\n return parametersImpl.map(function (parameterImpl) {\n return new Parameter_1.Parameter(parameterImpl, _this);\n });\n });\n };\n return Sheet;\n}(api_shared_js_1.EventListenerManager));\nexports.Sheet = Sheet;\n//# sourceMappingURL=Sheet.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Workbook = /** @class */ (function () {\n function Workbook(_workbookImpl) {\n this._workbookImpl = _workbookImpl;\n }\n Workbook.prototype.getAllDataSourcesAsync = function () {\n return this._workbookImpl.getAllDataSourcesAsync();\n };\n return Workbook;\n}());\nexports.Workbook = Workbook;\n//# sourceMappingURL=Workbook.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar FilterChangedEvent_1 = require(\"../Events/FilterChangedEvent\");\nvar MarksSelectedEvent_1 = require(\"../Events/MarksSelectedEvent\");\nvar SummaryDataChangedEvent_1 = require(\"../Events/SummaryDataChangedEvent\");\nvar ServiceRegistryUtil_1 = require(\"../Services/ServiceRegistryUtil\");\nvar Dashboard_1 = require(\"./Dashboard\");\nvar Sheet_1 = require(\"./Sheet\");\nvar Worksheet = /** @class */ (function (_super) {\n __extends(Worksheet, _super);\n function Worksheet(_worksheetImpl) {\n var _this = _super.call(this, _worksheetImpl) || this;\n _this._worksheetImpl = _worksheetImpl;\n // Call to initialize events and then call down to the event listener manager to handle things\n _this.initializeEvents().forEach(function (e) { return _this.addNewEventType(e); });\n return _this;\n }\n Object.defineProperty(Worksheet.prototype, \"parentDashboard\", {\n get: function () {\n // This should never happen for Extensions if the DashboardImpls are created correctly\n if (this._worksheetImpl.parentDashboard == null) {\n throw new api_shared_js_1.TableauError(Contract.SharedErrorCodes.ImplementationError, \"Parent dashboard not implemented\");\n }\n return new Dashboard_1.Dashboard(this._worksheetImpl.parentDashboard);\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Helper method which goes through and registers each event type this impl knows about\n * with the NotificationService. It returns an array of SingleEventManager objects which\n * can then be passed to an EventListenerManager to handle user registration / unregistration.\n *\n * @param {Worksheet} worksheet The worksheet object which will be included with the event notifications\n * @returns {Array} Collection of event managers to pass to an EventListenerManager\n */\n Worksheet.prototype.initializeEvents = function () {\n var _this = this;\n var results = new Array();\n var notificationService;\n try {\n notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService(\"notification-service\" /* Notification */);\n }\n catch (e) {\n // If we don't have this service registered, just return\n return results;\n }\n // Initialize all of the event managers we'll need (one for each event type)\n var marksEvent = new api_shared_js_1.SingleEventManagerImpl(api_external_contract_js_1.TableauEventType.MarkSelectionChanged);\n notificationService.registerHandler(api_internal_contract_js_1.NotificationId.SelectedMarksChanged, function (model) {\n var visualId = model;\n return _this.visualIdsAreEqual(visualId, _this._worksheetImpl.visualId);\n }, function () { return marksEvent.triggerEvent(function () { return new MarksSelectedEvent_1.MarksSelectedEvent(_this); }); });\n var filterEvent = new api_shared_js_1.SingleEventManagerImpl(api_external_contract_js_1.TableauEventType.FilterChanged);\n notificationService.registerHandler(api_internal_contract_js_1.NotificationId.FilterChanged, function (model) {\n var filterEventResponse = model;\n return _this._worksheetImpl.visualId.worksheet === filterEventResponse.visualId.worksheet;\n }, function (event) {\n filterEvent.triggerEvent(function () { return new FilterChangedEvent_1.FilterChangedEvent(_this, event.fieldName, event.fieldId); });\n });\n var summaryDataEvent = new api_shared_js_1.SingleEventManagerImpl(api_external_contract_js_1.TableauEventType.SummaryDataChanged);\n notificationService.registerHandler(api_internal_contract_js_1.NotificationId.SummaryDataChanged, function (model) {\n var summaryDataEventResponse = model;\n return _this._worksheetImpl.visualId.worksheet === summaryDataEventResponse.visualId.worksheet;\n }, function (event) {\n summaryDataEvent.triggerEvent(function () { return new SummaryDataChangedEvent_1.SummaryDataChangedEvent(_this); });\n });\n results.push(marksEvent);\n results.push(filterEvent);\n results.push(summaryDataEvent);\n return results;\n };\n Worksheet.prototype.applyFilterAsync = function (fieldName, values, updateType, options) {\n return this._worksheetImpl.applyFilterAsync(fieldName, values, updateType, options);\n };\n Worksheet.prototype.applyRangeFilterAsync = function (fieldName, filterOptions) {\n return this._worksheetImpl.applyRangeFilterAsync(fieldName, filterOptions);\n };\n Worksheet.prototype.applyHierarchicalFilterAsync = function (fieldName, values, updateType, options) {\n return this._worksheetImpl.applyHierarchicalFilterAsync(fieldName, values, updateType, options);\n };\n Worksheet.prototype.applyRelativeDateFilterAsync = function (fieldName, options) {\n return this._worksheetImpl.applyRelativeDateFilterAsync(fieldName, options);\n };\n Worksheet.prototype.clearFilterAsync = function (fieldName) {\n return this._worksheetImpl.clearFilterAsync(fieldName);\n };\n Worksheet.prototype.getDataSourcesAsync = function () {\n return this._worksheetImpl.getDataSourcesAsync();\n };\n Worksheet.prototype.getFiltersAsync = function () {\n return this._worksheetImpl.getFiltersAsync();\n };\n Worksheet.prototype.getSelectedMarksAsync = function () {\n return this._worksheetImpl.getSelectedMarksAsync();\n };\n Worksheet.prototype.getHighlightedMarksAsync = function () {\n return this._worksheetImpl.getHighlightedMarksAsync();\n };\n Worksheet.prototype.getSummaryDataAsync = function (options) {\n return this._worksheetImpl.getSummaryDataAsync(options);\n };\n Worksheet.prototype.getSummaryDataReaderAsync = function (pageRowCount, options) {\n return this._worksheetImpl.getSummaryDataReaderAsync(pageRowCount, options);\n };\n Worksheet.prototype.getSummaryColumnsInfoAsync = function () {\n return this._worksheetImpl.getSummaryColumnsInfoAsync();\n };\n Worksheet.prototype.getUnderlyingDataAsync = function (options) {\n console.warn('Worksheet.getUnderlyingDataAsync is deprecated. Please use ' +\n 'Worksheet.getUnderlyingTablesAsync and Worksheet.getUnderlyingTableDataAsync');\n return this._worksheetImpl.getUnderlyingDataAsync(options);\n };\n Worksheet.prototype.getUnderlyingTablesAsync = function () {\n return this._worksheetImpl.getUnderlyingTablesAsync();\n };\n Worksheet.prototype.getUnderlyingTableDataAsync = function (logicalTableId, options) {\n return this._worksheetImpl.getUnderlyingTableDataAsync(logicalTableId, options);\n };\n Worksheet.prototype.getUnderlyingTableDataReaderAsync = function (logicalTableId, pageRowCount, options) {\n return this._worksheetImpl.getUnderlyingTableDataReaderAsync(logicalTableId, pageRowCount, options);\n };\n Worksheet.prototype.getVisualSpecificationAsync = function () {\n return this._worksheetImpl.getVisualSpecificationAsync();\n };\n Worksheet.prototype.clearSelectedMarksAsync = function () {\n return this._worksheetImpl.clearSelectedMarksAsync();\n };\n Worksheet.prototype.selectMarksByIDAsync = function (marksInfo, updateType) {\n return this._worksheetImpl.selectMarksByIdAsync(marksInfo, updateType);\n };\n Worksheet.prototype.selectMarksByValueAsync = function (selections, selectionUpdateType) {\n return this._worksheetImpl.selectMarksByValueAsync(selections, selectionUpdateType);\n };\n Worksheet.prototype.selectMarksByIdAsync = function (selections, selectionUpdateType) {\n return this._worksheetImpl.selectMarksByIdAsync(selections, selectionUpdateType);\n };\n Worksheet.prototype.annotateMarkAsync = function (mark, annotationText) {\n return this._worksheetImpl.annotateMarkAsync(mark, annotationText);\n };\n Worksheet.prototype.getAnnotationsAsync = function () {\n return this._worksheetImpl.getAnnotationsAsync();\n };\n Worksheet.prototype.removeAnnotationAsync = function (annotation) {\n return this._worksheetImpl.removeAnnotationAsync(annotation);\n };\n Worksheet.prototype.hoverTupleAsync = function (hoveredTuple, tooltip, allowHoverActions) {\n if (allowHoverActions === void 0) { allowHoverActions = true; }\n return this._worksheetImpl.hoverTupleAsync(hoveredTuple, tooltip, allowHoverActions);\n };\n Worksheet.prototype.selectTuplesAsync = function (selectedTuples, selectOption, tooltip) {\n return this._worksheetImpl.selectTuplesAsync(selectedTuples, selectOption, tooltip);\n };\n Worksheet.prototype.getTooltipTextAsync = function (tupleId) {\n return this._worksheetImpl.getTooltipTextAsync(tupleId);\n };\n Worksheet.prototype.leaveMarkNavigationAsync = function () {\n return this._worksheetImpl.leaveMarkNavigationAsync();\n };\n Worksheet.prototype.visualIdsAreEqual = function (a, b) {\n return (a &&\n b &&\n a.worksheet === b.worksheet &&\n a.dashboard === b.dashboard &&\n a.storyboard === b.storyboard &&\n a.storyPointID === b.storyPointID);\n };\n return Worksheet;\n}(Sheet_1.Sheet));\nexports.Worksheet = Worksheet;\n//# sourceMappingURL=Worksheet.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Implementation of the external DashboardContent namespace.\n * This does not follow the Impl pattern as DashboardContent is\n * currently just a (single) property bag.\n */\nvar DashboardContent = /** @class */ (function () {\n function DashboardContent(_dashboard) {\n this._dashboard = _dashboard;\n }\n Object.defineProperty(DashboardContent.prototype, \"dashboard\", {\n get: function () {\n return this._dashboard;\n },\n enumerable: true,\n configurable: true\n });\n return DashboardContent;\n}());\nexports.DashboardContent = DashboardContent;\n//# sourceMappingURL=DashboardContent.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar ConnectedServer_1 = require(\"../Impl/ConnectedServer\");\nvar WorkbookFormattingEnvUtil_1 = require(\"./WorkbookFormattingEnvUtil\");\n/**\n * Implementation of the external environment namespace.\n * Environment does not follow the Impl pattern as it is\n * just a property bag.\n * First class extensions can get to ConnectedServer with: environment['connectedServer']\n */\nvar Environment = /** @class */ (function () {\n function Environment(extensionEnvironment) {\n this._apiVersion = api_shared_js_1.ApiVersion.Instance && api_shared_js_1.ApiVersion.Instance.formattedValue; // maj.min.fix (no build)\n this._context = api_shared_js_1.InternalToExternalEnumMappings.extensionContext.convert(extensionEnvironment.extensionContext);\n this._formatting = WorkbookFormattingEnvUtil_1.WorkbookFormattingEnvUtil.convertToWorkbookFormatting(extensionEnvironment.workbookFormatting);\n this._language = extensionEnvironment.extensionLanguage;\n this._country = extensionEnvironment.extensionCountry;\n this._locale = extensionEnvironment.extensionLocale;\n this._mode = api_shared_js_1.InternalToExternalEnumMappings.extensionMode.convert(extensionEnvironment.extensionMode);\n this._operatingSystem = extensionEnvironment.operatingSystem;\n this._tableauVersion = extensionEnvironment.tableauVersion;\n this._uniqueUserId = extensionEnvironment.uniqueUserId;\n // If we have a userId, then we are a first class extension\n if (extensionEnvironment.userId) {\n this.connectedServer = new ConnectedServer_1.ConnectedServer(extensionEnvironment.userId, extensionEnvironment.siteId, extensionEnvironment.siteNamespace, extensionEnvironment.workbookId);\n this.featureFlags = extensionEnvironment.featureFlags;\n }\n }\n Object.defineProperty(Environment.prototype, \"apiVersion\", {\n get: function () {\n return this._apiVersion;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"context\", {\n get: function () {\n return this._context;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"workbookFormatting\", {\n get: function () {\n return this._formatting;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"language\", {\n get: function () {\n return this._language;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"country\", {\n get: function () {\n return this._country;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"locale\", {\n get: function () {\n return this._locale;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"mode\", {\n get: function () {\n return this._mode;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"operatingSystem\", {\n get: function () {\n return this._operatingSystem;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"tableauVersion\", {\n get: function () {\n return this._tableauVersion;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Environment.prototype, \"uniqueUserId\", {\n get: function () {\n return this._uniqueUserId;\n },\n enumerable: true,\n configurable: true\n });\n return Environment;\n}());\nexports.Environment = Environment;\n//# sourceMappingURL=Environment.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Implementation of the external Extensions namespace.\n */\nvar Extensions = /** @class */ (function () {\n function Extensions(extensionImpl) {\n this.extensionImpl = extensionImpl;\n this.extensionImpl = extensionImpl;\n }\n Object.defineProperty(Extensions.prototype, \"dashboardContent\", {\n get: function () {\n return this.extensionImpl.dashboardContent;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Extensions.prototype, \"worksheetContent\", {\n get: function () {\n return this.extensionImpl.worksheetContent;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Extensions.prototype, \"environment\", {\n get: function () {\n return this.extensionImpl.environment;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Extensions.prototype, \"settings\", {\n get: function () {\n return this.extensionImpl.settings;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Extensions.prototype, \"ui\", {\n get: function () {\n return this.extensionImpl.ui;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Extensions.prototype, \"workbook\", {\n get: function () {\n return this.extensionImpl.workbook;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Extensions.prototype, \"dashboardObjectId\", {\n get: function () {\n return this.extensionImpl.extensionZoneId;\n },\n enumerable: true,\n configurable: true\n });\n Extensions.prototype.initializeAsync = function (contextMenuCallbacks) {\n return this.extensionImpl.initializeAsync(false, contextMenuCallbacks).then();\n };\n Extensions.prototype.initializeDialogAsync = function () {\n return this.extensionImpl.initializeAsync(true);\n };\n Extensions.prototype.createVizImageAsync = function (inputSpec) {\n return this.extensionImpl.createVizImageAsync(inputSpec);\n };\n Extensions.prototype.setClickThroughAsync = function (clickThroughEnabled) {\n return this.extensionImpl.setClickThroughAsync(clickThroughEnabled);\n };\n return Extensions;\n}());\nexports.Extensions = Extensions;\n//# sourceMappingURL=Extensions.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\n/**\n * Implementation of the external settings namespace.\n */\nvar Settings = /** @class */ (function (_super) {\n __extends(Settings, _super);\n function Settings(_settingsImpl) {\n var _this = _super.call(this) || this;\n _this._settingsImpl = _settingsImpl;\n // Initialize our event handling for this class\n _this._settingsImpl.initializeEvents().forEach(function (e) { return _this.addNewEventType(e); });\n return _this;\n }\n Settings.prototype.erase = function (key) {\n this._settingsImpl.erase(key);\n };\n Settings.prototype.get = function (key) {\n return this._settingsImpl.get(key);\n };\n Settings.prototype.getAll = function () {\n return this._settingsImpl.getAll();\n };\n Object.defineProperty(Settings.prototype, \"isModified\", {\n get: function () {\n return this._settingsImpl.isModified;\n },\n enumerable: true,\n configurable: true\n });\n Settings.prototype.saveAsync = function () {\n return this._settingsImpl.saveAsync();\n };\n Settings.prototype.set = function (key, value) {\n this._settingsImpl.set(key, value);\n };\n return Settings;\n}(api_shared_js_1.EventListenerManager));\nexports.Settings = Settings;\n//# sourceMappingURL=Settings.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Implementation of the external UI namespace.\n */\nvar UI = /** @class */ (function () {\n function UI(_impl) {\n this._impl = _impl;\n }\n UI.prototype.displayDialogAsync = function (url, payload, options) {\n return this._impl.displayDialogAsync(url, payload, options);\n };\n UI.prototype.closeDialog = function (payload) {\n this._impl.closeDialog(payload);\n };\n return UI;\n}());\nexports.UI = UI;\n//# sourceMappingURL=UI.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar WorkbookFormattingEnvUtil = /** @class */ (function () {\n function WorkbookFormattingEnvUtil() {\n }\n WorkbookFormattingEnvUtil.convertToWorkbookFormatting = function (workbookFormattingModel) {\n if (!workbookFormattingModel) {\n return undefined;\n }\n else {\n var formattingMap = workbookFormattingModel.formattingSheets.map(function (currentFormattingSheet) {\n var formattingSheet = {\n classNameKey: api_shared_js_1.InternalToExternalEnumMappings.classNameKey.convert(currentFormattingSheet.classNameKey),\n cssProperties: {\n fontFamily: currentFormattingSheet.cssProperties.fontFamily,\n fontSize: currentFormattingSheet.cssProperties.fontSize,\n fontWeight: currentFormattingSheet.cssProperties.fontWeight,\n fontStyle: currentFormattingSheet.cssProperties.fontStyle,\n textDecoration: currentFormattingSheet.cssProperties.textDecoration,\n color: currentFormattingSheet.cssProperties.color,\n },\n };\n return formattingSheet;\n });\n var result = {\n formattingSheets: formattingMap,\n };\n return result;\n }\n };\n return WorkbookFormattingEnvUtil;\n}());\nexports.WorkbookFormattingEnvUtil = WorkbookFormattingEnvUtil;\n//# sourceMappingURL=WorkbookFormattingEnvUtil.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Implementation of the external WorksheetContent namespace.\n * This does not follow the Impl pattern as WorksheetContent is\n * currently just a (single) property bag.\n */\nvar WorksheetContent = /** @class */ (function () {\n function WorksheetContent(_worksheet) {\n this._worksheet = _worksheet;\n }\n Object.defineProperty(WorksheetContent.prototype, \"worksheet\", {\n get: function () {\n return this._worksheet;\n },\n enumerable: true,\n configurable: true\n });\n return WorksheetContent;\n}());\nexports.WorksheetContent = WorksheetContent;\n//# sourceMappingURL=WorksheetContent.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar InitializationServiceImpl = /** @class */ (function (_super) {\n __extends(InitializationServiceImpl, _super);\n function InitializationServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(InitializationServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"InitializationService\" /* InitializationService */;\n },\n enumerable: true,\n configurable: true\n });\n InitializationServiceImpl.prototype.initializeDashboardExtensionsAsync = function (isExtensionDialog, contextMenuIds) {\n var _a;\n var params = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'initializeDashboardExtensionsAsync',\n _a[api_internal_contract_js_1.ParameterId.ExtensionContextMenuIds] = contextMenuIds,\n _a[api_internal_contract_js_1.ParameterId.IsExtensionDialog] = isExtensionDialog,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.InitializeExtension, params).then(function (response) {\n // TODO - Validate return value\n var result = response.result;\n return result;\n });\n };\n return InitializationServiceImpl;\n}(api_shared_js_1.ServiceImplBase));\nexports.InitializationServiceImpl = InitializationServiceImpl;\n//# sourceMappingURL=InitializationServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar SettingsServiceImpl = /** @class */ (function (_super) {\n __extends(SettingsServiceImpl, _super);\n function SettingsServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(SettingsServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"SettingsService\" /* SettingsService */;\n },\n enumerable: true,\n configurable: true\n });\n SettingsServiceImpl.prototype.saveSettingsAsync = function (settings) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'saveSettingsAsync',\n _a[api_internal_contract_js_1.ParameterId.SettingsValues] = settings,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.SaveExtensionSettings, parameters).then(function (value) {\n var result = value.result;\n if (!result || !result.settingsValues) {\n throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, 'Unexpected error savings settings.');\n }\n return result.settingsValues;\n });\n };\n return SettingsServiceImpl;\n}(api_shared_js_1.ServiceImplBase));\nexports.SettingsServiceImpl = SettingsServiceImpl;\n//# sourceMappingURL=SettingsServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar DEFAULT_DIALOG_HEIGHT = 400; // in pixels\nvar DEFAULT_DIALOG_WIDTH = 600; // in pixels\nvar DEFAULT_DIALOG_STYLE = api_external_contract_js_1.DialogStyle.Window;\nvar UIServiceImpl = /** @class */ (function (_super) {\n __extends(UIServiceImpl, _super);\n function UIServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(UIServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"UIService\" /* UIService */;\n },\n enumerable: true,\n configurable: true\n });\n UIServiceImpl.prototype.displayDialogAsync = function (url, payload, options) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'displayDialogAsync',\n _a[api_internal_contract_js_1.ParameterId.ExtensionDialogUrl] = url,\n _a[api_internal_contract_js_1.ParameterId.ExtensionDialogPayload] = payload,\n _a);\n var h = options && options.height ? options.height : DEFAULT_DIALOG_HEIGHT;\n var w = options && options.width ? options.width : DEFAULT_DIALOG_WIDTH;\n var dialogStyle = options && options.dialogStyle ? options.dialogStyle : DEFAULT_DIALOG_STYLE;\n // On the platform side, we do something reasonable regardess of whether the passed\n // height and width are too large or too small. But this likely indicates a developer error,\n // so we throw an error here to help with debugging.\n if (h <= 0 || w <= 0) {\n throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'Size parameters for displayDialogAsync must be positive');\n }\n parameters[api_internal_contract_js_1.ParameterId.ExtensionDialogH] = h;\n parameters[api_internal_contract_js_1.ParameterId.ExtensionDialogW] = w;\n api_shared_js_1.ErrorHelpers.verifyEnumValue(dialogStyle, api_external_contract_js_1.DialogStyle, 'DialogStyle');\n parameters[api_internal_contract_js_1.ParameterId.ExtensionDialogStyle] = api_shared_js_1.ExternalToInternalEnumMappings.dialogStyles.convert(dialogStyle);\n return this.execute(api_internal_contract_js_1.VerbId.DisplayDialog, parameters).then(function (response) {\n var dialogResult = response.result;\n switch (dialogResult) {\n case api_internal_contract_js_1.ExtensionDialogResult.DialogAlreadyOpen:\n throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.DialogAlreadyOpen, 'There already exists an open dialog for this extension.');\n case api_internal_contract_js_1.ExtensionDialogResult.InvalidDomain:\n throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidDomainDialog, 'The url of an extension dialog must match the domain of the parent extension.');\n default:\n // Success case\n return;\n }\n });\n };\n UIServiceImpl.prototype.closeDialog = function (payload) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'closeDialog',\n _a);\n if (payload) {\n parameters[api_internal_contract_js_1.ParameterId.ExtensionDialogPayload] = payload;\n }\n return this.execute(api_internal_contract_js_1.VerbId.CloseDialog, parameters).then(function () {\n return;\n });\n };\n UIServiceImpl.prototype.setClickThroughAsync = function (clickThroughEnabled, extensionZoneId) {\n var _a;\n api_shared_js_1.ErrorHelpers.verifyParameterType(clickThroughEnabled, 'boolean', 'clickThroughEnabled');\n if (extensionZoneId === undefined || extensionZoneId <= 0) {\n throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, 'Extension Id is invalid.');\n }\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.ExtensionZoneId] = extensionZoneId,\n _a[api_internal_contract_js_1.ParameterId.ClickThroughEnabled] = clickThroughEnabled,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.SetClickThrough, parameters).then(function () {\n return;\n });\n };\n return UIServiceImpl;\n}(api_shared_js_1.ServiceImplBase));\nexports.UIServiceImpl = UIServiceImpl;\n//# sourceMappingURL=UIServiceImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nvar InitializationServiceImpl_1 = require(\"./Impl/InitializationServiceImpl\");\nvar SettingsServiceImpl_1 = require(\"./Impl/SettingsServiceImpl\");\nvar UIServiceImpl_1 = require(\"./Impl/UIServiceImpl\");\nvar ServiceRegistryUtil_1 = require(\"./ServiceRegistryUtil\");\nfunction registerAllExtensionsServices(dispatcher) {\n api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).registerService(new SettingsServiceImpl_1.SettingsServiceImpl(dispatcher, ServiceRegistryUtil_1.ExtensionsRegistryId));\n api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).registerService(new UIServiceImpl_1.UIServiceImpl(dispatcher, ServiceRegistryUtil_1.ExtensionsRegistryId));\n}\nexports.registerAllExtensionsServices = registerAllExtensionsServices;\nfunction registerInitializationExtensionsServices(dispatcher) {\n api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).registerService(new InitializationServiceImpl_1.InitializationServiceImpl(dispatcher, ServiceRegistryUtil_1.ExtensionsRegistryId));\n}\nexports.registerInitializationExtensionsServices = registerInitializationExtensionsServices;\n//# sourceMappingURL=RegisterAllExtensionsServices.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ExtensionsRegistryId = 0;\n//# sourceMappingURL=ServiceRegistryUtil.js.map","\"use strict\";\n// This file re-exports everything which is part of the extensions api public interface\nfunction __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./ExternalContract/Embedding/AskDataInterfaces\"));\nvar Enums_1 = require(\"./ExternalContract/Embedding/Enums\");\nexports.ApiMenuType = Enums_1.ApiMenuType;\nexports.CrosstabFileFormat = Enums_1.CrosstabFileFormat;\nexports.DeviceType = Enums_1.DeviceType;\nexports.EmbeddingErrorCodes = Enums_1.EmbeddingErrorCodes;\nexports.EmbeddingTableauEventType = Enums_1.TableauEventType;\nexports.FileFormats = Enums_1.FileFormats;\nexports.PrintOrientation = Enums_1.PrintOrientation;\nexports.PrintPageSize = Enums_1.PrintPageSize;\nexports.PrintScaling = Enums_1.PrintScaling;\nexports.PulseLayout = Enums_1.PulseLayout;\nexports.SheetSizeBehavior = Enums_1.SheetSizeBehavior;\nexports.TableauDialogType = Enums_1.TableauDialogType;\nexports.Toolbar = Enums_1.Toolbar;\n__export(require(\"./ExternalContract/Embedding/PulseInterfaces\"));\n__export(require(\"./ExternalContract/Embedding/VizInterfaces\"));\n__export(require(\"./ExternalContract/Embedding/WebComponentInterfaces\"));\n__export(require(\"./SharedApiExternalContract\"));\n//# sourceMappingURL=EmbeddingApiExternalContract.js.map","\"use strict\";\n// This file re-exports everything which is part of the extensions api public interface\nfunction __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Tableau_1 = require(\"./ExternalContract/Extensions/Namespaces/Tableau\");\nexports.ErrorCodes = Tableau_1.ErrorCodes;\nexports.ExtensionContext = Tableau_1.ExtensionContext;\nexports.ExtensionMode = Tableau_1.ExtensionMode;\nexports.TableauEventType = Tableau_1.TableauEventType;\nexports.VizImageEncodingType = Tableau_1.VizImageEncodingType;\nexports.VizImagePaletteType = Tableau_1.VizImagePaletteType;\nexports.VizImageSizeSettingAlignmentType = Tableau_1.VizImageSizeSettingAlignmentType;\nexports.VizImageSizeSettingType = Tableau_1.VizImageSizeSettingType;\nexports.VizImageSortDirectionType = Tableau_1.VizImageSortDirectionType;\n__export(require(\"./SharedApiExternalContract\"));\n//# sourceMappingURL=ExtensionsApiExternalContract.js.map","\"use strict\";\n/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\nfunction __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./EmbeddingApiExternalContract\"));\n__export(require(\"./ExtensionsApiExternalContract\"));\n//# sourceMappingURL=ExternalContract.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * The names of the string constants you can use as HTML attributes for the web component.\n * @ignore\n * @deprecated\n */\nvar AskDataAttributes;\n(function (AskDataAttributes) {\n AskDataAttributes[\"Origin\"] = \"origin\";\n AskDataAttributes[\"ShowEmbed\"] = \"show-embed\";\n AskDataAttributes[\"ShowPin\"] = \"show-pin\";\n AskDataAttributes[\"ShowSave\"] = \"show-save\";\n AskDataAttributes[\"ShowShare\"] = \"show-share\";\n})(AskDataAttributes = exports.AskDataAttributes || (exports.AskDataAttributes = {}));\n//# sourceMappingURL=AskDataInterfaces.js.map","\"use strict\";\n// All enum values made available to Embedding developers.\n// Enums should be kept in alphabetical order.\n// Most of them should match an enum on the server defined at\n// workgroup/vqlweb/scriptsharp/src/ApiShared/PublicEnums.cs#L398:17\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Crosstab file formats available to use with {@link Viz.exportCrosstabAsync}\n */\nvar CrosstabFileFormat;\n(function (CrosstabFileFormat) {\n CrosstabFileFormat[\"CSV\"] = \"csv\";\n CrosstabFileFormat[\"Excel\"] = \"xlsx\";\n})(CrosstabFileFormat = exports.CrosstabFileFormat || (exports.CrosstabFileFormat = {}));\n/**\n * Device types available to use with {@link Viz.device}\n */\nvar DeviceType;\n(function (DeviceType) {\n DeviceType[\"Default\"] = \"default\";\n DeviceType[\"Desktop\"] = \"desktop\";\n DeviceType[\"Tablet\"] = \"tablet\";\n DeviceType[\"Phone\"] = \"phone\";\n})(DeviceType = exports.DeviceType || (exports.DeviceType = {}));\n/**\n * All error codes used by the Embedding API.\n */\nvar EmbeddingErrorCodes;\n(function (EmbeddingErrorCodes) {\n /**\n * Raised when a request to the auth endpoint fails.\n */\n EmbeddingErrorCodes[\"AuthFailed\"] = \"auth-failed\";\n /**\n * The browser is not capable of supporting the Tableau Embedding API\n */\n EmbeddingErrorCodes[\"BrowserNotCapable\"] = \"browser-not-capable\";\n /**\n * The permissions on a workbook or a view do not allow downloading the workbook.\n */\n EmbeddingErrorCodes[\"DownloadWorkbookNotAllowed\"] = \"download-workbook-not-allowed\";\n /**\n * Thrown when an error occurs while attempting to perform a filter operation.\n */\n EmbeddingErrorCodes[\"FilterCannotBePerformed\"] = \"filter-cannot-be-performed\";\n /**\n * Thrown when attempting to switch to a sheet by index that does not exist in the workbook.\n */\n EmbeddingErrorCodes[\"IndexOutOfRange\"] = \"index-out-of-range\";\n /**\n * Thrown when an error occurs within the Tableau Embedding API. Contact Tableau Support.\n */\n EmbeddingErrorCodes[\"InternalError\"] = \"internal-error\";\n /**\n * An operation was attempted on a custom view that does not exist.\n */\n EmbeddingErrorCodes[\"InvalidCustomViewName\"] = \"invalid-custom-view-name\";\n /**\n * An invalid date was specified in a method that required a date parameter.\n */\n EmbeddingErrorCodes[\"InvalidDateParameter\"] = \"invalid-date-parameter\";\n /**\n * Either a filter operation was attempted on a field that does not exist in the data source, or the value supplied\n * in the filter operation is the wrong data type or format.\n */\n EmbeddingErrorCodes[\"invalidFilterFieldNameOrValue\"] = \"invalid-filter-field-name\";\n /**\n * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message\n * field.\n */\n EmbeddingErrorCodes[\"InvalidParameter\"] = \"invalid-parameter\";\n /**\n * A negative size was specified or the maxSize value is less than minSize in Sheet.changeSizeAsync().\n */\n EmbeddingErrorCodes[\"InvalidSize\"] = \"invalid-size\";\n /**\n * Attempted to get an authoring worksheet when the current sheet is not a worksheet.\n * @ignore\n */\n EmbeddingErrorCodes[\"InvalidSheetType\"] = \"invalid-sheet-type\";\n /**\n * A behavior value was found that is not included in the SheetSizeBehavior enum.\n */\n EmbeddingErrorCodes[\"InvalidSizeBehavior\"] = \"invalid-size-behavior\";\n /**\n * A behavior other than SheetSizeBehavior.Automatic was specified in Sheet.changeSizeAsync() when the sheet is a\n * Worksheet instance.\n */\n EmbeddingErrorCodes[\"InvalidSizeBehaviorOnWorksheet\"] = \"invalid-size-behavior-on-worksheet\";\n /**\n * The URL specified in the Viz class constructor is not valid.\n */\n EmbeddingErrorCodes[\"InvalidUrl\"] = \"invalid-url\";\n /**\n * The maxSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.AtMost.\n */\n EmbeddingErrorCodes[\"MissingMaxSize\"] = \"missing-max-size\";\n /**\n * The minSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.AtLeast.\n */\n EmbeddingErrorCodes[\"MissingMinSize\"] = \"missing-min-size\";\n /**\n * The minSize or maxSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.Range.\n */\n EmbeddingErrorCodes[\"MissingMinMaxSize\"] = \"missing-min-max-size\";\n /**\n * Can occur if the embedding app interacts with a parameter that has been removed from the worksheet.\n */\n EmbeddingErrorCodes[\"MissingParameter\"] = \"missing-parameter\";\n /**\n * The rangeN field is missing for a relative date filter of type LASTN or NEXTN.\n */\n EmbeddingErrorCodes[\"MissingRangeNForRelativeDateFilters\"] = \"missing-range-n-for-relative-date-filters\";\n /**\n * An attempt was made to access Sheet.getUrl() on a hidden sheet. Hidden sheets do not have URLs.\n */\n EmbeddingErrorCodes[\"NoUrlForHiddenWorksheet\"] = \"no-url-for-hidden-worksheet\";\n /**\n * One or both of the parentElement or the URL parameters is not specified in the Viz constructor.\n */\n EmbeddingErrorCodes[\"NoUrlOrParentElementNotFound\"] = \"no-url-or-parent-element-not-found\";\n /**\n * An operation was attempted on a sheet that is not active or embedded within the active dashboard.\n */\n EmbeddingErrorCodes[\"NotActiveSheet\"] = \"not-active-sheet\";\n /**\n * A required parameter was not specified, null, or an empty string/array.\n */\n EmbeddingErrorCodes[\"NullOrEmptyParameter\"] = \"null-or-empty-parameter\";\n /**\n * An operation was attempted on a sheet that does not exist in the workbook.\n */\n EmbeddingErrorCodes[\"SheetNotInWorkbook\"] = \"sheet-not-in-workbook\";\n /**\n * An operation is performed on a CustomView object that is no longer valid (it has been removed).\n */\n EmbeddingErrorCodes[\"StaleDataReference\"] = \"stale-data-reference\";\n /**\n * Unknown error triggered during the auth flow.\n */\n EmbeddingErrorCodes[\"UnknownAuthError\"] = \"unknown-auth-error\";\n /**\n * An unknown event name was specified in the call to Viz.addEventListener or Viz.removeEventListener.\n */\n EmbeddingErrorCodes[\"UnsupportedEventName\"] = \"unsupported-event-name\";\n /**\n * A Viz object has already been created as a child of the parentElement specified in the Viz constructor.\n */\n EmbeddingErrorCodes[\"VizAlreadyInManager\"] = \"viz-already-in-manager\";\n /**\n * Function is not supported in the embedding api.\n */\n EmbeddingErrorCodes[\"ImplementationError\"] = \"wrong-implementation\";\n /**\n * @NotImplemented\n */\n EmbeddingErrorCodes[\"NotImplemented\"] = \"not-implemented\";\n /**\n * Unknown error during event initialization\n */\n EmbeddingErrorCodes[\"EventInitializationError\"] = \"event-initialization-error\";\n /**\n * Version of the embedding api not supported by the version of tableau\n */\n EmbeddingErrorCodes[\"IncompatibleVersionError\"] = \"incompatible-version-error\";\n /**\n * Unknown {@link TableauDialogType} passed in to Viz.displayDialogAsync.\n */\n EmbeddingErrorCodes[\"UnknownDialogType\"] = \"unknown-dialog-type\";\n /**\n * Can occur if the API interacts with a filter that has been removed from the worksheet.\n * Can also occurs if a {@link FilterType} has not been implemented.\n */\n EmbeddingErrorCodes[\"FilterMissingOrNotImplemented\"] = \"filter-missing-not-implemented\";\n /**\n * Can occur if story point ids no longer match.\n */\n EmbeddingErrorCodes[\"StoryPointIdMismatch\"] = \"storypoint-id-mismatch\";\n})(EmbeddingErrorCodes = exports.EmbeddingErrorCodes || (exports.EmbeddingErrorCodes = {}));\n/**\n * Formats available to use with displayStaticImage in @VizInterfaces\n */\nvar FileFormats;\n(function (FileFormats) {\n FileFormats[\"PDF\"] = \"pdf\";\n FileFormats[\"PNG\"] = \"png\";\n})(FileFormats = exports.FileFormats || (exports.FileFormats = {}));\nvar PrintOrientation;\n(function (PrintOrientation) {\n PrintOrientation[\"Portrait\"] = \"portrait\";\n PrintOrientation[\"Landscape\"] = \"landscape\";\n})(PrintOrientation = exports.PrintOrientation || (exports.PrintOrientation = {}));\nvar PrintPageSize;\n(function (PrintPageSize) {\n PrintPageSize[\"Letter\"] = \"letter\";\n PrintPageSize[\"Legal\"] = \"legal\";\n PrintPageSize[\"Note\"] = \"note\";\n PrintPageSize[\"Folio\"] = \"folio\";\n PrintPageSize[\"Tabloid\"] = \"tabloid\";\n PrintPageSize[\"Ledger\"] = \"ledger\";\n PrintPageSize[\"Statement\"] = \"statement\";\n PrintPageSize[\"Executive\"] = \"executive\";\n PrintPageSize[\"A3\"] = \"A3\";\n PrintPageSize[\"A4\"] = \"A4\";\n PrintPageSize[\"A5\"] = \"A5\";\n PrintPageSize[\"B4\"] = \"B4\";\n PrintPageSize[\"B5\"] = \"B5\";\n PrintPageSize[\"Quarto\"] = \"quarto\";\n PrintPageSize[\"Unspecified\"] = \"unspecified\";\n})(PrintPageSize = exports.PrintPageSize || (exports.PrintPageSize = {}));\nvar PrintScaling;\n(function (PrintScaling) {\n PrintScaling[\"Automatic\"] = \"automatic\";\n PrintScaling[\"Perc25\"] = \"25%\";\n PrintScaling[\"Perc50\"] = \"50%\";\n PrintScaling[\"Perc60\"] = \"60%\";\n PrintScaling[\"Perc75\"] = \"75%\";\n PrintScaling[\"Perc80\"] = \"80%\";\n PrintScaling[\"Perc90\"] = \"90%\";\n PrintScaling[\"Perc100\"] = \"100%\";\n PrintScaling[\"Perc200\"] = \"200%\";\n PrintScaling[\"Perc400\"] = \"400%\";\n PrintScaling[\"AtMost1PageHigh\"] = \"at-most-1-page-high\";\n PrintScaling[\"AtMost2PagesHigh\"] = \"at-most-2-pages-high\";\n PrintScaling[\"AtMost1PageWide\"] = \"at-most-1-page-wide\";\n PrintScaling[\"AtMost2PagesWide\"] = \"at-most-2-pages-wide\";\n})(PrintScaling = exports.PrintScaling || (exports.PrintScaling = {}));\nvar RevertVizSelection;\n(function (RevertVizSelection) {\n RevertVizSelection[\"All\"] = \"all\";\n RevertVizSelection[\"Axes\"] = \"axes\";\n RevertVizSelection[\"Filters\"] = \"filters\";\n RevertVizSelection[\"Sorts\"] = \"sorts\";\n RevertVizSelection[\"Shelves\"] = \"shelves\";\n})(RevertVizSelection = exports.RevertVizSelection || (exports.RevertVizSelection = {}));\nvar ToolbarButtons;\n(function (ToolbarButtons) {\n ToolbarButtons[\"Alerts\"] = \"alerts\";\n ToolbarButtons[\"AskData\"] = \"askData\";\n ToolbarButtons[\"CustomViews\"] = \"customViews\";\n ToolbarButtons[\"DataDetails\"] = \"dataDetails\";\n ToolbarButtons[\"Share\"] = \"share\";\n ToolbarButtons[\"Subscribe\"] = \"subscribe\";\n})(ToolbarButtons = exports.ToolbarButtons || (exports.ToolbarButtons = {}));\nvar Toolbar;\n(function (Toolbar) {\n Toolbar[\"Top\"] = \"top\";\n Toolbar[\"Bottom\"] = \"bottom\";\n Toolbar[\"Hidden\"] = \"hidden\";\n})(Toolbar = exports.Toolbar || (exports.Toolbar = {}));\nvar SheetSizeBehavior;\n(function (SheetSizeBehavior) {\n SheetSizeBehavior[\"Automatic\"] = \"automatic\";\n SheetSizeBehavior[\"Exactly\"] = \"exactly\";\n SheetSizeBehavior[\"Range\"] = \"range\";\n SheetSizeBehavior[\"AtLeast\"] = \"atleast\";\n SheetSizeBehavior[\"AtMost\"] = \"atmost\";\n})(SheetSizeBehavior = exports.SheetSizeBehavior || (exports.SheetSizeBehavior = {}));\nvar PulseLayout;\n(function (PulseLayout) {\n PulseLayout[\"Default\"] = \"default\";\n PulseLayout[\"Card\"] = \"card\";\n PulseLayout[\"Ban\"] = \"ban\";\n})(PulseLayout = exports.PulseLayout || (exports.PulseLayout = {}));\n/**\n * Be careful when adding new event types. Extensions and embedding follow two different patterns on how events are named.\n * Events should be all lower case and without hyphens or underscores.\n */\n/**\n * Represents the type of tableau embedding event that can be listened for.\n */\nvar TableauEventType;\n(function (TableauEventType) {\n /**\n * Raised when a custom view has finished loading. This event is raised after the callback function for {@link FirstInteractive} (if any) has been called.\n *\n * @category Viewing\n */\n TableauEventType[\"CustomViewLoaded\"] = \"customviewloaded\";\n /**\n * Raised when a custom view has been removed.\n *\n * @category Viewing\n */\n TableauEventType[\"CustomViewRemoved\"] = \"customviewremoved\";\n /**\n * Raised when a custom view has been saved (newly created or updated).\n *\n * @category Viewing\n */\n TableauEventType[\"CustomViewSaved\"] = \"customviewsaved\";\n /**\n * Raised when a custom view has been set as the default view for a workbook.\n *\n * @category Viewing\n */\n TableauEventType[\"CustomViewSetDefault\"] = \"customviewsetdefault\";\n /** Raised when the user clicks on the Edit Button.\n *\n * @category Viewing\n */\n TableauEventType[\"EditButtonClicked\"] = \"editbuttonclicked\";\n /** Raised when the user clicks on the Edit In Desktop Button.\n *\n * @category Authoring, Viewing\n */\n TableauEventType[\"EditInDesktopButtonClicked\"] = \"editindesktopbuttonclicked\";\n /** Raised when any filter has changed state. You can use this event type with TableauViz objects.\n *\n * @category Viewing\n */\n TableauEventType[\"FilterChanged\"] = \"filterchanged\";\n /** Fired when viz size is known\n *\n * @category Authoring, Viewing\n */\n TableauEventType[\"FirstVizSizeKnown\"] = \"firstvizsizeknown\";\n /** Fired when a viz first becomes interactive\n *\n * @category Authoring, Viewing\n */\n TableauEventType[\"FirstInteractive\"] = \"firstinteractive\";\n /** Raised when a custom mark context menu is clicked.\n *\n * @category Viewing\n */\n TableauEventType[\"CustomMarkContextMenuEvent\"] = \"custommarkcontextmenu\";\n /** The selected marks on a visualization have changed. You can use this event type with TableauViz objects.\n *\n * @category Viewing\n */\n TableauEventType[\"MarkSelectionChanged\"] = \"markselectionchanged\";\n /** A parameter has had its value modified. You can use this event type with [[Parameter]] objects.\n *\n * @category Viewing\n */\n TableauEventType[\"ParameterChanged\"] = \"parameterchanged\";\n /** Raised when a toolbar button or control becomes available or becomes unavailable.\n *\n * @category Viewing\n */\n TableauEventType[\"ToolbarStateChanged\"] = \"toolbarstatechanged\";\n /** Raised when the workbook is ready to close. This notification is sent when using embedded web authoring functionality.\n *\n * @category Authoring\n */\n TableauEventType[\"WorkbookReadyToClose\"] = \"workbookreadytoclose\";\n /** Raised when the workbook has been published. This notification is sent when using embedded web authoring functionality.\n *\n * @category Authoring\n */\n TableauEventType[\"WorkbookPublished\"] = \"workbookpublished\";\n /** Raised when \"publish as\" is successful. This notification is sent when using embedded web authoring functionality.\n *\n * @category Authoring\n */\n TableauEventType[\"WorkbookPublishedAs\"] = \"workbookpublishedas\";\n /**\n * Raised when a URL action occurs. See the {@link UrlActionEvent} class.\n *\n * @category Viewing\n */\n TableauEventType[\"UrlAction\"] = \"urlaction\";\n /**\n * Raised after a tab switch occurs (the active sheet has changed). Guarantees the viz object will be interactive after this.\n *\n * @category Viewing\n */\n TableauEventType[\"TabSwitched\"] = \"tabswitched\";\n /**\n *\n * Raised after a new story point becomes active.\n *\n * @category Viewing\n */\n TableauEventType[\"StoryPointSwitched\"] = \"storypointswitched\";\n /**\n *\n * Raised when an error occurs while loading the contents of the webcomponent.\n *\n * @category Authoring, Viewing, AskData\n */\n TableauEventType[\"VizLoadError\"] = \"vizloaderror\";\n /**\n * Raised after the iframe src attribute has been updated\n *\n * @category Authoring, Viewing, AskData\n */\n TableauEventType[\"IframeSrcUpdated\"] = \"iframesrcupdated\";\n /**\n * Raised when changes are made to summary data.\n *\n * @category Viewing\n */\n TableauEventType[\"SummaryDataChanged\"] = \"summarydatachanged\";\n /**\n * Raised when tableau (viz-client) is ready to receive an auth token.\n * Used for authentication in salesforce native mode.\n *\n * @hidden\n * @category Authoring, Viewing,\n */\n TableauEventType[\"ReadyToReceiveAuthToken\"] = \"readytoreceiveauthtoken\";\n})(TableauEventType = exports.TableauEventType || (exports.TableauEventType = {}));\n/**\n * Represents the location of a context menu where users can add external menu items.\n */\nvar ApiMenuType;\n(function (ApiMenuType) {\n /** External menu item will be injected in ubertip dialog */\n ApiMenuType[\"Ubertip\"] = \"ubertip\";\n})(ApiMenuType = exports.ApiMenuType || (exports.ApiMenuType = {}));\n/** You can use this type with a {@link Viz} object. */\nvar TableauDialogType;\n(function (TableauDialogType) {\n /**\n * Used to display the download PDF dialog.\n */\n TableauDialogType[\"ExportPDF\"] = \"export-pdf\";\n /**\n * Used to display the download PowerPoint dialog.\n */\n TableauDialogType[\"ExportPowerPoint\"] = \"export-powerpoint\";\n /**\n * Used to display the download Data dialog.\n */\n TableauDialogType[\"ExportData\"] = \"export-data\";\n /**\n * Used to display the download CrossTab dialog.\n */\n TableauDialogType[\"ExportCrossTab\"] = \"export-cross-tab\";\n /**\n * Used to display the download Workbook dialog.\n */\n TableauDialogType[\"ExportWorkbook\"] = \"export-workbook\";\n /**\n * Used to display the Share dialog.\n */\n TableauDialogType[\"Share\"] = \"share\";\n})(TableauDialogType = exports.TableauDialogType || (exports.TableauDialogType = {}));\n//# sourceMappingURL=Enums.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * The names of the string constants you can use as HTML attributes for the web component.\n * @ignore\n */\nvar PulseAttributes;\n(function (PulseAttributes) {\n PulseAttributes[\"DisableExploreFilter\"] = \"disable-explore-filter\";\n PulseAttributes[\"Layout\"] = \"layout\";\n})(PulseAttributes = exports.PulseAttributes || (exports.PulseAttributes = {}));\n//# sourceMappingURL=PulseInterfaces.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * The shared string constants you can use as HTML attributes for the and web component.\n * @ignore\n */\nvar VizSharedAttributes;\n(function (VizSharedAttributes) {\n VizSharedAttributes[\"TouchOptimize\"] = \"touch-optimize\";\n VizSharedAttributes[\"HideEditInDesktopButton\"] = \"hide-edit-in-desktop-button\";\n VizSharedAttributes[\"SuppressDefaultEditBehavior\"] = \"suppress-default-edit-behavior\";\n VizSharedAttributes[\"DisableVersionCheck\"] = \"disable-version-check\";\n VizSharedAttributes[\"OnEditInDesktopButtonClicked\"] = \"onEditInDesktopButtonClicked\";\n VizSharedAttributes[\"OnFirstVizSizeKnown\"] = \"onFirstVizSizeKnown\";\n VizSharedAttributes[\"OnFirstInteractive\"] = \"onFirstInteractive\";\n})(VizSharedAttributes = exports.VizSharedAttributes || (exports.VizSharedAttributes = {}));\n/**\n * The names of the string constants you can use as HTML attributes for the web component.\n * @ignore\n */\nvar VizAttributes;\n(function (VizAttributes) {\n VizAttributes[\"DisableUrlActionsPopups\"] = \"disable-url-actions\";\n VizAttributes[\"HideTabs\"] = \"hide-tabs\";\n VizAttributes[\"Toolbar\"] = \"toolbar\";\n VizAttributes[\"InstanceIdToClone\"] = \"instance-id-to-clone\";\n VizAttributes[\"Device\"] = \"device\";\n VizAttributes[\"HideEditButton\"] = \"hide-edit-button\";\n VizAttributes[\"OnEditButtonClicked\"] = \"onEditButtonClicked\";\n VizAttributes[\"OnFilterChanged\"] = \"onFilterChanged\";\n VizAttributes[\"OnCustomMarkContextMenuEvent\"] = \"onCustomMarkContextMenuEvent\";\n VizAttributes[\"OnMarkSelectionChanged\"] = \"onMarkSelectionChanged\";\n VizAttributes[\"OnParameterChanged\"] = \"onParameterChanged\";\n VizAttributes[\"OnToolbarStateChanged\"] = \"onToolbarStateChanged\";\n VizAttributes[\"OnUrlAction\"] = \"onUrlAction\";\n VizAttributes[\"OnTabSwitched\"] = \"onTabSwitched\";\n VizAttributes[\"OnCustomViewLoaded\"] = \"onCustomViewLoaded\";\n VizAttributes[\"OnCustomViewRemoved\"] = \"onCustomViewRemoved\";\n VizAttributes[\"OnCustomViewSaved\"] = \"onCustomViewSaved\";\n VizAttributes[\"OnCustomViewSetDefault\"] = \"onCustomViewSetDefault\";\n VizAttributes[\"OnStoryPointSwitched\"] = \"onStoryPointSwitched\";\n VizAttributes[\"OnSummaryDataChanged\"] = \"onSummaryDataChanged\";\n VizAttributes[\"OnReadyToReceiveAuthToken\"] = \"onReadyToReceiveAuthToken\";\n})(VizAttributes = exports.VizAttributes || (exports.VizAttributes = {}));\n/**\n * The names of the string constants you can use as HTML attributes for the web component.\n * @ignore\n */\nvar VizAuthoringAttributes;\n(function (VizAuthoringAttributes) {\n VizAuthoringAttributes[\"OnWorkbookPublished\"] = \"onWorkbookPublished\";\n VizAuthoringAttributes[\"OnWorkbookPublishedAs\"] = \"onWorkbookPublishedAs\";\n VizAuthoringAttributes[\"OnWorkbookReadyToClose\"] = \"onWorkbookReadyToClose\";\n VizAuthoringAttributes[\"HideCloseButton\"] = \"hide-close-button\";\n})(VizAuthoringAttributes = exports.VizAuthoringAttributes || (exports.VizAuthoringAttributes = {}));\n/**\n * The names of the string constants you can use as child tags for TableauViz and TableauAuthoringViz custom elements.\n */\nvar VizChildElements;\n(function (VizChildElements) {\n /**\n * Contains a list of filter parameters. Available only in viewing mode.\n */\n VizChildElements[\"VizFilter\"] = \"viz-filter\";\n /**\n * Contains a name and value for a parameter. Available only in viewing mode.\n */\n VizChildElements[\"VizParameter\"] = \"viz-parameter\";\n /**\n * Contains a list of custom parameters. Available in both viewing and authoring modes.\n */\n VizChildElements[\"CustomParameter\"] = \"custom-parameter\";\n})(VizChildElements = exports.VizChildElements || (exports.VizChildElements = {}));\nvar VizChildElementAttributes;\n(function (VizChildElementAttributes) {\n VizChildElementAttributes[\"Field\"] = \"field\";\n VizChildElementAttributes[\"Value\"] = \"value\";\n VizChildElementAttributes[\"Name\"] = \"name\";\n})(VizChildElementAttributes = exports.VizChildElementAttributes || (exports.VizChildElementAttributes = {}));\n//# sourceMappingURL=VizInterfaces.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * The names of the common string constants you can use as HTML attributes for the tableau web component.\n * @ignore\n */\nvar WebComponentAttributes;\n(function (WebComponentAttributes) {\n WebComponentAttributes[\"Src\"] = \"src\";\n WebComponentAttributes[\"Width\"] = \"width\";\n WebComponentAttributes[\"Height\"] = \"height\";\n WebComponentAttributes[\"Token\"] = \"token\";\n WebComponentAttributes[\"Debug\"] = \"debug\";\n WebComponentAttributes[\"IframeAuth\"] = \"iframe-auth\";\n WebComponentAttributes[\"OnVizLoadError\"] = \"onvizloaderror\";\n WebComponentAttributes[\"ForceTokenSync\"] = \"force-token-sync\";\n})(WebComponentAttributes = exports.WebComponentAttributes || (exports.WebComponentAttributes = {}));\n/**\n * The names of the string constants you can use as child tags for TableauViz, TableauAuthoringViz and TableauAskData custom elements.\n * @ignore\n */\nvar WebComponentChildElements;\n(function (WebComponentChildElements) {\n /**\n * Contains a list of custom parameters. Available in viz viewing, viz authoring and askdata.\n */\n WebComponentChildElements[\"CustomParameter\"] = \"custom-parameter\";\n})(WebComponentChildElements = exports.WebComponentChildElements || (exports.WebComponentChildElements = {}));\nvar WebComponentChildElementAttributes;\n(function (WebComponentChildElementAttributes) {\n WebComponentChildElementAttributes[\"Field\"] = \"field\";\n WebComponentChildElementAttributes[\"Value\"] = \"value\";\n WebComponentChildElementAttributes[\"Name\"] = \"name\";\n})(WebComponentChildElementAttributes = exports.WebComponentChildElementAttributes || (exports.WebComponentChildElementAttributes = {}));\n//# sourceMappingURL=WebComponentInterfaces.js.map","\"use strict\";\n// All enum values made available to Extensions developers.\n// Enums should be kept in alphabetical order.\nvar Tableau;\n(function (Tableau) {\n /**\n * All error codes used by the Extensions API.\n */\n var ErrorCodes;\n (function (ErrorCodes) {\n /**\n * Thrown when caller attempts to execute command before initialization has completed.\n */\n ErrorCodes[\"APINotInitialized\"] = \"api-not-initialized\";\n /**\n * Thrown when caller attempts to execute command while extension is not visible.\n */\n ErrorCodes[\"VisibilityError\"] = \"visibility-error\";\n /**\n * Only one dialog can be opened at time with the UI namespace functionality.\n */\n ErrorCodes[\"DialogAlreadyOpen\"] = \"dialog-already-open\";\n /**\n * The open dialog was closed by the user.\n */\n ErrorCodes[\"DialogClosedByUser\"] = \"dialog-closed-by-user\";\n /**\n * An error occurred within the Tableau Extensions API. Contact Tableau Support.\n */\n ErrorCodes[\"InternalError\"] = \"internal-error\";\n /**\n * A dialog must start on the same domain as the parent extenion.\n */\n ErrorCodes[\"InvalidDomainDialog\"] = \"invalid-dialog-domain\";\n /**\n * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.\n */\n ErrorCodes[\"InvalidParameter\"] = \"invalid-parameter\";\n /**\n * Can occur if the extension interacts with a filter that has been removed from the worksheet.\n */\n ErrorCodes[\"MissingFilter\"] = \"missing-filter\";\n /**\n * Can occur if the extension interacts with a parameter that has been removed from the worksheet.\n */\n ErrorCodes[\"MissingParameter\"] = \"missing-parameter\";\n /**\n * Internal Server Error\n */\n ErrorCodes[\"ServerError\"] = \"server-error\";\n /**\n * Developer cannot save settings while another save is still in progress.\n */\n ErrorCodes[\"SettingSaveInProgress\"] = \"setting-save-in-progress\";\n /**\n * An unknown event name was specified in the call to `addEventListener` or `removeEventListener`.\n */\n ErrorCodes[\"UnsupportedEventName\"] = \"unsupported-event-name\";\n /**\n * A method was used for a type of data source that doesn't support that method (see getActiveTablesAsync for an example)\n */\n ErrorCodes[\"UnsupportedMethodForDataSourceType\"] = \"unsupported-method-for-data-source-type\";\n })(ErrorCodes = Tableau.ErrorCodes || (Tableau.ErrorCodes = {}));\n /**\n * The context in which the Extensions is currently running.\n */\n var ExtensionContext;\n (function (ExtensionContext) {\n ExtensionContext[\"Desktop\"] = \"desktop\";\n ExtensionContext[\"Server\"] = \"server\";\n })(ExtensionContext = Tableau.ExtensionContext || (Tableau.ExtensionContext = {}));\n /**\n * The mode in which the Extensions is currently running.\n */\n var ExtensionMode;\n (function (ExtensionMode) {\n ExtensionMode[\"Authoring\"] = \"authoring\";\n ExtensionMode[\"Viewing\"] = \"viewing\";\n })(ExtensionMode = Tableau.ExtensionMode || (Tableau.ExtensionMode = {}));\n /**\n * Represents the type of event that can be listened for.\n */\n var TableauEventType;\n (function (TableauEventType) {\n /** Raised when any filter has changed state. You can use this event type with [Worksheet](../interfaces/worksheet.html) objects.*/\n TableauEventType[\"FilterChanged\"] = \"filter-changed\";\n /** The selected marks on a visualization has changed.\n * You can use this event type with [Worksheet](../interfaces/worksheet.html) objects. */\n TableauEventType[\"MarkSelectionChanged\"] = \"mark-selection-changed\";\n /** The summary data backing a worksheet has changed\n * You can use this event type with [Worksheet](../interfaces/worksheet.html) objects.*/\n TableauEventType[\"SummaryDataChanged\"] = \"summary-data-changed\";\n /** A parameter has had its value modified. You can use this event type with [[Parameter]] objects. */\n TableauEventType[\"ParameterChanged\"] = \"parameter-changed\";\n /** Settings have been changed for this extension. You can use this event type with [[Settings]] objects. */\n TableauEventType[\"SettingsChanged\"] = \"settings-changed\";\n /** The dashboard layout has changed\n * @category Dashboard Extensions\n */\n TableauEventType[\"DashboardLayoutChanged\"] = \"dashboard-layout-changed\";\n /** The workbook formatting has changed\n * @category Dashboard Extensions\n */\n TableauEventType[\"WorkbookFormattingChanged\"] = \"workbook-formatting-changed\";\n })(TableauEventType = Tableau.TableauEventType || (Tableau.TableauEventType = {}));\n /**\n * Enum that represents the data type of encodings for createVizImageAsync.\n * @since 1.6.0\n */\n var VizImageEncodingType;\n (function (VizImageEncodingType) {\n VizImageEncodingType[\"Discrete\"] = \"discrete\";\n VizImageEncodingType[\"Continuous\"] = \"continuous\";\n })(VizImageEncodingType = Tableau.VizImageEncodingType || (Tableau.VizImageEncodingType = {}));\n /**\n * Enum that represents the sort direction for createVizImageAsync.\n * @since 1.8.0 and Tableau 2021.4\n */\n var VizImageSortDirectionType;\n (function (VizImageSortDirectionType) {\n VizImageSortDirectionType[\"Ascending\"] = \"ascending\";\n VizImageSortDirectionType[\"Descending\"] = \"descending\";\n })(VizImageSortDirectionType = Tableau.VizImageSortDirectionType || (Tableau.VizImageSortDirectionType = {}));\n /**\n * Enum that represents the palette type for createVizImageAsync.\n * @since 1.8.0 and Tableau 2021.4\n */\n var VizImagePaletteType;\n (function (VizImagePaletteType) {\n VizImagePaletteType[\"CustomDiverging\"] = \"custom-diverging\";\n VizImagePaletteType[\"CustomSequential\"] = \"custom-sequential\";\n })(VizImagePaletteType = Tableau.VizImagePaletteType || (Tableau.VizImagePaletteType = {}));\n /**\n * Enum that represents the Size Setting type for createVizImageAsync.\n * @since 1.8.0 and Tableau 2021.4\n */\n var VizImageSizeSettingType;\n (function (VizImageSizeSettingType) {\n VizImageSizeSettingType[\"Fixed\"] = \"fixed\";\n VizImageSizeSettingType[\"Manual\"] = \"manual\";\n })(VizImageSizeSettingType = Tableau.VizImageSizeSettingType || (Tableau.VizImageSizeSettingType = {}));\n /**\n * Enum that represents the Size Setting alignment type for createVizImageAsync.\n * @since 1.8.0 and Tableau 2021.4\n */\n var VizImageSizeSettingAlignmentType;\n (function (VizImageSizeSettingAlignmentType) {\n VizImageSizeSettingAlignmentType[\"Right\"] = \"right\";\n VizImageSizeSettingAlignmentType[\"Left\"] = \"left\";\n VizImageSizeSettingAlignmentType[\"Center\"] = \"center\";\n })(VizImageSizeSettingAlignmentType = Tableau.VizImageSizeSettingAlignmentType || (Tableau.VizImageSizeSettingAlignmentType = {}));\n})(Tableau || (Tableau = {}));\nmodule.exports = Tableau;\n//# sourceMappingURL=Tableau.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar SharedErrorCodes;\n(function (SharedErrorCodes) {\n /**\n * A CSV or Excel file failed to be created in Viz.exportCrosstabAsync().\n */\n SharedErrorCodes[\"CrosstabCreationError\"] = \"crosstab-creation-error\";\n /**\n * A CSV file failed to be created in Viz.exportDataAsync().\n */\n SharedErrorCodes[\"DataCreationError\"] = \"data-creation-error\";\n /**\n * An invalid aggregation was specified for the filter, such as setting a range filter to \"SUM(Sales)\" instead of\n * \"Sales\".\n */\n SharedErrorCodes[\"InvalidAggregationFieldName\"] = \"invalid-aggregation-field-name\";\n /**\n * A filter operation was attempted on a field that does not exist in the data source.\n */\n SharedErrorCodes[\"InvalidFilterFieldName\"] = \"invalid-filter-name\";\n /**\n * A filter operation was attempted using a value that is the wrong data type or format.\n */\n SharedErrorCodes[\"InvalidFilterFieldValue\"] = \"invalid-filter-fieldValue\";\n /**\n * An invalid date value was specified in a Sheet.selectMarksAsync() call for a date field.\n */\n SharedErrorCodes[\"InvalidSelectionDate\"] = \"invalid-selection-date\";\n /**\n * A field was specified in a Sheet.selectMarksAsync() call that does not exist in the data source.\n */\n SharedErrorCodes[\"InvalidSelectionFieldName\"] = \"invalid-selection-fieldName\";\n /**\n * An invalid value was specified in a Sheet.selectMarksAsync() call.\n */\n SharedErrorCodes[\"InvalidSelectionValue\"] = \"invalid-selection-value\";\n /**\n * A parameter did not include a valid sheet selection for exporting.\n */\n SharedErrorCodes[\"InvalidSelectionSheet\"] = \"invalid-selection-sheet\";\n /**\n * An error occurred within the Tableau API. Contact Tableau Support.\n */\n SharedErrorCodes[\"InternalError\"] = \"internal-error\";\n /**\n * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.\n */\n SharedErrorCodes[\"InvalidParameter\"] = \"invalid-parameter\";\n /**\n * A PDF file failed to be created in Viz.exportPDFAsync().\n */\n SharedErrorCodes[\"PDFCreationError\"] = \"pdf-creation-error\";\n /**\n * A PowerPoint file failed to be created in Viz.exportPowerPointAsync().\n */\n SharedErrorCodes[\"PowerPointCreationError\"] = \"powerpoint-creation-error\";\n /**\n * An operation was attempted on a sheet that is not active or embedded within the active dashboard.\n */\n SharedErrorCodes[\"NotActiveSheet\"] = \"not-active-sheet\";\n /**\n * Property or Function is not supported within the Tableau API.\n */\n SharedErrorCodes[\"ImplementationError\"] = \"wrong-implementation\";\n /**\n * Can occur when two incompatible calls are triggered together.\n */\n SharedErrorCodes[\"ApiExecutionError\"] = \"api-execution-error\";\n /**\n * A general-purpose server error occurred. Details are contained in the Error object.\n */\n SharedErrorCodes[\"ServerError\"] = \"server-error\";\n /**\n * Can occur when an api call times out.\n */\n SharedErrorCodes[\"Timeout\"] = \"timeout\";\n})(SharedErrorCodes = exports.SharedErrorCodes || (exports.SharedErrorCodes = {}));\n//# sourceMappingURL=Enums.js.map","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n __assign = Object.assign || function(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n t[p] = s[p];\n }\n return t;\n };\n return __assign.apply(this, arguments);\n};\n/**\n * The tableau namespace exists for organization and to avoid polluting\n * the global namespace. It contains no constructs other than sub-namespaces and the Tableau enumerations.\n */\nvar Tableau;\n(function (Tableau) {\n var AnalyticsObjectType;\n (function (AnalyticsObjectType) {\n AnalyticsObjectType[\"Cluster\"] = \"cluster\";\n AnalyticsObjectType[\"Forecast\"] = \"forecast\";\n AnalyticsObjectType[\"TrendLine\"] = \"trend-line\";\n })(AnalyticsObjectType = Tableau.AnalyticsObjectType || (Tableau.AnalyticsObjectType = {}));\n var AnnotationType;\n (function (AnnotationType) {\n AnnotationType[\"Mark\"] = \"mark\";\n AnnotationType[\"Point\"] = \"point\";\n AnnotationType[\"Area\"] = \"area\";\n })(AnnotationType = Tableau.AnnotationType || (Tableau.AnnotationType = {}));\n var ColumnType;\n (function (ColumnType) {\n ColumnType[\"Discrete\"] = \"discrete\";\n ColumnType[\"Continuous\"] = \"continuous\";\n ColumnType[\"Unknown\"] = \"unknown\";\n })(ColumnType = Tableau.ColumnType || (Tableau.ColumnType = {}));\n var ClassNameKey;\n (function (ClassNameKey) {\n ClassNameKey[\"WorksheetTitle\"] = \"tableau-worksheet-title\";\n ClassNameKey[\"Worksheet\"] = \"tableau-worksheet\";\n ClassNameKey[\"Tooltip\"] = \"tableau-tooltip\";\n ClassNameKey[\"StoryTitle\"] = \"tableau-story-title\";\n ClassNameKey[\"DashboardTitle\"] = \"tableau-dashboard-title\";\n })(ClassNameKey = Tableau.ClassNameKey || (Tableau.ClassNameKey = {}));\n /**\n * What the object represents in a dashboard.\n */\n var DashboardObjectType;\n (function (DashboardObjectType) {\n DashboardObjectType[\"Blank\"] = \"blank\";\n DashboardObjectType[\"Worksheet\"] = \"worksheet\";\n DashboardObjectType[\"QuickFilter\"] = \"quick-filter\";\n DashboardObjectType[\"ParameterControl\"] = \"parameter-control\";\n DashboardObjectType[\"PageFilter\"] = \"page-filter\";\n DashboardObjectType[\"Legend\"] = \"legend\";\n DashboardObjectType[\"Title\"] = \"title\";\n DashboardObjectType[\"Text\"] = \"text\";\n DashboardObjectType[\"Image\"] = \"image\";\n DashboardObjectType[\"WebPage\"] = \"web-page\";\n DashboardObjectType[\"Extension\"] = \"extension\";\n })(DashboardObjectType = Tableau.DashboardObjectType || (Tableau.DashboardObjectType = {}));\n /**\n * Enum that represents the visibility state of a dashboard object.\n * @since 1.7.0\n */\n var DashboardObjectVisibilityType;\n (function (DashboardObjectVisibilityType) {\n /** Used for turning on the visibility of a dashboard object.*/\n DashboardObjectVisibilityType[\"Show\"] = \"show\";\n /** Used for turning off the visibility of a dashboard object.*/\n DashboardObjectVisibilityType[\"Hide\"] = \"hide\";\n })(DashboardObjectVisibilityType = Tableau.DashboardObjectVisibilityType || (Tableau.DashboardObjectVisibilityType = {}));\n /**\n * The different types of data a value can have\n */\n var DataType;\n (function (DataType) {\n DataType[\"String\"] = \"string\";\n DataType[\"Int\"] = \"int\";\n DataType[\"Float\"] = \"float\";\n DataType[\"Bool\"] = \"bool\";\n DataType[\"Date\"] = \"date\";\n DataType[\"DateTime\"] = \"date-time\";\n DataType[\"Spatial\"] = \"spatial\";\n DataType[\"Unknown\"] = \"unknown\";\n })(DataType = Tableau.DataType || (Tableau.DataType = {}));\n /**\n * Enum that represents the changes that occur to a dashboard object.\n */\n var DashboardLayoutChange;\n (function (DashboardLayoutChange) {\n /** A dashboard object was added */\n DashboardLayoutChange[\"Added\"] = \"added\";\n /** A dashboard object was removed */\n DashboardLayoutChange[\"Removed\"] = \"removed\";\n /** A dashboard object's floating state changed */\n DashboardLayoutChange[\"IsFloatingChanged\"] = \"is-floating-changed\";\n /** A dashboard object's visibility changed */\n DashboardLayoutChange[\"IsVisibleChanged\"] = \"is-visible-changed\";\n /** A dashboard object's position changed */\n DashboardLayoutChange[\"PositionChanged\"] = \"position-changed\";\n /** A dashboard object's size changed */\n DashboardLayoutChange[\"SizeChanged\"] = \"size-changed\";\n /** A dashboard object was renamed */\n DashboardLayoutChange[\"NameChanged\"] = \"name-changed\";\n /** A dashboard object is selected */\n DashboardLayoutChange[\"Selected\"] = \"selected\";\n /** A dashboard object is deselected */\n DashboardLayoutChange[\"Deselected\"] = \"deselected\";\n /** Navigate to another dashboard */\n DashboardLayoutChange[\"DashboardChanged\"] = \"dashboard-changed\";\n })(DashboardLayoutChange = Tableau.DashboardLayoutChange || (Tableau.DashboardLayoutChange = {}));\n /**\n * Valid date ranges for a relative date filter.\n */\n var DateRangeType;\n (function (DateRangeType) {\n DateRangeType[\"Last\"] = \"last\";\n DateRangeType[\"LastN\"] = \"last-n\";\n DateRangeType[\"Next\"] = \"next\";\n DateRangeType[\"NextN\"] = \"next-n\";\n DateRangeType[\"Current\"] = \"current\";\n DateRangeType[\"ToDate\"] = \"to-date\";\n })(DateRangeType = Tableau.DateRangeType || (Tableau.DateRangeType = {}));\n /**\n * Enum that represents the types of dialog popup styles.\n */\n var DialogStyle;\n (function (DialogStyle) {\n DialogStyle[\"Window\"] = \"window\";\n DialogStyle[\"Modal\"] = \"modal\";\n DialogStyle[\"Modeless\"] = \"modeless\";\n })(DialogStyle = Tableau.DialogStyle || (Tableau.DialogStyle = {}));\n var EncodingType;\n (function (EncodingType) {\n EncodingType[\"Column\"] = \"column\";\n EncodingType[\"Row\"] = \"row\";\n EncodingType[\"Page\"] = \"page\";\n EncodingType[\"Filter\"] = \"filter\";\n EncodingType[\"MarksType\"] = \"marks-type\";\n EncodingType[\"MeasureValues\"] = \"measure-values\";\n EncodingType[\"Color\"] = \"color\";\n EncodingType[\"Size\"] = \"size\";\n EncodingType[\"Label\"] = \"label\";\n EncodingType[\"Detail\"] = \"detail\";\n EncodingType[\"Tooltip\"] = \"tooltip\";\n EncodingType[\"Shape\"] = \"shape\";\n EncodingType[\"Path\"] = \"path\";\n EncodingType[\"Angle\"] = \"angle\";\n EncodingType[\"Geometry\"] = \"geometry\";\n EncodingType[\"Custom\"] = \"custom\";\n })(EncodingType = Tableau.EncodingType || (Tableau.EncodingType = {}));\n /**\n * Type of aggregation on a field.\n */\n var FieldAggregationType;\n (function (FieldAggregationType) {\n FieldAggregationType[\"Sum\"] = \"sum\";\n FieldAggregationType[\"Avg\"] = \"avg\";\n FieldAggregationType[\"Min\"] = \"min\";\n FieldAggregationType[\"Max\"] = \"max\";\n FieldAggregationType[\"Stdev\"] = \"stdev\";\n FieldAggregationType[\"Stdevp\"] = \"stdevp\";\n FieldAggregationType[\"Var\"] = \"var\";\n FieldAggregationType[\"Varp\"] = \"varp\";\n FieldAggregationType[\"Collect\"] = \"collect\";\n FieldAggregationType[\"Count\"] = \"count\";\n FieldAggregationType[\"Countd\"] = \"countd\";\n FieldAggregationType[\"Median\"] = \"median\";\n FieldAggregationType[\"Attr\"] = \"attr\";\n FieldAggregationType[\"None\"] = \"none\";\n FieldAggregationType[\"Year\"] = \"year\";\n FieldAggregationType[\"Qtr\"] = \"qtr\";\n FieldAggregationType[\"Month\"] = \"month\";\n FieldAggregationType[\"Day\"] = \"day\";\n FieldAggregationType[\"Hour\"] = \"hour\";\n FieldAggregationType[\"Minute\"] = \"minute\";\n FieldAggregationType[\"Second\"] = \"second\";\n FieldAggregationType[\"Week\"] = \"week\";\n FieldAggregationType[\"Weekday\"] = \"weekday\";\n FieldAggregationType[\"MonthYear\"] = \"month-year\";\n FieldAggregationType[\"Mdy\"] = \"mdy\";\n FieldAggregationType[\"End\"] = \"end\";\n FieldAggregationType[\"TruncYear\"] = \"trunc-year\";\n FieldAggregationType[\"TruncQtr\"] = \"trunc-qtr\";\n FieldAggregationType[\"TruncMonth\"] = \"trunc-month\";\n FieldAggregationType[\"TruncWeek\"] = \"trunc-week\";\n FieldAggregationType[\"TruncDay\"] = \"trunc-day\";\n FieldAggregationType[\"TruncHour\"] = \"trunc-hour\";\n FieldAggregationType[\"TruncMinute\"] = \"trunc-minute\";\n FieldAggregationType[\"TruncSecond\"] = \"trunc-second\";\n FieldAggregationType[\"Quart1\"] = \"quart1\";\n FieldAggregationType[\"Quart3\"] = \"quart3\";\n FieldAggregationType[\"Skewness\"] = \"skewness\";\n FieldAggregationType[\"Kurtosis\"] = \"kurtosis\";\n FieldAggregationType[\"InOut\"] = \"in-out\";\n FieldAggregationType[\"User\"] = \"user\";\n })(FieldAggregationType = Tableau.FieldAggregationType || (Tableau.FieldAggregationType = {}));\n /**\n * Role of a field.\n */\n var FieldRoleType;\n (function (FieldRoleType) {\n FieldRoleType[\"Dimension\"] = \"dimension\";\n FieldRoleType[\"Measure\"] = \"measure\";\n FieldRoleType[\"Unknown\"] = \"unknown\";\n })(FieldRoleType = Tableau.FieldRoleType || (Tableau.FieldRoleType = {}));\n /**\n * An enumeration of the valid types of filters that can be applied.\n */\n var FilterType;\n (function (FilterType) {\n FilterType[\"Categorical\"] = \"categorical\";\n FilterType[\"Range\"] = \"range\";\n FilterType[\"Hierarchical\"] = \"hierarchical\";\n FilterType[\"RelativeDate\"] = \"relative-date\";\n })(FilterType = Tableau.FilterType || (Tableau.FilterType = {}));\n /**\n * The different update types for applying filter\n */\n var FilterUpdateType;\n (function (FilterUpdateType) {\n FilterUpdateType[\"Add\"] = \"add\";\n FilterUpdateType[\"All\"] = \"all\";\n FilterUpdateType[\"Replace\"] = \"replace\";\n FilterUpdateType[\"Remove\"] = \"remove\";\n })(FilterUpdateType = Tableau.FilterUpdateType || (Tableau.FilterUpdateType = {}));\n /**\n * The domain type for a filter\n */\n var FilterDomainType;\n (function (FilterDomainType) {\n /**\n * The domain values that are relevant to the specified filter\n * i.e. the domain is restricted by a previous filter\n */\n FilterDomainType[\"Relevant\"] = \"relevant\";\n /**\n * list of all possible domain values from database\n */\n FilterDomainType[\"Database\"] = \"database\";\n })(FilterDomainType = Tableau.FilterDomainType || (Tableau.FilterDomainType = {}));\n /**\n * The option for specifying which values to include for filtering\n * Indicates what to do with null values for a given filter or mark selection call.\n */\n var FilterNullOption;\n (function (FilterNullOption) {\n FilterNullOption[\"NullValues\"] = \"null-values\";\n FilterNullOption[\"NonNullValues\"] = \"non-null-values\";\n FilterNullOption[\"AllValues\"] = \"all-values\";\n })(FilterNullOption = Tableau.FilterNullOption || (Tableau.FilterNullOption = {}));\n /**\n * Enum that serves as a filter on the DataValues returned from `getSummaryDataReaderAsync`,\n * `getUnderlyingTableDataReaderAsync` and `getLogicalTableDataReaderAsync`.\n * This is an optimization of returned data values only. Tableau versions prior to 2021.2\n * will pass the data across and populate the DataValue properties.\n * Please note that all properties not requested will be `undefined` in the DataValue results.\n * @since 1.5.0\n */\n var IncludeDataValuesOption;\n (function (IncludeDataValuesOption) {\n /** DataValues will include all properties.*/\n IncludeDataValuesOption[\"AllValues\"] = \"all-values\";\n /** DataValues will only include value and nativeValue properties.*/\n IncludeDataValuesOption[\"OnlyNativeValues\"] = \"only-native-values\";\n /** DataValues will only include formattedValue properties. */\n IncludeDataValuesOption[\"OnlyFormattedValues\"] = \"only-formatted-values\";\n })(IncludeDataValuesOption = Tableau.IncludeDataValuesOption || (Tableau.IncludeDataValuesOption = {}));\n /**\n * Type of mark for a given marks card in a viz.\n */\n var MarkType;\n (function (MarkType) {\n MarkType[\"Bar\"] = \"bar\";\n MarkType[\"Line\"] = \"line\";\n MarkType[\"Area\"] = \"area\";\n MarkType[\"Square\"] = \"square\";\n MarkType[\"Circle\"] = \"circle\";\n MarkType[\"Shape\"] = \"shape\";\n MarkType[\"Text\"] = \"text\";\n MarkType[\"Map\"] = \"map\";\n MarkType[\"Pie\"] = \"pie\";\n MarkType[\"GanttBar\"] = \"gantt-bar\";\n MarkType[\"Polygon\"] = \"polygon\";\n MarkType[\"Heatmap\"] = \"heatmap\";\n MarkType[\"VizExtension\"] = \"viz-extension\";\n })(MarkType = Tableau.MarkType || (Tableau.MarkType = {}));\n /**\n * An enumeration describing the different types of allowable values.\n * This is used for restricting the domain of a parameter\n */\n var ParameterValueType;\n (function (ParameterValueType) {\n ParameterValueType[\"All\"] = \"all\";\n ParameterValueType[\"List\"] = \"list\";\n ParameterValueType[\"Range\"] = \"range\";\n })(ParameterValueType = Tableau.ParameterValueType || (Tableau.ParameterValueType = {}));\n /**\n * Date period used in filters and in parameters.\n */\n var PeriodType;\n (function (PeriodType) {\n PeriodType[\"Years\"] = \"years\";\n PeriodType[\"Quarters\"] = \"quarters\";\n PeriodType[\"Months\"] = \"months\";\n PeriodType[\"Weeks\"] = \"weeks\";\n PeriodType[\"Days\"] = \"days\";\n PeriodType[\"Hours\"] = \"hours\";\n PeriodType[\"Minutes\"] = \"minutes\";\n PeriodType[\"Seconds\"] = \"seconds\";\n })(PeriodType = Tableau.PeriodType || (Tableau.PeriodType = {}));\n var QuickTableCalcType;\n (function (QuickTableCalcType) {\n QuickTableCalcType[\"RunningTotal\"] = \"running-total\";\n QuickTableCalcType[\"Difference\"] = \"difference\";\n QuickTableCalcType[\"PercentDifference\"] = \"percent-difference\";\n QuickTableCalcType[\"PercentOfTotal\"] = \"percent-of-total\";\n QuickTableCalcType[\"Rank\"] = \"rank\";\n QuickTableCalcType[\"Percentile\"] = \"percentile\";\n QuickTableCalcType[\"MovingAverage\"] = \"moving-average\";\n QuickTableCalcType[\"YTDTotal\"] = \"ytd-total\";\n QuickTableCalcType[\"CompoundGrowthRate\"] = \"compound-growth-rate\";\n QuickTableCalcType[\"YearOverYearGrowth\"] = \"year-over-year-growth\";\n QuickTableCalcType[\"YTDGrowth\"] = \"ytd-growth\";\n QuickTableCalcType[\"Undefined\"] = \"undefined\";\n })(QuickTableCalcType = Tableau.QuickTableCalcType || (Tableau.QuickTableCalcType = {}));\n /**\n * Enum for specifying the selection type for select marks api.\n */\n var SelectionUpdateType;\n (function (SelectionUpdateType) {\n SelectionUpdateType[\"Replace\"] = \"select-replace\";\n SelectionUpdateType[\"Add\"] = \"select-add\";\n SelectionUpdateType[\"Remove\"] = \"select-remove\";\n })(SelectionUpdateType = Tableau.SelectionUpdateType || (Tableau.SelectionUpdateType = {}));\n /**\n * Enum for specifying the select option for the `extensions.Worksheet.selectTuplesAsync` method.\n */\n var SelectOptions;\n (function (SelectOptions) {\n /**\n * Clears existing selection before selecting the tuples specified\n */\n SelectOptions[\"Simple\"] = \"select-options-simple\";\n /**\n * Adds specified tuples to the existing selection\n */\n SelectOptions[\"Toggle\"] = \"select-options-toggle\";\n })(SelectOptions = Tableau.SelectOptions || (Tableau.SelectOptions = {}));\n /**\n * The type of sheet a [[Sheet]] object represents\n */\n var SheetType;\n (function (SheetType) {\n SheetType[\"Dashboard\"] = \"dashboard\";\n SheetType[\"Story\"] = \"story\";\n SheetType[\"Worksheet\"] = \"worksheet\";\n })(SheetType = Tableau.SheetType || (Tableau.SheetType = {}));\n var SortDirection;\n (function (SortDirection) {\n SortDirection[\"Increasing\"] = \"increasing\";\n SortDirection[\"Decreasing\"] = \"decreasing\";\n })(SortDirection = Tableau.SortDirection || (Tableau.SortDirection = {}));\n var TrendLineModelType;\n (function (TrendLineModelType) {\n TrendLineModelType[\"Linear\"] = \"linear\";\n TrendLineModelType[\"Logarithmic\"] = \"logarithmic\";\n TrendLineModelType[\"Exponential\"] = \"exponential\";\n TrendLineModelType[\"Polynomial\"] = \"polynomial\";\n })(TrendLineModelType = Tableau.TrendLineModelType || (Tableau.TrendLineModelType = {}));\n /**\n * Enum that represents the replay speed of an animation.\n * @since 1.7.0\n */\n var ReplaySpeedType;\n (function (ReplaySpeedType) {\n /** Used for setting the replay speed of an animation to 0.5x.*/\n ReplaySpeedType[\"Slow\"] = \"slow\";\n /** Used for setting the replay speed of an animation to 1.0x.*/\n ReplaySpeedType[\"Normal\"] = \"normal\";\n /** Used for setting the replay speed of an animation to 2.0x.*/\n ReplaySpeedType[\"Fast\"] = \"fast\";\n })(ReplaySpeedType = Tableau.ReplaySpeedType || (Tableau.ReplaySpeedType = {}));\n /**\n * Enum that represents the selection state of a level in a hierarchical filter\n * @since Extensions 1.10.0\n */\n var HierarchicalLevelSelectionState;\n (function (HierarchicalLevelSelectionState) {\n HierarchicalLevelSelectionState[\"AllSelected\"] = \"all-selected\";\n HierarchicalLevelSelectionState[\"NoneSelected\"] = \"none-selected\";\n HierarchicalLevelSelectionState[\"SomeSelected\"] = \"some-selected\";\n HierarchicalLevelSelectionState[\"UnknownSelected\"] = \"unknown-selected\";\n })(HierarchicalLevelSelectionState = Tableau.HierarchicalLevelSelectionState || (Tableau.HierarchicalLevelSelectionState = {}));\n Tableau.ZoneVisibilityType = __assign({}, DashboardObjectVisibilityType);\n})(Tableau || (Tableau = {}));\nmodule.exports = Tableau;\n//# sourceMappingURL=Tableau.js.map","\"use strict\";\n// This file re-exports everything which is part of the shared api public interface\nfunction __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__export(require(\"./ExternalContract/Shared/Enums\"));\nvar Tableau_1 = require(\"./ExternalContract/Shared/Namespaces/Tableau\");\nexports.AnalyticsObjectType = Tableau_1.AnalyticsObjectType;\nexports.AnnotationType = Tableau_1.AnnotationType;\nexports.ClassNameKey = Tableau_1.ClassNameKey;\nexports.ColumnType = Tableau_1.ColumnType;\nexports.DashboardLayoutChange = Tableau_1.DashboardLayoutChange;\nexports.DashboardObjectType = Tableau_1.DashboardObjectType;\nexports.DashboardObjectVisibilityType = Tableau_1.DashboardObjectVisibilityType;\nexports.DataType = Tableau_1.DataType;\nexports.DateRangeType = Tableau_1.DateRangeType;\nexports.DialogStyle = Tableau_1.DialogStyle;\nexports.EncodingType = Tableau_1.EncodingType;\nexports.FieldAggregationType = Tableau_1.FieldAggregationType;\nexports.FieldRoleType = Tableau_1.FieldRoleType;\nexports.FilterDomainType = Tableau_1.FilterDomainType;\nexports.FilterNullOption = Tableau_1.FilterNullOption;\nexports.FilterType = Tableau_1.FilterType;\nexports.FilterUpdateType = Tableau_1.FilterUpdateType;\nexports.HierarchicalLevelSelectionState = Tableau_1.HierarchicalLevelSelectionState;\nexports.IncludeDataValuesOption = Tableau_1.IncludeDataValuesOption;\nexports.MarkType = Tableau_1.MarkType;\nexports.ParameterValueType = Tableau_1.ParameterValueType;\nexports.PeriodType = Tableau_1.PeriodType;\nexports.QuickTableCalcType = Tableau_1.QuickTableCalcType;\nexports.ReplaySpeedType = Tableau_1.ReplaySpeedType;\nexports.SelectOptions = Tableau_1.SelectOptions;\nexports.SelectionUpdateType = Tableau_1.SelectionUpdateType;\nexports.SheetType = Tableau_1.SheetType;\nexports.SortDirection = Tableau_1.SortDirection;\nexports.TrendLineModelType = Tableau_1.TrendLineModelType;\nexports.ZoneVisibilityType = Tableau_1.ZoneVisibilityType;\n//# sourceMappingURL=SharedApiExternalContract.js.map","\"use strict\";\n/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\nfunction __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// The following polyfills are needed for IE11\nrequire(\"core-js/es/number/is-integer\");\nrequire(\"core-js/es/number/is-nan\");\nrequire(\"core-js/es/object/assign\");\n// Export the version of the internal contract to be available at runtime\n// This file is generated by yarn publish:bump via scripts/publish-check.ts\n// updateInternalContractRuntimeVersion in the monorepo root.\nvar internalContractVersion = require(\"../internal-contract-version.json\");\nexports.INTERNAL_CONTRACT_VERSION = internalContractVersion;\n__export(require(\"./contract/DataTypeConverter\"));\n__export(require(\"./contract/Enums\"));\n__export(require(\"./contract/Notifications\"));\n__export(require(\"./contract/Parameters\"));\n__export(require(\"./contract/Verbs\"));\n__export(require(\"./interface/AskDataInterface\"));\n__export(require(\"./interface/PulseInterface\"));\n__export(require(\"./interface/VqlInterface\"));\n__export(require(\"./messaging/CrossFrameMessenger\"));\n__export(require(\"./messaging/interface/MessageTypes\"));\n__export(require(\"./versioning/VersionConverterFactory\"));\n__export(require(\"./versioning/external/ExternalIdentityVersionConverter\"));\n__export(require(\"./versioning/external/ExternalVersionConverterFactory\"));\n// Export the version number of messaging for consumers to use.\n// Be very careful making any updates to this contract which break version compatibility.\nexports.MESSAGING_VERSION = {\n major: 1,\n minor: 0,\n fix: 0,\n};\n//# sourceMappingURL=JsApiInternalContract.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Enums_1 = require(\"./Enums\");\nvar DataTypeConverter = /** @class */ (function () {\n function DataTypeConverter() {\n }\n DataTypeConverter.isSpecial = function (valueAsString) {\n // Prior to ShowDataTablePresModel, special values come to us as\n // '%null%', '%all%', '%wildcard%', '%missing%'...\n // While this function will never return true for ShowDataTablePresModel conversion,\n // it is as cheap as passing around a version and checking that.\n // (See DataValueFormatter.cpp)\n if (valueAsString.length > 2 && valueAsString[0] === '%' && valueAsString[valueAsString.length - 1] === '%') {\n return true;\n }\n return false;\n };\n // tslint:disable-next-line:no-any\n DataTypeConverter.parseBoolean = function (booleanString) {\n // boolean values come to us as 'true'|'false'\n var normalizedBoolean = booleanString.toLowerCase();\n return normalizedBoolean !== 'true' && normalizedBoolean !== 'false' ? this.specialValueIndicator : normalizedBoolean === 'true';\n };\n // tslint:disable-next-line:no-any\n DataTypeConverter.parseNumber = function (valueAsString) {\n var value = Number(valueAsString);\n return isNaN(value) ? this.specialValueIndicator : value;\n };\n DataTypeConverter.parseDate = function (dateAsString) {\n // Note that without a time, the date is assumed to be UTC\n // Input of 2020-03-25 is printed as: Mar 24 2020 17:00:00 GMT-0700\n // This matches style used in existing convertFilterValuePresModel\n var value = new Date(dateAsString);\n return Number.isNaN(value.getTime()) ? null : value;\n };\n DataTypeConverter.parseDateTime = function (dateAsString) {\n // With a time, the date is assumed to be UTC.\n // Our date format is always: yyyy-mm-dd hh:mm:ss\n // Unfortunately, IE11 can't parse that format so we add a T between the day and time.\n // We also add a Z so that it is UTC. (Without the Z, some browsers assume local, and others UTC)\n var formattedDateString = dateAsString.replace(' ', 'T').concat('Z');\n var value = new Date(formattedDateString);\n return Number.isNaN(value.getTime()) ? null : value;\n };\n // It would be nice to merge this and the method FilterConverter::convertFilterValuePresModel in api-platform-js\n DataTypeConverter.convertValueAsStringToValue = function (valueAsString, type) {\n // This is both DataDictionary and ShowDataTablePresModel compatible.\n // In the DataDictionary, valueAsString can be '%null%' or '%missing%', while in\n // ShowDataTablePresModel, we can get 'null' or 'missing', or '%null%' for string special values.\n // For either of these cases, we return specialValueIndicator (or the original special string).\n // To maintain backwards compatibilty, this converter:\n // 1. returns a string for any special values\n // 2. returns a string for any date\n // Parameter min/max values can be undefined, so result is also undefined\n if (valueAsString === undefined || valueAsString === null) {\n return undefined;\n }\n if (this.isSpecial(valueAsString)) {\n return valueAsString;\n }\n switch (type) {\n case Enums_1.DataType.Bool:\n return this.parseBoolean(valueAsString);\n case Enums_1.DataType.Int:\n case Enums_1.DataType.Float:\n // Return special value '%null%' for any failure in parsing.\n // We need to do that because ShowDataTablePresModel will give us strings like 'null'\n // for special values.\n return this.parseNumber(valueAsString);\n case Enums_1.DataType.Date:\n // For ShowDataTablePresModel, special values will be \"null\" which will fail to parse.\n // In that case, we return '%null%'.\n return this.parseDate(valueAsString) === null ? this.specialValueIndicator : valueAsString;\n case Enums_1.DataType.DateTime:\n // For ShowDataTablePresModel, special values will be \"null\" which will fail to parse.\n // In that case, we return '%null%'\n return this.parseDateTime(valueAsString) === null ? this.specialValueIndicator : valueAsString;\n case Enums_1.DataType.Spatial:\n case Enums_1.DataType.String:\n default:\n return valueAsString;\n }\n };\n // tslint:disable-next-line:no-any\n DataTypeConverter.convertValueToNativeValue = function (value, type) {\n // This converts from our 1.2 API that returns strings for specials, and dates as strings.\n // It takes the special case of '%null%' and returns a null.\n // For dates, it returns a Date object rather than a string.\n // convertValueToNativeValue should be used to build a DataValue.nativeValue field.\n // Parameter min/max can be undefined. If that is the case, nativeValue is treated like a special\n if (value === undefined || value === null) {\n return null;\n }\n switch (type) {\n case Enums_1.DataType.Bool:\n return typeof value === 'string' ? null : value;\n case Enums_1.DataType.Int:\n case Enums_1.DataType.Float:\n return typeof value === 'string' ? null : value;\n case Enums_1.DataType.Date:\n // Convert the string to Date object (or null if parsing fails ... we assume special)\n return this.parseDate(value);\n case Enums_1.DataType.DateTime:\n // Convert the string to Date object (or null if parsing fails ... we assume special)\n return this.parseDateTime(value);\n case Enums_1.DataType.String:\n return this.isSpecial(value) ? null : value;\n case Enums_1.DataType.Spatial:\n default:\n return value;\n }\n };\n // tslint:disable-next-line:no-any\n DataTypeConverter.convertStringValueToNativeValue = function (value, type) {\n // This handles the conversion from string directly to native value for all types\n return this.convertValueToNativeValue(this.convertValueAsStringToValue(value, type), type);\n };\n DataTypeConverter.specialValueIndicator = '%null%';\n return DataTypeConverter;\n}());\nexports.DataTypeConverter = DataTypeConverter;\n//# sourceMappingURL=DataTypeConverter.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ExtensionContext;\n(function (ExtensionContext) {\n ExtensionContext[\"Desktop\"] = \"desktop\";\n ExtensionContext[\"Server\"] = \"server\";\n ExtensionContext[\"Unknown\"] = \"unknown\";\n})(ExtensionContext = exports.ExtensionContext || (exports.ExtensionContext = {}));\nvar ExtensionMode;\n(function (ExtensionMode) {\n ExtensionMode[\"Authoring\"] = \"authoring\";\n ExtensionMode[\"Viewing\"] = \"viewing\";\n ExtensionMode[\"Unknown\"] = \"unknown\";\n})(ExtensionMode = exports.ExtensionMode || (exports.ExtensionMode = {}));\nvar AnnotateEnum;\n(function (AnnotateEnum) {\n AnnotateEnum[\"Mark\"] = \"mark\";\n AnnotateEnum[\"Point\"] = \"point\";\n AnnotateEnum[\"Area\"] = \"area\";\n})(AnnotateEnum = exports.AnnotateEnum || (exports.AnnotateEnum = {}));\nvar ColumnType;\n(function (ColumnType) {\n ColumnType[\"Discrete\"] = \"discrete\";\n ColumnType[\"Continuous\"] = \"continuous\";\n ColumnType[\"Unknown\"] = \"unknown\";\n})(ColumnType = exports.ColumnType || (exports.ColumnType = {}));\nvar DashboardObjectType;\n(function (DashboardObjectType) {\n DashboardObjectType[\"Blank\"] = \"blank\";\n DashboardObjectType[\"Worksheet\"] = \"worksheet\";\n DashboardObjectType[\"QuickFilter\"] = \"quick-filter\";\n DashboardObjectType[\"ParameterControl\"] = \"parameter-control\";\n DashboardObjectType[\"PageFilter\"] = \"page-filter\";\n DashboardObjectType[\"Legend\"] = \"legend\";\n DashboardObjectType[\"Title\"] = \"title\";\n DashboardObjectType[\"Text\"] = \"text\";\n DashboardObjectType[\"Image\"] = \"image\";\n DashboardObjectType[\"WebPage\"] = \"web-page\";\n DashboardObjectType[\"Extension\"] = \"extension\";\n})(DashboardObjectType = exports.DashboardObjectType || (exports.DashboardObjectType = {}));\nvar DataType;\n(function (DataType) {\n DataType[\"String\"] = \"string\";\n DataType[\"Int\"] = \"int\";\n DataType[\"Float\"] = \"float\";\n DataType[\"Bool\"] = \"bool\";\n DataType[\"Date\"] = \"date\";\n DataType[\"DateTime\"] = \"date-time\";\n DataType[\"Spatial\"] = \"spatial\";\n DataType[\"Unknown\"] = \"unknown\";\n})(DataType = exports.DataType || (exports.DataType = {}));\nvar DialogStyle;\n(function (DialogStyle) {\n DialogStyle[\"Window\"] = \"window\";\n DialogStyle[\"Modal\"] = \"modal\";\n DialogStyle[\"Modeless\"] = \"modeless\";\n})(DialogStyle = exports.DialogStyle || (exports.DialogStyle = {}));\nvar EncodedDataType;\n(function (EncodedDataType) {\n EncodedDataType[\"Number\"] = \"number\";\n EncodedDataType[\"String\"] = \"string\";\n EncodedDataType[\"Date\"] = \"date\";\n EncodedDataType[\"Boolean\"] = \"boolean\";\n})(EncodedDataType = exports.EncodedDataType || (exports.EncodedDataType = {}));\nvar ErrorCodes;\n(function (ErrorCodes) {\n ErrorCodes[\"INITIALIZATION_ERROR\"] = \"initialization-error\";\n ErrorCodes[\"INTERNAL_ERROR\"] = \"internal-error\";\n ErrorCodes[\"MISSING_ENUM_MAPPING\"] = \"missing-enum-mapping\";\n ErrorCodes[\"MISSING_PARAMETER\"] = \"missing-parameter\";\n ErrorCodes[\"PERMISSION_DENIED\"] = \"permission-denied\";\n ErrorCodes[\"PRES_MODEL_PARSING_ERROR\"] = \"pres-model-parsing-error\";\n ErrorCodes[\"VERSION_NOT_CONFIGURED\"] = \"version-not-configured\";\n ErrorCodes[\"VISIBILITY_ERROR\"] = \"visibility-error\";\n ErrorCodes[\"UNKNOWN_VERB_ID\"] = \"unknown-verb-id\";\n})(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {}));\nvar FieldAggregationType;\n(function (FieldAggregationType) {\n FieldAggregationType[\"Sum\"] = \"sum\";\n FieldAggregationType[\"Avg\"] = \"avg\";\n FieldAggregationType[\"Min\"] = \"min\";\n FieldAggregationType[\"Max\"] = \"max\";\n FieldAggregationType[\"Stdev\"] = \"stdev\";\n FieldAggregationType[\"Stdevp\"] = \"stdevp\";\n FieldAggregationType[\"Var\"] = \"var\";\n FieldAggregationType[\"Varp\"] = \"varp\";\n FieldAggregationType[\"Collect\"] = \"collect\";\n FieldAggregationType[\"Count\"] = \"count\";\n FieldAggregationType[\"Countd\"] = \"countd\";\n FieldAggregationType[\"Median\"] = \"median\";\n FieldAggregationType[\"Attr\"] = \"attr\";\n FieldAggregationType[\"None\"] = \"none\";\n FieldAggregationType[\"Year\"] = \"year\";\n FieldAggregationType[\"Qtr\"] = \"qtr\";\n FieldAggregationType[\"Month\"] = \"month\";\n FieldAggregationType[\"Day\"] = \"day\";\n FieldAggregationType[\"Hour\"] = \"hour\";\n FieldAggregationType[\"Minute\"] = \"minute\";\n FieldAggregationType[\"Second\"] = \"second\";\n FieldAggregationType[\"Week\"] = \"week\";\n FieldAggregationType[\"Weekday\"] = \"weekday\";\n FieldAggregationType[\"MonthYear\"] = \"month-year\";\n FieldAggregationType[\"Mdy\"] = \"mdy\";\n FieldAggregationType[\"End\"] = \"end\";\n FieldAggregationType[\"TruncYear\"] = \"trunc-year\";\n FieldAggregationType[\"TruncQtr\"] = \"trunc-qtr\";\n FieldAggregationType[\"TruncMonth\"] = \"trunc-month\";\n FieldAggregationType[\"TruncWeek\"] = \"trunc-week\";\n FieldAggregationType[\"TruncDay\"] = \"trunc-day\";\n FieldAggregationType[\"TruncHour\"] = \"trunc-hour\";\n FieldAggregationType[\"TruncMinute\"] = \"trunc-minute\";\n FieldAggregationType[\"TruncSecond\"] = \"trunc-second\";\n FieldAggregationType[\"Quart1\"] = \"quart1\";\n FieldAggregationType[\"Quart3\"] = \"quart3\";\n FieldAggregationType[\"Skewness\"] = \"skewness\";\n FieldAggregationType[\"Kurtosis\"] = \"kurtosis\";\n FieldAggregationType[\"InOut\"] = \"in-out\";\n FieldAggregationType[\"User\"] = \"user\";\n})(FieldAggregationType = exports.FieldAggregationType || (exports.FieldAggregationType = {}));\nvar FieldRoleType;\n(function (FieldRoleType) {\n FieldRoleType[\"Dimension\"] = \"dimension\";\n FieldRoleType[\"Measure\"] = \"measure\";\n FieldRoleType[\"Unknown\"] = \"unknown\";\n})(FieldRoleType = exports.FieldRoleType || (exports.FieldRoleType = {}));\n/**\n * The different update types for applying filter.\n */\nvar FilterUpdateType;\n(function (FilterUpdateType) {\n FilterUpdateType[\"Add\"] = \"add\";\n FilterUpdateType[\"All\"] = \"all\";\n FilterUpdateType[\"Replace\"] = \"replace\";\n FilterUpdateType[\"Remove\"] = \"remove\";\n})(FilterUpdateType = exports.FilterUpdateType || (exports.FilterUpdateType = {}));\nvar SheetType;\n(function (SheetType) {\n SheetType[\"Dashboard\"] = \"dashboard\";\n SheetType[\"Story\"] = \"story\";\n SheetType[\"Worksheet\"] = \"worksheet\";\n})(SheetType = exports.SheetType || (exports.SheetType = {}));\nvar DomainRestrictionType;\n(function (DomainRestrictionType) {\n DomainRestrictionType[\"All\"] = \"all\";\n DomainRestrictionType[\"List\"] = \"list\";\n DomainRestrictionType[\"Range\"] = \"range\";\n})(DomainRestrictionType = exports.DomainRestrictionType || (exports.DomainRestrictionType = {}));\nvar DateStepPeriod;\n(function (DateStepPeriod) {\n DateStepPeriod[\"Years\"] = \"years\";\n DateStepPeriod[\"Quarters\"] = \"quarters\";\n DateStepPeriod[\"Months\"] = \"months\";\n DateStepPeriod[\"Weeks\"] = \"weeks\";\n DateStepPeriod[\"Days\"] = \"days\";\n DateStepPeriod[\"Hours\"] = \"hours\";\n DateStepPeriod[\"Minutes\"] = \"minutes\";\n DateStepPeriod[\"Seconds\"] = \"seconds\";\n})(DateStepPeriod = exports.DateStepPeriod || (exports.DateStepPeriod = {}));\n/**\n * The option for specifying which values to include for filtering.\n */\nvar FilterNullOption;\n(function (FilterNullOption) {\n FilterNullOption[\"NullValues\"] = \"nullvalues\";\n FilterNullOption[\"NonNullValues\"] = \"nonnullvalues\";\n FilterNullOption[\"AllValues\"] = \"allvalues\";\n})(FilterNullOption = exports.FilterNullOption || (exports.FilterNullOption = {}));\n/**\n * The type of filter domain\n */\nvar FilterDomainType;\n(function (FilterDomainType) {\n FilterDomainType[\"Relevant\"] = \"relevant\";\n FilterDomainType[\"Database\"] = \"database\";\n})(FilterDomainType = exports.FilterDomainType || (exports.FilterDomainType = {}));\n/**\n * Internal enum for specifying the selection type for select marks api.\n */\nvar SelectionUpdateType;\n(function (SelectionUpdateType) {\n SelectionUpdateType[\"Replace\"] = \"select-replace\";\n SelectionUpdateType[\"Add\"] = \"select-add\";\n SelectionUpdateType[\"Remove\"] = \"select-remove\";\n})(SelectionUpdateType = exports.SelectionUpdateType || (exports.SelectionUpdateType = {}));\n/**\n * Internal enum for specifying the select option for the select tuples api.\n */\nvar SelectOptions;\n(function (SelectOptions) {\n SelectOptions[\"Simple\"] = \"select-options-simple\";\n SelectOptions[\"Toggle\"] = \"select-options-toggle\";\n SelectOptions[\"Menu\"] = \"select-options-menu\";\n SelectOptions[\"Range\"] = \"select-options-range\";\n SelectOptions[\"Search\"] = \"select-options-search\";\n})(SelectOptions = exports.SelectOptions || (exports.SelectOptions = {}));\n/**\n * Internal enum for specifying the included values type for range selection.\n */\nvar QuantitativeIncludedValues;\n(function (QuantitativeIncludedValues) {\n QuantitativeIncludedValues[\"IncludeNull\"] = \"include-null\";\n QuantitativeIncludedValues[\"IncludeNonNull\"] = \"include-non-null\";\n QuantitativeIncludedValues[\"IncludeAll\"] = \"include-all\";\n})(QuantitativeIncludedValues = exports.QuantitativeIncludedValues || (exports.QuantitativeIncludedValues = {}));\n/**\n * Internal enum for specifying a hierarchical level selection state.\n */\nvar HierarchicalLevelSelectionState;\n(function (HierarchicalLevelSelectionState) {\n HierarchicalLevelSelectionState[\"AllSelected\"] = \"all-selected\";\n HierarchicalLevelSelectionState[\"NoneSelected\"] = \"none-selected\";\n HierarchicalLevelSelectionState[\"SomeSelected\"] = \"some-selected\";\n HierarchicalLevelSelectionState[\"UnknownSelected\"] = \"unknown-selected\";\n})(HierarchicalLevelSelectionState = exports.HierarchicalLevelSelectionState || (exports.HierarchicalLevelSelectionState = {}));\n/**\n * Type of mark for a given marks card in a viz.\n */\nvar MarkType;\n(function (MarkType) {\n MarkType[\"Bar\"] = \"bar\";\n MarkType[\"Line\"] = \"line\";\n MarkType[\"Area\"] = \"area\";\n MarkType[\"Square\"] = \"square\";\n MarkType[\"Circle\"] = \"circle\";\n MarkType[\"Shape\"] = \"shape\";\n MarkType[\"Text\"] = \"text\";\n MarkType[\"Map\"] = \"map\";\n MarkType[\"Pie\"] = \"pie\";\n MarkType[\"GanttBar\"] = \"gantt-bar\";\n MarkType[\"Polygon\"] = \"polygon\";\n MarkType[\"Heatmap\"] = \"heatmap\";\n MarkType[\"VizExtension\"] = \"viz-extension\";\n})(MarkType = exports.MarkType || (exports.MarkType = {}));\n/**\n * Internal enum for specifying the type of filter\n */\nvar FilterType;\n(function (FilterType) {\n FilterType[\"Categorical\"] = \"categorical\";\n FilterType[\"Range\"] = \"range\";\n FilterType[\"RelativeDate\"] = \"relativeDate\";\n FilterType[\"Hierarchical\"] = \"hierarchical\";\n})(FilterType = exports.FilterType || (exports.FilterType = {}));\n/**\n * Internal enum for specifying the DateRangeType of a relative date filter\n */\nvar DateRangeType;\n(function (DateRangeType) {\n /**\n * Refers to the last day, week, month, etc. of the date period.\n */\n DateRangeType[\"Last\"] = \"last\";\n /**\n * Refers to the last N days, weeks, months, etc. of the date period.\n */\n DateRangeType[\"LastN\"] = \"lastN\";\n /**\n * Refers to the next day, week, month, etc. of the date period.\n */\n DateRangeType[\"Next\"] = \"next\";\n /**\n * Refers to the next N days, weeks, months, etc. of the date period.\n */\n DateRangeType[\"NextN\"] = \"nextN\";\n /**\n * Refers to the current day, week, month, etc. of the date period.\n */\n DateRangeType[\"Current\"] = \"current\";\n /**\n * Refers to everything up to and including the current day, week, month, etc. of the date period.\n */\n DateRangeType[\"ToDate\"] = \"toDate\";\n})(DateRangeType = exports.DateRangeType || (exports.DateRangeType = {}));\n/**\n * Used to determine if the launching of an extension dialog succeeded or failed.\n */\nvar ExtensionDialogResult;\n(function (ExtensionDialogResult) {\n ExtensionDialogResult[\"DialogAlreadyOpen\"] = \"dialog-already-open\";\n ExtensionDialogResult[\"InvalidDomain\"] = \"invalid-domain\";\n ExtensionDialogResult[\"Success\"] = \"success\";\n})(ExtensionDialogResult = exports.ExtensionDialogResult || (exports.ExtensionDialogResult = {}));\n// Enumeration for ApiShowData table id sentinels.\nvar ApiShowDataTableSentinel;\n(function (ApiShowDataTableSentinel) {\n // find the one logical table - used in version compatibility check for getUnderlyingDataTable and getLogicalDataTable commands\n ApiShowDataTableSentinel[\"SingleTableId\"] = \"single-table-id-sentinel\";\n ApiShowDataTableSentinel[\"SingleTableCaption\"] = \"Single table id sentinel\";\n})(ApiShowDataTableSentinel = exports.ApiShowDataTableSentinel || (exports.ApiShowDataTableSentinel = {}));\n/**\n * Used to optimize the getSummaryData/getUnderlyingTableData results\n * Mapped from external IncludeDataValuesOption\n */\nvar ApiShowDataTableFormat;\n(function (ApiShowDataTableFormat) {\n ApiShowDataTableFormat[\"NativeValuesOnly\"] = \"native-values-only\";\n ApiShowDataTableFormat[\"FormattedValuesOnly\"] = \"formatted-values-only\";\n ApiShowDataTableFormat[\"NativeAndFormattedValues\"] = \"native-and-formatted-values\";\n})(ApiShowDataTableFormat = exports.ApiShowDataTableFormat || (exports.ApiShowDataTableFormat = {}));\n/**\n * Used to set page size for export layout options.\n */\nvar PageSizeOption;\n(function (PageSizeOption) {\n PageSizeOption[\"Letter\"] = \"letter\";\n PageSizeOption[\"Legal\"] = \"legal\";\n PageSizeOption[\"Note\"] = \"note\";\n PageSizeOption[\"Folio\"] = \"folio\";\n PageSizeOption[\"Tabloid\"] = \"tabloid\";\n PageSizeOption[\"Ledger\"] = \"ledger\";\n PageSizeOption[\"Statement\"] = \"statement\";\n PageSizeOption[\"Executive\"] = \"executive\";\n PageSizeOption[\"A3\"] = \"a3\";\n PageSizeOption[\"A4\"] = \"a4\";\n PageSizeOption[\"A5\"] = \"a5\";\n PageSizeOption[\"B4\"] = \"b4\";\n PageSizeOption[\"B5\"] = \"b5\";\n PageSizeOption[\"Quarto\"] = \"quarto\";\n PageSizeOption[\"Unspecified\"] = \"unspecified\";\n})(PageSizeOption = exports.PageSizeOption || (exports.PageSizeOption = {}));\n/**\n * Used to set the page orientation mode for export layout options.\n */\nvar PageOrientation;\n(function (PageOrientation) {\n PageOrientation[\"Printer\"] = \"printer\";\n PageOrientation[\"Portrait\"] = \"portrait\";\n PageOrientation[\"Landscape\"] = \"landscape\";\n})(PageOrientation = exports.PageOrientation || (exports.PageOrientation = {}));\n/**\n * Used to set scale mode for export layout options.\n */\nvar ScaleMode;\n(function (ScaleMode) {\n ScaleMode[\"ScaleAuto\"] = \"auto\";\n ScaleMode[\"ScalePercentage\"] = \"percent\";\n ScaleMode[\"ScaleFitPages\"] = \"fit-pages\";\n})(ScaleMode = exports.ScaleMode || (exports.ScaleMode = {}));\n/**\n * Used by setFitAndScaleValues to scale percent values\n */\nvar PageScalingOption;\n(function (PageScalingOption) {\n PageScalingOption[\"ScalePctAuto\"] = \"auto\";\n PageScalingOption[\"ScalePct400\"] = \"pct400\";\n PageScalingOption[\"ScalePct200\"] = \"pct200\";\n PageScalingOption[\"ScalePct100\"] = \"pct100\";\n PageScalingOption[\"ScalePct90\"] = \"pct90\";\n PageScalingOption[\"ScalePct80\"] = \"pct80\";\n PageScalingOption[\"ScalePct75\"] = \"pct75\";\n PageScalingOption[\"ScalePct60\"] = \"pct60\";\n PageScalingOption[\"ScalePct50\"] = \"pct50\";\n PageScalingOption[\"ScalePct25\"] = \"pct25\";\n})(PageScalingOption = exports.PageScalingOption || (exports.PageScalingOption = {}));\n/**\n * Used by setFitAndScaleValues to scale fit page values\n */\nvar FitPages;\n(function (FitPages) {\n FitPages[\"FitOneHigh\"] = \"fit0x1\";\n FitPages[\"FitTwoHigh\"] = \"fit0x2\";\n FitPages[\"FitOneWide\"] = \"fit1x0\";\n FitPages[\"FitTwoWide\"] = \"fit2x0\";\n})(FitPages = exports.FitPages || (exports.FitPages = {}));\n/**\n * Used by getVisualSpecificationAsync\n */\nvar EncodingType;\n(function (EncodingType) {\n EncodingType[\"Color\"] = \"color\";\n EncodingType[\"Size\"] = \"size\";\n EncodingType[\"Label\"] = \"label\";\n EncodingType[\"Detail\"] = \"detail\";\n EncodingType[\"Tooltip\"] = \"tooltip\";\n EncodingType[\"Shape\"] = \"shape\";\n EncodingType[\"Path\"] = \"path\";\n EncodingType[\"Angle\"] = \"angle\";\n EncodingType[\"Geometry\"] = \"geometry\";\n EncodingType[\"Custom\"] = \"custom\";\n})(EncodingType = exports.EncodingType || (exports.EncodingType = {}));\n//# sourceMappingURL=Enums.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar NotificationId;\n(function (NotificationId) {\n NotificationId[\"CustomMarkContextMenuClicked\"] = \"custom-mark-context-menu-clicked\";\n NotificationId[\"ContextMenuClick\"] = \"context-menu-click\";\n NotificationId[\"CustomViewRemoved\"] = \"custom-view-removed\";\n NotificationId[\"CustomViewSaved\"] = \"custom-view-saved\";\n NotificationId[\"CustomViewSetDefault\"] = \"custom-view-set-default\";\n NotificationId[\"CustomViewsLoaded\"] = \"custom-views-loaded\";\n NotificationId[\"DashboardLayoutChanged\"] = \"dashboard-layout-changed\";\n NotificationId[\"EditButtonClicked\"] = \"edit-button-clicked\";\n NotificationId[\"EditInDesktopButtonClicked\"] = \"edit-in-desktop-button-clicked\";\n NotificationId[\"ExtensionDialogUpdate\"] = \"extension-dialog-update\";\n NotificationId[\"FilterChanged\"] = \"filter-changed\";\n NotificationId[\"FirstVizSizeKnown\"] = \"first-viz-size-known\";\n NotificationId[\"ParameterChanged\"] = \"parameter-changed\";\n NotificationId[\"SelectedMarksChanged\"] = \"selected-marks-changed\";\n NotificationId[\"SettingsChanged\"] = \"settings-changed\";\n NotificationId[\"SummaryDataChanged\"] = \"summary-data-changed\";\n NotificationId[\"TestConversionNotification\"] = \"test-conversion-notification\";\n NotificationId[\"ToolbarStateChanged\"] = \"toolbar-state-changed\";\n NotificationId[\"VizInteractive\"] = \"viz-interactive\";\n NotificationId[\"AskDataInteractive\"] = \"ask-data-interactive\";\n NotificationId[\"WorkbookReadyToClose\"] = \"workbook-ready-to-close\";\n NotificationId[\"WorkbookFormattingChanged\"] = \"workbook-formatting-changed\";\n NotificationId[\"WorkbookPublished\"] = \"workbook-published\";\n NotificationId[\"WorkbookPublishedAs\"] = \"workbook-published-as\";\n NotificationId[\"UrlAction\"] = \"url-action\";\n NotificationId[\"TabSwitched\"] = \"tab-switched\";\n NotificationId[\"StoryPointSwitched\"] = \"story-point-switched\";\n NotificationId[\"ReadyToReceiveAuthToken\"] = \"ready-to-receive-auth-token\";\n})(NotificationId = exports.NotificationId || (exports.NotificationId = {}));\n//# sourceMappingURL=Notifications.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// PLEASE KEEP IN ALPHABETICAL ORDER. This helps with visually finding entries, knowing where to put\n// new ones, and merge conflicts.\nvar ParameterId;\n(function (ParameterId) {\n ParameterId[\"ActiveTablesInfo\"] = \"active-tables-info\";\n ParameterId[\"AnchorDate\"] = \"anchor-date\";\n ParameterId[\"AnnotateEnum\"] = \"annotate-enum\";\n ParameterId[\"AnnotationList\"] = \"annotation-list\";\n ParameterId[\"CategoricalDomain\"] = \"categorical-domain\";\n ParameterId[\"ClickThroughEnabled\"] = \"click-through-enabled\";\n ParameterId[\"ColumnsToInclude\"] = \"columns-to-include\";\n ParameterId[\"ColumnsToIncludeById\"] = \"columns-to-include-by-id\";\n ParameterId[\"ConnectionDescriptionSummaries\"] = \"connection-description-summaries\";\n ParameterId[\"CurrentSheetType\"] = \"current-sheet-type\";\n ParameterId[\"CustomView\"] = \"custom-view\";\n ParameterId[\"CustomViewIsDefault\"] = \"custom-view-is-default\";\n ParameterId[\"CustomViewIsPublic\"] = \"custom-view-is-public\";\n ParameterId[\"CustomViewLuid\"] = \"custom-view-luid\";\n ParameterId[\"CustomViewName\"] = \"custom-view-name\";\n ParameterId[\"CustomViews\"] = \"custom-views\";\n ParameterId[\"Dashboard\"] = \"dashboard\";\n ParameterId[\"DashboardFilters\"] = \"dashboard-filters\";\n ParameterId[\"DashboardName\"] = \"dashboard\";\n ParameterId[\"DashboardObjectPositionAndSizeUpdate\"] = \"dashboard-object-position-and-size-update\";\n ParameterId[\"DashboardObjectPositionAndSizeUpdateList\"] = \"dashboard-object-position-and-size-update-list\";\n ParameterId[\"DataRowIndex\"] = \"data-row-index\";\n ParameterId[\"DataSchema\"] = \"data-schema\";\n ParameterId[\"DataSource\"] = \"data-source\";\n ParameterId[\"DataSourceDataTable\"] = \"data-source-data-table\";\n ParameterId[\"DataSourceId\"] = \"data-source-id\";\n ParameterId[\"DataSourceName\"] = \"data-source-name\";\n ParameterId[\"DataTable\"] = \"data-table\";\n ParameterId[\"DataTableReader\"] = \"data-table-reader\";\n ParameterId[\"DateRangeType\"] = \"date-range-type\";\n ParameterId[\"DeltaTimeMs\"] = \"delta-time-ms\";\n ParameterId[\"DimValSelectionModels\"] = \"dimensionValueSelectionModels\";\n ParameterId[\"DomainType\"] = \"domain-type\";\n ParameterId[\"EmbeddingAbstractQuery\"] = \"embedding-abstract-query\";\n ParameterId[\"EmbeddingBootstrapInfo\"] = \"embedding-bootstrap-info\";\n ParameterId[\"ExportCrosstabSheetMap\"] = \"export-crosstab-sheet-map\";\n ParameterId[\"ExportFile\"] = \"export-file\";\n ParameterId[\"ExportOriginUrl\"] = \"export-origin-url\";\n ParameterId[\"ExportPdfOptions\"] = \"export-pdf-options\";\n ParameterId[\"ExtensionBootstrapInfo\"] = \"extension-bootstrap-info\";\n ParameterId[\"ExtensionContextMenuIds\"] = \"extension-context-menu-ids\";\n ParameterId[\"ExtensionDialogH\"] = \"extension-dialog-height\";\n ParameterId[\"ExtensionDialogPayload\"] = \"extension-dialog-payload\";\n ParameterId[\"ExtensionDialogResult\"] = \"extension-dialog-result\";\n ParameterId[\"ExtensionDialogStyle\"] = \"extension-dialog-style\";\n ParameterId[\"ExtensionDialogUrl\"] = \"extension-dialog-url\";\n ParameterId[\"ExtensionDialogW\"] = \"extension-dialog-width\";\n ParameterId[\"ExtensionLocator\"] = \"extension-locator\";\n ParameterId[\"ExtensionSettingsInfo\"] = \"extension-settings-info\";\n ParameterId[\"ExtensionZoneId\"] = \"extension-zone-id\";\n ParameterId[\"ExternalMenuDescription\"] = \"external-menu-description\";\n ParameterId[\"ExternalMenuHeader\"] = \"external-menu-header\";\n ParameterId[\"ExternalMenuItemDisplayName\"] = \"external-menu-item-display-name\";\n ParameterId[\"ExternalMenuItemId\"] = \"external-menu-item-id\";\n ParameterId[\"Field\"] = \"field\";\n ParameterId[\"FieldId\"] = \"field-id\";\n ParameterId[\"FieldName\"] = \"field-name\";\n ParameterId[\"FilterLevels\"] = \"filter-levels\";\n ParameterId[\"FilterRangeMax\"] = \"filter-range-max\";\n ParameterId[\"FilterRangeMin\"] = \"filter-range-min\";\n ParameterId[\"FilterRangeNullOption\"] = \"filter-range-null-option\";\n ParameterId[\"FilterUpdateType\"] = \"filter-update-type\";\n ParameterId[\"FilterValues\"] = \"filter-values\";\n ParameterId[\"FontNameListItems\"] = \"font-name-list-items\";\n ParameterId[\"FormattedText\"] = \"formatted-text\";\n ParameterId[\"FunctionName\"] = \"function-name\";\n ParameterId[\"HierValSelectionModels\"] = \"hierarchicalValueSelectionModels\";\n ParameterId[\"HighlightedData\"] = \"highlighted-data\";\n ParameterId[\"HoverTupleInteraction\"] = \"hover-tuple-interaction\";\n ParameterId[\"IgnoreAliases\"] = \"ignore-aliases\";\n ParameterId[\"IgnoreSelection\"] = \"ignore-selection\";\n ParameterId[\"IncludeAllColumns\"] = \"include-all-columns\";\n ParameterId[\"InvalidAggFieldName\"] = \"invalid-agg-field-name\";\n ParameterId[\"InvalidDates\"] = \"invalid-dates\";\n ParameterId[\"InvalidFieldCaption\"] = \"invalid-field-caption\";\n ParameterId[\"InvalidFields\"] = \"invalid-fields\";\n ParameterId[\"InvalidValues\"] = \"invalid-values\";\n ParameterId[\"IsExcludeMode\"] = \"is-exclude\";\n ParameterId[\"IsExtensionDialog\"] = \"is-extension-dialog\";\n ParameterId[\"JoinDescription\"] = \"join-description\";\n ParameterId[\"LogicalTableId\"] = \"logical-table-id\";\n ParameterId[\"LogicalTableInfoList\"] = \"logical-table-info-list\";\n ParameterId[\"MaxHeight\"] = \"max-height\";\n ParameterId[\"MaxRows\"] = \"max-rows\";\n ParameterId[\"MaxWidth\"] = \"max-width\";\n ParameterId[\"MinHeight\"] = \"min-height\";\n ParameterId[\"MinWidth\"] = \"min-width\";\n ParameterId[\"PageRowCount\"] = \"page-row-count\";\n ParameterId[\"ParameterCaption\"] = \"paremeter-caption\";\n ParameterId[\"ParameterError\"] = \"parameter-error\";\n ParameterId[\"ParameterFieldName\"] = \"parameter-field-name\";\n ParameterId[\"ParameterInfo\"] = \"parameter-info\";\n ParameterId[\"ParameterInfos\"] = \"parameter-infos\";\n ParameterId[\"ParameterValue\"] = \"parameter-value\";\n ParameterId[\"PeriodType\"] = \"period-type\";\n ParameterId[\"QuantitativeDomain\"] = \"quantitative-dmain\";\n ParameterId[\"QuantRangeSelectionModels\"] = \"quantativeRangeSelectionModels\";\n ParameterId[\"RangeN\"] = \"range-n\";\n ParameterId[\"ReplaySpeed\"] = \"replay-speed\";\n ParameterId[\"SelectedData\"] = \"selected-data\";\n ParameterId[\"SelectedSheetNames\"] = \"selected-sheet-names\";\n ParameterId[\"Selection\"] = \"selection\";\n ParameterId[\"SelectionList\"] = \"selection-list\";\n ParameterId[\"SelectionUpdateType\"] = \"selectionUpdateType\";\n ParameterId[\"SelectTuplesInteraction\"] = \"select-tuples-interaction\";\n ParameterId[\"SendNotifications\"] = \"send-notifications\";\n ParameterId[\"SettingsValues\"] = \"settings-values\";\n ParameterId[\"SharedFilterSheets\"] = \"shared-filter-sheets\";\n ParameterId[\"SharedFiltersInfo\"] = \"shared-filters-info\";\n ParameterId[\"SheetIdentifier\"] = \"sheet-identifier\";\n ParameterId[\"SheetName\"] = \"sheet-name\";\n ParameterId[\"SheetPath\"] = \"sheet-path\";\n ParameterId[\"ShouldRefreshDS\"] = \"should-refresh-ds\";\n ParameterId[\"ShowDataTableFormat\"] = \"show-data-table-format\";\n ParameterId[\"State\"] = \"state\";\n ParameterId[\"StoryPointIndex\"] = \"story-point-index\";\n ParameterId[\"StoryPointInfo\"] = \"story-point-info\";\n ParameterId[\"SwitchToSheetName\"] = \"switch-to-sheet-name\";\n ParameterId[\"TargetPoint\"] = \"target-point\";\n ParameterId[\"TestConversionParameter\"] = \"test-conversion-parameter\";\n ParameterId[\"Text\"] = \"formatted-text\";\n ParameterId[\"TooltipContext\"] = \"tooltip-context\";\n ParameterId[\"TooltipTextRequest\"] = \"tooltip-text-request\";\n ParameterId[\"TooltipText\"] = \"tooltip-text\";\n ParameterId[\"UnderlyingDataTable\"] = \"underlying-data-table\";\n ParameterId[\"UnderlyingSummaryDataTable\"] = \"underlying-summary-data-table\";\n ParameterId[\"Url\"] = \"url\";\n ParameterId[\"UseTabDelimiters\"] = \"use-tab-delimiters\";\n ParameterId[\"ViewDataTableCacheId\"] = \"view-data-table-cache-id\";\n ParameterId[\"ViewDataTableId\"] = \"view-data-table-id\";\n ParameterId[\"VisualId\"] = \"visual-id\";\n ParameterId[\"VisualSpecification\"] = \"visual-specification\";\n ParameterId[\"VizAPIInputJson\"] = \"vizapi-input-json\";\n ParameterId[\"VizAPIStateWithDataModel\"] = \"vizapi-state-with-data-model\";\n ParameterId[\"VizAPIStateWarningMsg\"] = \"vizapi-state-warning-msg\";\n ParameterId[\"VizAPISVG\"] = \"vizapi-svg\";\n ParameterId[\"WorksheetName\"] = \"worksheet-name\";\n ParameterId[\"WorksheetFilters\"] = \"worksheet-filters\";\n ParameterId[\"ZoneIdsVisibilityMap\"] = \"zone-ids-visibility-map\";\n})(ParameterId = exports.ParameterId || (exports.ParameterId = {}));\n//# sourceMappingURL=Parameters.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// Declare this key type and export the NotificationId to make this behave like a string enum.\n//\n// PLEASE KEEP IN ALPHABETICAL ORDER. This helps with visually finding entries, knowing where to put\n// new ones, and merge conflicts.\nvar VerbId;\n(function (VerbId) {\n VerbId[\"ActivateNextStoryPoint\"] = \"activate-next-story-point\";\n VerbId[\"ActivatePreviousStoryPoint\"] = \"activate-previous-story-point\";\n VerbId[\"ActivateSheet\"] = \"activateSheet\";\n VerbId[\"ActivateStoryPoint\"] = \"activate-story-point\";\n VerbId[\"AppendExternalMenuItem\"] = \"append-external-menu-item\";\n VerbId[\"ApplyCategoricalFilter\"] = \"categorical-filter\";\n VerbId[\"ApplyRangeFilter\"] = \"range-filter\";\n VerbId[\"ApplyRelativeDateFilter\"] = \"apply-relative-date-Filter\";\n VerbId[\"Authenticate\"] = \"authenticate\";\n VerbId[\"BlockExtension\"] = \"block-extension\";\n VerbId[\"ChangeParameterValue\"] = \"change-parameter-value\";\n VerbId[\"ChangeSharedFilter\"] = \"change-shared-filter\";\n VerbId[\"ClearFilter\"] = \"clear-filter\";\n VerbId[\"ClearSelectedMarks\"] = \"clear-selected-marks\";\n VerbId[\"CloseDialog\"] = \"close-dialog\";\n VerbId[\"CreateAnnotation\"] = \"create-annotation\";\n VerbId[\"DashboardCategoricalFilter\"] = \"dashboard-categorical-filter\";\n VerbId[\"DisplayDialog\"] = \"display-dialog\";\n VerbId[\"DownloadWorkbook\"] = \"download-workbook\";\n VerbId[\"ExecuteExternalMenuItem\"] = \"execute-external-menu-item\";\n VerbId[\"ExportCrosstab\"] = \"export-crosstab\";\n VerbId[\"ExportCrosstabCsvDownload\"] = \"export-crosstab-csv-download\";\n VerbId[\"ExportCrosstabExcelDownload\"] = \"export-crosstab-excel-download\";\n VerbId[\"ExportData\"] = \"export-data\";\n VerbId[\"ExportDataDownload\"] = \"export-data-download\";\n VerbId[\"ExportImage\"] = \"export-image\";\n VerbId[\"ExportPdf\"] = \"export-pdf\";\n VerbId[\"ExportPdfDownload\"] = \"export-pdf-download\";\n VerbId[\"ExportPowerpoint\"] = \"export-powerpoint\";\n VerbId[\"ExportPowerpointDownload\"] = \"export-powerpoint-download\";\n VerbId[\"FindParameter\"] = \"find-parameter\";\n VerbId[\"GetActiveTables\"] = \"get-active-tables\";\n VerbId[\"GetAllDataSources\"] = \"get-all-data-sources\";\n VerbId[\"GetAnnotations\"] = \"get-annotations\";\n VerbId[\"GetCategoricalDomain\"] = \"get-categorical-domain\";\n VerbId[\"GetConnectionDescriptionSummaries\"] = \"get-connection-description-summaries\";\n VerbId[\"GetCurrentSrc\"] = \"get-current-src\";\n VerbId[\"GetCustomViews\"] = \"get-custom-views\";\n VerbId[\"GetDashboardFilters\"] = \"get-dashboard-filters\";\n VerbId[\"GetDataSource\"] = \"get-datasource\";\n VerbId[\"GetDataSourceData\"] = \"get-datasource-data\";\n VerbId[\"GetDataSources\"] = \"get-data-sources\";\n VerbId[\"GetDataSummaryData\"] = \"get-summary-data\";\n VerbId[\"GetDataSummaryDataReader\"] = \"get-summary-data-reader\";\n VerbId[\"GetDataTableReaderPage\"] = \"get-data-table-reader-page\";\n VerbId[\"GetEmbeddingAbstractQueryWithDataModel\"] = \"get-embedding-abstract-query-with-data-model\";\n VerbId[\"GetEmbeddingClientInfo\"] = \"get-embedding-client-info\";\n VerbId[\"GetVizStateWithDataModel\"] = \"get-viz-state-with-data-model\";\n VerbId[\"GetExportCrosstabSheetMap\"] = \"get-export-crosstab-sheet-map\";\n VerbId[\"GetExportPdfOptions\"] = \"get-export-pdf-options\";\n VerbId[\"GetField\"] = \"get-field\";\n VerbId[\"GetFieldAndDataSource\"] = \"get-field-and-datasource\";\n VerbId[\"GetVisualSpecification\"] = \"get-visual-specification\";\n VerbId[\"GetFilters\"] = \"get-filters\";\n VerbId[\"GetFonts\"] = \"get-fonts\";\n VerbId[\"GetHighlightedMarks\"] = \"get-highlighted-marks\";\n VerbId[\"GetJoinDescription\"] = \"get-join-description\";\n VerbId[\"GetLogicalTableData\"] = \"get-logical-table-data\";\n VerbId[\"GetLogicalTableDataReader\"] = \"get-logical-table-data-reader\";\n VerbId[\"GetLogicalTables\"] = \"get-logical-tables\";\n VerbId[\"GetParametersForSheet\"] = \"get-parameters-for-sheet\";\n VerbId[\"GetRangeDomain\"] = \"get-range-domain\";\n VerbId[\"GetSelectedMarks\"] = \"get-selected-marks\";\n VerbId[\"GetSharedFilter\"] = \"get-shared-filter\";\n VerbId[\"GetTooltipText\"] = \"get-tooltip-text\";\n VerbId[\"GetUnderlyingData\"] = \"get-underlying-data\";\n VerbId[\"GetUnderlyingTableData\"] = \"get-underlying-table-data\";\n VerbId[\"GetUnderlyingTableDataReader\"] = \"get-underlying-table-data-reader\";\n VerbId[\"GetUnderlyingTables\"] = \"get-underlying-tables\";\n VerbId[\"HierarchicalFilter\"] = \"hierachical-filter\";\n VerbId[\"InitializeExtension\"] = \"initialize-extension\";\n VerbId[\"MoveAndResizeZones\"] = \"move-and-resize-zones\";\n VerbId[\"RaiseLeaveMarkNavNotification\"] = \"raise-leave-mark-nav-notification\";\n VerbId[\"RaiseHoverTupleNotification\"] = \"raise-hover-tuple-notification\";\n VerbId[\"RaiseSelectTuplesNotification\"] = \"raise-select-tuples-notification\";\n VerbId[\"Redo\"] = \"redo\";\n VerbId[\"RefreshDataSource\"] = \"refresh-data-source\";\n VerbId[\"ReleaseDataTableReader\"] = \"release-data-table-reader\";\n VerbId[\"RemoveAnnotation\"] = \"remove-annotation\";\n VerbId[\"RemoveCustomView\"] = \"remove-custom-view\";\n VerbId[\"RemoveExternalMenuItem\"] = \"remove-external-menu-item\";\n VerbId[\"RenameExternalMenu\"] = \"rename-external-menu\";\n VerbId[\"ReplayAnimation\"] = \"replay-animation\";\n VerbId[\"RevertStoryPoint\"] = \"revert-story-point\";\n VerbId[\"RevertWorkbook\"] = \"revert-workbook\";\n VerbId[\"SaveExtensionSettings\"] = \"save-extension-settings\";\n VerbId[\"SaveWorkbookAsCustomView\"] = \"save-workbook-as-custom-view\";\n VerbId[\"SelectByValue\"] = \"select-by-value\";\n VerbId[\"SetActiveCustomViewAsDefault\"] = \"set-active-custom-view-as-default\";\n VerbId[\"SetAutoUpdate\"] = \"set-auto-update\";\n VerbId[\"SetClickThrough\"] = \"set-click-through\";\n VerbId[\"SetVizStateWithDataModel\"] = \"set-viz-state-with-data-model\";\n VerbId[\"SetSheetSize\"] = \"set-sheet-size\";\n VerbId[\"SetZoneVisibility\"] = \"set-zone-visibility\";\n VerbId[\"Share\"] = \"share\";\n VerbId[\"ShowCustomView\"] = \"show-custom-view\";\n VerbId[\"TestConversionVerb\"] = \"test-conversion-verb\";\n VerbId[\"Undo\"] = \"undo\";\n VerbId[\"UpdateCustomView\"] = \"update-custom-view\";\n VerbId[\"VizAPI\"] = \"viz-api\";\n})(VerbId = exports.VerbId || (exports.VerbId = {}));\n//# sourceMappingURL=Verbs.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar AskDataOptionNames;\n(function (AskDataOptionNames) {\n AskDataOptionNames[\"token\"] = \"token\";\n AskDataOptionNames[\"origin\"] = \"origin\";\n AskDataOptionNames[\"showEmbed\"] = \"showEmbed\";\n AskDataOptionNames[\"showPin\"] = \"showPin\";\n AskDataOptionNames[\"showSave\"] = \"showSave\";\n AskDataOptionNames[\"showShare\"] = \"showShare\";\n AskDataOptionNames[\"debug\"] = \":jsdebug\";\n AskDataOptionNames[\"ApiID\"] = \":apiID\";\n AskDataOptionNames[\"ApiExternalVersion\"] = \":apiExternalVersion\";\n AskDataOptionNames[\"ApiInternalVersion\"] = \":apiInternalVersion\";\n AskDataOptionNames[\"AskDataWebComponent\"] = \":askDataWebComponent\";\n})(AskDataOptionNames = exports.AskDataOptionNames || (exports.AskDataOptionNames = {}));\n//# sourceMappingURL=AskDataInterface.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar PulseOptionNames;\n(function (PulseOptionNames) {\n PulseOptionNames[\"embed\"] = \"embed\";\n PulseOptionNames[\"token\"] = \"token\";\n PulseOptionNames[\"disableExploreFilter\"] = \"disableExploreFilter\";\n PulseOptionNames[\"layout\"] = \"embed_layout\";\n PulseOptionNames[\"ApiExternalVersion\"] = \":apiExternalVersion\";\n PulseOptionNames[\"ApiInternalVersion\"] = \":apiInternalVersion\";\n PulseOptionNames[\"PulseWebComponent\"] = \":pulseWebComponent\";\n})(PulseOptionNames = exports.PulseOptionNames || (exports.PulseOptionNames = {}));\n//# sourceMappingURL=PulseInterface.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * These strings were *manually copied* from the server,\n * workgroup/src/silos/tableau-server/libraries/tab-controller-vizql/src/com/tableausoftware/\n * controller/vizql/constants/ParameterKeys.java#L9\n * should be exported instead\n * parameters that vizql will accept in an embedding URL\n **/\nvar VqlParameterNames;\n(function (VqlParameterNames) {\n VqlParameterNames[\"ONE\"] = \"1\";\n VqlParameterNames[\"ALERTS\"] = \":alerts\";\n VqlParameterNames[\"ALIAS\"] = \"alias\";\n VqlParameterNames[\"ALLOW_DEFERRED_BOOTSTRAP\"] = \":allowDeferredBootstrap\";\n VqlParameterNames[\"ALLOW_AUTOGEN_WORKSHEET_PHONE_LAYOUTS\"] = \"allowAutogenWorksheetPhoneLayouts\";\n VqlParameterNames[\"API_ID\"] = \":apiID\";\n VqlParameterNames[\"APP\"] = \":app\";\n VqlParameterNames[\"ATTACHMENT\"] = \"attachment\";\n VqlParameterNames[\"IS_IPAD_APP\"] = \"app\";\n VqlParameterNames[\"ANIMATE_TRANSITION\"] = \":animate_transition\";\n VqlParameterNames[\"ASCENDING\"] = \"ascending\";\n VqlParameterNames[\"AUTHENTICATION\"] = \"authentication\";\n VqlParameterNames[\"ATTRIBUTES\"] = \"attributes\";\n VqlParameterNames[\"AUTHORING_SHEET\"] = \":authSheet\";\n VqlParameterNames[\"AXIS\"] = \"axis\";\n VqlParameterNames[\"BOOTSTRAP_WHEN_NOTIFIED\"] = \":bootstrapWhenNotified\";\n VqlParameterNames[\"BROWSER_BACK_BUTTON_UNDO\"] = \":browserBackButtonUndo\";\n VqlParameterNames[\"BROWSER_RENDERING_ON\"] = \"isBrowserRendering\";\n VqlParameterNames[\"BROWSER_RENDERING_THRESHOLD\"] = \"browserRenderingThreshold\";\n VqlParameterNames[\"CHARSET\"] = \"charset\";\n VqlParameterNames[\"CLIENT_DIMENSION\"] = \"clientDimension\";\n VqlParameterNames[\"CLIENT_IP\"] = \"client_ip\";\n VqlParameterNames[\"CLIENT_NUM\"] = \"clientNum\";\n VqlParameterNames[\"COLON_EMBEDDED\"] = \":embedded\";\n VqlParameterNames[\"COLON_MOBILE\"] = \":mobile\";\n VqlParameterNames[\"COLON_DEEP_LINKING_DISABLED\"] = \":deepLinkingDisabled\";\n VqlParameterNames[\"COLON_WATERMARK\"] = \":watermark\";\n VqlParameterNames[\"COMMENTS\"] = \":comments\";\n VqlParameterNames[\"COMMENTING_ENABLED\"] = \":commentingEnabled\";\n VqlParameterNames[\"COMMENTING_MENTIONS_ENABLED\"] = \":commentingMentions\";\n VqlParameterNames[\"CONNECTION\"] = \"connection\";\n VqlParameterNames[\"CREATED_BY_FEATURE\"] = \"createdByFeature\";\n VqlParameterNames[\"CRYPTED_PASSWORD\"] = \"crypted\";\n VqlParameterNames[\"CSSDEBUG\"] = \":cssdebug\";\n VqlParameterNames[\"CSV\"] = \"csv\";\n VqlParameterNames[\"CUSTOM_VIEWS\"] = \":customViews\";\n VqlParameterNames[\"CV\"] = \":cv\";\n VqlParameterNames[\"CV_ID\"] = \"cvId\";\n VqlParameterNames[\"DASHBOARD_PORT_SIZE\"] = \"dashboardPortSize\";\n VqlParameterNames[\"DATA_DETAILS\"] = \":dataDetails\";\n VqlParameterNames[\"DATASOURCE\"] = \"datasource\";\n VqlParameterNames[\"DEBUG\"] = \":debug\";\n VqlParameterNames[\"DELAY\"] = \":delay\";\n VqlParameterNames[\"DEPTH\"] = \"depth\";\n VqlParameterNames[\"DEVICE_TYPE\"] = \":device\";\n VqlParameterNames[\"DEVICE_PIXEL_RATIO\"] = \"devicePixelRatio\";\n VqlParameterNames[\"DEVICE_PREVIEW_MODE\"] = \":devicepreviewmode\";\n VqlParameterNames[\"DIMENSIONS\"] = \":dimensions\";\n VqlParameterNames[\"DISABLE_SHARED_SESSIONS\"] = \":disable_shared_sessions\";\n VqlParameterNames[\"DISABLE_URL_ACTIONS_POPUPS\"] = \":disableUrlActionsPopups\";\n VqlParameterNames[\"DIRECTION\"] = \"direction\";\n VqlParameterNames[\"DISPLAY_OVERLAY\"] = \":display_overlay\";\n VqlParameterNames[\"DISPLAY_SHARE\"] = \":display_share\";\n VqlParameterNames[\"DISPLAY_SPINNER\"] = \":display_spinner\";\n VqlParameterNames[\"DISPLAY_STATIC_IMAGE\"] = \":display_static_image\";\n VqlParameterNames[\"DISPLAY_TABS\"] = \"display_tabs\";\n VqlParameterNames[\"DISPLAY_VIEW_COUNT\"] = \":display_count\";\n VqlParameterNames[\"IGNORE_STICKY_SESSION\"] = \":ignore_sticky_session\";\n VqlParameterNames[\"INCREMENT_VIEW_COUNT\"] = \":increment_view_count\";\n VqlParameterNames[\"DOCMODE\"] = \"docmode\";\n VqlParameterNames[\"DOMAIN\"] = \"domain\";\n VqlParameterNames[\"DO_WORK\"] = \"do_work\";\n VqlParameterNames[\"DX\"] = \"dx\";\n VqlParameterNames[\"DY\"] = \"dy\";\n VqlParameterNames[\"EDIT_DATA_ALERT\"] = \":editDataAlert\";\n VqlParameterNames[\"EMBED\"] = \":embed\";\n VqlParameterNames[\"EMBEDDED\"] = \"embedded\";\n VqlParameterNames[\"ENCRYPTED\"] = \"encrypted\";\n VqlParameterNames[\"API_EXTERNAL_VERSION\"] = \":apiExternalVersion\";\n VqlParameterNames[\"API_INTERNAL_VERSION\"] = \":apiInternalVersion\";\n VqlParameterNames[\"EXCLUDE\"] = \"exclude\";\n VqlParameterNames[\"EXPORT_FORMAT\"] = \":export_format\";\n VqlParameterNames[\"FIELDNAME\"] = \"fieldname\";\n VqlParameterNames[\"FIELD_NAME\"] = \"field_name\";\n VqlParameterNames[\"FIELD_SEP\"] = \"field_sep\";\n VqlParameterNames[\"FILE\"] = \"file\";\n VqlParameterNames[\"FILTER_TILE_SIZE\"] = \"filterTileSize\";\n VqlParameterNames[\"FN\"] = \"fn\";\n VqlParameterNames[\"FOCUS\"] = \"focus\";\n VqlParameterNames[\"FORCE_CACHE\"] = \"force_cache\";\n VqlParameterNames[\"FORMAT\"] = \"format\";\n VqlParameterNames[\"FORMAT_DATA_VALUE_LOCALLY\"] = \"formatDataValueLocally\";\n VqlParameterNames[\"FROM_WG\"] = \":from_wg\";\n VqlParameterNames[\"GRAPHQL_DATABASE_ID\"] = \":graphQLDatabaseId\";\n VqlParameterNames[\"GRAPHQL_TABLE_ID\"] = \":graphQLTableId\";\n VqlParameterNames[\"GUID\"] = \":guid\";\n VqlParameterNames[\"H\"] = \"h\";\n VqlParameterNames[\"HIDDEN\"] = \"hidden\";\n VqlParameterNames[\"HIDE_CLOSE_BUTTON\"] = \":hideCloseButton\";\n VqlParameterNames[\"HIDE_EDIT_BUTTON\"] = \":hideEditButton\";\n VqlParameterNames[\"HIDE_EDIT_IN_DESKTOP_BUTTON\"] = \":hideEditInDesktopButton\";\n VqlParameterNames[\"HIGH_DPI\"] = \":highdpi\";\n VqlParameterNames[\"IMAGE_SIZE_LIMIT\"] = \"imageSizeLimit\";\n VqlParameterNames[\"TRANSPARENT_LINE_MARKS_LIMIT\"] = \"transparentLineMarkLimit\";\n VqlParameterNames[\"CLIENT_RENDER_PIXEL_LIMIT\"] = \"clientRenderPixelLimit\";\n VqlParameterNames[\"IN\"] = \"in\";\n VqlParameterNames[\"INSTANCE_ID\"] = \":iid\";\n VqlParameterNames[\"IS_GUEST_REDIRECT_FROM_VIZPORTAL\"] = \":isGuestRedirectFromVizportal\";\n VqlParameterNames[\"IS_MARK_ANIMATION_ENABLED\"] = \"isMarkAnimationEnabled\";\n VqlParameterNames[\"IS_VIZPORTAL\"] = \":isVizPortal\";\n VqlParameterNames[\"INPUT_\"] = \"input_string\";\n VqlParameterNames[\"JSDEBUG\"] = \":jsdebug\";\n VqlParameterNames[\"JSON\"] = \"json\";\n VqlParameterNames[\"JSON_ONLY\"] = \":jsonOnly\";\n VqlParameterNames[\"KEEPFILE\"] = \"keepfile\";\n VqlParameterNames[\"KEY\"] = \"key\";\n VqlParameterNames[\"LANGUAGE\"] = \"language\";\n VqlParameterNames[\"LANGUAGE_REQUESTED\"] = \":language\";\n VqlParameterNames[\"LINKTARGET\"] = \":linktarget\";\n VqlParameterNames[\"LOAD_ORDER_ID\"] = \":loadOrderID\";\n VqlParameterNames[\"LOAD_NEWEST_REVISION\"] = \":loadNewestRevision\";\n VqlParameterNames[\"LOCAL_PATHS\"] = \":localPaths\";\n VqlParameterNames[\"LOCALE\"] = \"locale\";\n VqlParameterNames[\"LOCATION_ID\"] = \"locationid\";\n VqlParameterNames[\"LOCATION_TYPE\"] = \"locationtype\";\n VqlParameterNames[\"WORKBOOK_LOCALE\"] = \"workbookLocale\";\n VqlParameterNames[\"MAXROWS\"] = \"maxrows\";\n VqlParameterNames[\"MAX_AGE\"] = \"maxAge\";\n VqlParameterNames[\"MAX_ROWS\"] = \"maxRows\";\n VqlParameterNames[\"METHOD\"] = \"method\";\n VqlParameterNames[\"MOBILE\"] = \"mobile\";\n VqlParameterNames[\"MODIFIER\"] = \"modifier\";\n VqlParameterNames[\"NAME\"] = \"name\";\n VqlParameterNames[\"NAV_TYPE\"] = \"navType\";\n VqlParameterNames[\"NAV_SRC\"] = \"navSrc\";\n VqlParameterNames[\"NOATTACHMENT\"] = \"no-attachment\";\n VqlParameterNames[\"NO_OVERWRITE\"] = \"no_overwrite\";\n VqlParameterNames[\"OPEN_AUTHORING_IN_TOP_WINDOW\"] = \":openAuthoringInTopWindow\";\n VqlParameterNames[\"OPENID_HD\"] = \":openid_hd\";\n VqlParameterNames[\"OPENID_LOGIN_HINT\"] = \":openid_login_hint\";\n VqlParameterNames[\"OAUTHREQUEST\"] = \"oauthrequest\";\n VqlParameterNames[\"OAUTH_CREDENTIAL_IDS\"] = \"oauth_credential_ids\";\n VqlParameterNames[\"OFFLINE_MODE\"] = \":offlinemode\";\n VqlParameterNames[\"ORIGIN\"] = \":origin\";\n VqlParameterNames[\"OVERLAY\"] = \":overlay\";\n VqlParameterNames[\"P\"] = \"p\";\n VqlParameterNames[\"PATH\"] = \"path\";\n VqlParameterNames[\"PANE_RESOLVER_X\"] = \"paneResolverX\";\n VqlParameterNames[\"PANE_RESOLVER_Y\"] = \"paneResolverY\";\n VqlParameterNames[\"PARAM\"] = \"param\";\n VqlParameterNames[\"PARENT_ID\"] = \"parent_id\";\n VqlParameterNames[\"PASSWORD\"] = \"password\";\n VqlParameterNames[\"PATTERN\"] = \"pattern\";\n VqlParameterNames[\"PIXEL_RATIO\"] = \":pixelratio\";\n VqlParameterNames[\"PREFIX\"] = \":prefix\";\n VqlParameterNames[\"PREVIEW\"] = \":preview\";\n VqlParameterNames[\"PRIMARY_CONTENT_URL\"] = \"primary_content_url\";\n VqlParameterNames[\"PROJECT\"] = \"project\";\n VqlParameterNames[\"PROTOCOL\"] = \"protocol\";\n VqlParameterNames[\"PSEUDO\"] = \":pseudo\";\n VqlParameterNames[\"QUERY\"] = \"query\";\n VqlParameterNames[\"R\"] = \"r\";\n VqlParameterNames[\"RANGE_TYPE\"] = \"range_type\";\n VqlParameterNames[\"RECORD_SEP\"] = \"record_sep\";\n VqlParameterNames[\"RECORD_CLIENT_PERFORMANCE\"] = \":record_client_performance\";\n VqlParameterNames[\"RECORD_PERFORMANCE\"] = \":record_performance\";\n VqlParameterNames[\"RECOVER_OLD_SESSION_ID\"] = \":recover_old_session_id\";\n VqlParameterNames[\"RECOVER_SESSION_STATE_TICKETS\"] = \":recover_session_state_tickets\";\n VqlParameterNames[\"REFRESH\"] = \":refresh\";\n VqlParameterNames[\"REFRESHUNMODIFIED\"] = \":refreshunmodified\";\n VqlParameterNames[\"REGION\"] = \"region\";\n VqlParameterNames[\"RELOAD_ON_CUSTOM_VIEW_SAVE\"] = \":reloadOnCustomViewSave\";\n VqlParameterNames[\"RENDER\"] = \":render\";\n VqlParameterNames[\"RENDER_MAPS_CLIENT_SIDE\"] = \"renderMapsClientSide\";\n VqlParameterNames[\"RETRY\"] = \":retry\";\n VqlParameterNames[\"REUSE\"] = \"reuse\";\n VqlParameterNames[\"REUSE_FOREVER\"] = \"reuse_forever\";\n VqlParameterNames[\"REVERT\"] = \":revert\";\n VqlParameterNames[\"SAVE_DB_PASSWORDS\"] = \"save_db_passwords\";\n VqlParameterNames[\"SELECT_X\"] = \"select_x\";\n VqlParameterNames[\"SELECT_Y\"] = \"select_y\";\n VqlParameterNames[\"SESSION_FEATURE_PREFIX\"] = \":ff_\";\n VqlParameterNames[\"SESSION_FLAGS\"] = \":session_feature_flags\";\n VqlParameterNames[\"SHARE_BUTTON\"] = \"share_button\";\n VqlParameterNames[\"SHEET_ID\"] = \"sheet_id\";\n VqlParameterNames[\"SHARED\"] = \"shared\";\n VqlParameterNames[\"SHOWALL\"] = \"showall\";\n VqlParameterNames[\"SHOW_APP_BANNER\"] = \":showAppBanner\";\n VqlParameterNames[\"SHOW_ASK_DATA\"] = \":showAskData\";\n VqlParameterNames[\"SHOW_PARAMS\"] = \"showParams\";\n VqlParameterNames[\"SHOW_SHARE_OPTIONS\"] = \":showShareOptions\";\n VqlParameterNames[\"SIZE\"] = \":size\";\n VqlParameterNames[\"SOURCE\"] = \"source\";\n VqlParameterNames[\"STATE\"] = \"state\";\n VqlParameterNames[\"STICKY_SESSION_KEY\"] = \"stickySessionKey\";\n VqlParameterNames[\"SUBSCRIPTIONS\"] = \":subscriptions\";\n VqlParameterNames[\"SUMMARY\"] = \"summary\";\n VqlParameterNames[\"SUPPRESS_DEFAULT_EDIT_BEHAVIOR\"] = \":suppressDefaultEditBehavior\";\n VqlParameterNames[\"SYNC_SESSION\"] = \":sync_session\";\n VqlParameterNames[\"SYNC_SESSION_STATE\"] = \"sync_session_state\";\n VqlParameterNames[\"TABS\"] = \":tabs\";\n VqlParameterNames[\"TARGET\"] = \"target\";\n VqlParameterNames[\"TARGET_SITE\"] = \"target_site\";\n VqlParameterNames[\"TOOLBAR\"] = \":toolbar\";\n VqlParameterNames[\"TOOLTIP\"] = \":tooltip\";\n VqlParameterNames[\"TS\"] = \"ts\";\n VqlParameterNames[\"UNDERLYING_TABLE_ID\"] = \"underlying_table_id\";\n VqlParameterNames[\"UNDERLYING_TABLE_CAPTION\"] = \"underlying_table_caption\";\n VqlParameterNames[\"UPDATE_TYPE\"] = \"update_type\";\n VqlParameterNames[\"USE_GUEST\"] = \":useGuest\";\n VqlParameterNames[\"USE_INLINE_IMAGES\"] = \"use_inline_images\";\n VqlParameterNames[\"USERAGENT\"] = \"useragent\";\n VqlParameterNames[\"USERNAME\"] = \"username\";\n VqlParameterNames[\"VALUE\"] = \"value\";\n VqlParameterNames[\"VERBOSE_MODE\"] = \"verboseMode\";\n VqlParameterNames[\"VIEW_ID\"] = \"views_id\";\n VqlParameterNames[\"VIZ_SNAPSHOT_ID\"] = \"viz_snapshot_id\";\n VqlParameterNames[\"VW\"] = \":vw\";\n VqlParameterNames[\"W\"] = \"w\";\n VqlParameterNames[\"WORKSHEET_PORT_SIZE\"] = \"worksheetPortSize\";\n VqlParameterNames[\"WATERMARK\"] = \"watermark\";\n VqlParameterNames[\"WATERMARK_MARGIN\"] = \":watermark_margin\";\n VqlParameterNames[\"WB\"] = \":wb\";\n VqlParameterNames[\"WHICH\"] = \"which\";\n VqlParameterNames[\"X\"] = \"x\";\n VqlParameterNames[\"Y\"] = \"y\";\n VqlParameterNames[\"ZID\"] = \"zid\";\n VqlParameterNames[\"ZONE_ID\"] = \"zone_id\";\n VqlParameterNames[\"KEYCHAIN_VERSION\"] = \"keychain_version\";\n VqlParameterNames[\"DATASOURCE_ID\"] = \"datasource_id\";\n VqlParameterNames[\"DATASOURCE_NAME\"] = \"datasource_name\";\n VqlParameterNames[\"LENS_ID\"] = \"lens_id\";\n VqlParameterNames[\"WIDTH\"] = \"width\";\n VqlParameterNames[\"HEIGHT\"] = \"height\";\n // Default Layout params\n VqlParameterNames[\"LAYOUT_VIEWS\"] = \"views\";\n VqlParameterNames[\"LAYOUT_MENUS\"] = \"menus\";\n VqlParameterNames[\"LAYOUT_GEOMETRY\"] = \"geometry\";\n VqlParameterNames[\"LAYOUT_PAGES\"] = \"pages\";\n VqlParameterNames[\"LAYOUT_CACHEURL\"] = \"cacheurl\";\n VqlParameterNames[\"LAYOUT_SHEET\"] = \"sheet\";\n VqlParameterNames[\"LAYOUT_DEPTH\"] = \"depth\";\n})(VqlParameterNames || (VqlParameterNames = {}));\n/**\n * parameters that are only relevant when working with Tableau Public\n * maybe not really necessry to split them out\n */\nvar PublicParameterNames;\n(function (PublicParameterNames) {\n PublicParameterNames[\"SHOW_VIZ_HOME\"] = \":showVizHome\";\n // display view count\n})(PublicParameterNames || (PublicParameterNames = {}));\n/**\n * Map the parameter names as used in the url to what we call them publicly in the embedding library.\n * The only parameters listed here should be the ones that get sent to vizql\n * - this should match the interface at external-contract:VizInterfaces:VizSettings\n */\nvar VizOptionNames;\n(function (VizOptionNames) {\n // publicName = internalStringValue\n VizOptionNames[\"Size\"] = \":size\";\n VizOptionNames[\"Embed\"] = \":embed\";\n VizOptionNames[\"ApiInternalVersion\"] = \":apiInternalVersion\";\n VizOptionNames[\"ApiExternalVersion\"] = \":apiExternalVersion\";\n VizOptionNames[\"ShowVizHome\"] = \":showVizHome\";\n VizOptionNames[\"Jsdebug\"] = \":jsdebug\";\n VizOptionNames[\"BootstrapWhenNotified\"] = \":bootstrapWhenNotified\";\n VizOptionNames[\"NavType\"] = \"navType\";\n VizOptionNames[\"NavSrc\"] = \"navSrc\";\n VizOptionNames[\"debug\"] = \":jsdebug\";\n VizOptionNames[\"ApiID\"] = \":apiID\";\n VizOptionNames[\"disableUrlActionsPopups\"] = \":disableUrlActionsPopups\";\n VizOptionNames[\"hideTabs\"] = \":tabs\";\n VizOptionNames[\"toolbar\"] = \":toolbar\";\n VizOptionNames[\"device\"] = \":device\";\n VizOptionNames[\"instanceIdToClone\"] = \":iid\";\n VizOptionNames[\"touchOptimize\"] = \"mobile\";\n VizOptionNames[\"hideEditButton\"] = \":hideEditButton\";\n VizOptionNames[\"hideEditInDesktopButton\"] = \":hideEditInDesktopButton\";\n VizOptionNames[\"suppressDefaultEditBehavior\"] = \":suppressDefaultEditBehavior\";\n VizOptionNames[\"hideCloseButton\"] = \":hideCloseButton\";\n})(VizOptionNames = exports.VizOptionNames || (exports.VizOptionNames = {}));\n//# sourceMappingURL=VqlInterface.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar guid = require(\"guid\");\nvar JsApiInternalContract_1 = require(\"../JsApiInternalContract\");\nvar CrossFramePreparedMessage_1 = require(\"./CrossFramePreparedMessage\");\nvar MessageTypeChecks_1 = require(\"./MessageTypeChecks\");\nvar MessageTypes_1 = require(\"./interface/MessageTypes\");\n/**\n * The CrossFrameMessenger is the primary export from the api-messaging module. An instance of\n * this class can be instantiated on both sides of a frame boundary to facilitate communication\n * in both directions between the frames. This class implements both the dispatcher and the listener\n * portions, but doesn't require callers to care about both.\n */\nvar CrossFrameMessenger = /** @class */ (function () {\n /**\n * Creates an instance of CrossFrameMessenger. If you would like to use the CrossFrameMessenger as a MessageListener,\n * be sure to call StartListening and register message handlers.\n * @param thisWindow The window object which the CrossFrameMessenger lives. An onMessage listener will be added here.\n * @param [otherWindow] Optional otherWindow which messages will be posted to.\n * If defined, incoming messages must originate from otherWindow to be passed on\n * @param [otherWindowOrigin] The target origin which otherWindow must have in order to receive dispatched messages.\n * This value will be sent as the targetOrigin of a postMessage\n * (https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage)\n */\n function CrossFrameMessenger(thisWindow, otherWindow, otherWindowOrigin) {\n this.thisWindow = thisWindow;\n this.otherWindow = otherWindow;\n this.otherWindowOrigin = otherWindowOrigin;\n // Make sure to call StartListening\n }\n ///// MessageListener Implementation\n CrossFrameMessenger.prototype.startListening = function () {\n var _this = this;\n // Check if we already are listening, if not, hook up a message listener\n if (!this.unregisterFunction) {\n var boundHandler_1 = this.onMessageReceived.bind(this);\n this.thisWindow.addEventListener('message', boundHandler_1, true);\n this.unregisterFunction = function () { return _this.thisWindow.removeEventListener('message', boundHandler_1, true); };\n }\n };\n CrossFrameMessenger.prototype.stopListening = function () {\n // Stop listening if we have started listening\n if (this.unregisterFunction) {\n this.unregisterFunction();\n this.unregisterFunction = undefined;\n }\n };\n CrossFrameMessenger.prototype.setInitializeMessageHandler = function (handler) {\n this.initializeMessageHandler = handler;\n };\n CrossFrameMessenger.prototype.setCommandResponseMessageHandler = function (handler) {\n this.commandResponseMessageHandler = handler;\n };\n CrossFrameMessenger.prototype.setCommandMessageHandler = function (handler) {\n this.commandMessageHandler = handler;\n };\n CrossFrameMessenger.prototype.setNotificationMessageHandler = function (handler) {\n this.notificationMessageHandler = handler;\n };\n CrossFrameMessenger.prototype.setHandshakeMessageHandler = function (handler) {\n this.handshakeMessageHandler = handler;\n };\n ///// MessageDispatcher Implementation\n /**\n * @param apiVersion api-internal-contract-js version (exported in JsApiInternalConntract)\n * @param crossFrameVersion crossframe messaging version (exported in JsApiInternalConntract)\n * @param options additional options that can be passed at initialization (information about the version of\n * external being used for example)\n */\n CrossFrameMessenger.prototype.prepareInitializationMessage = function (apiVersion, crossFrameVersion, options) {\n var message = {\n msgGuid: guid.raw(),\n msgType: MessageTypes_1.MessageType.Initialize,\n crossFrameVersion: crossFrameVersion,\n apiVersion: apiVersion,\n options: options,\n };\n return this.prepareMessage(message);\n };\n CrossFrameMessenger.prototype.prepareCommandMessage = function (verbId, parameters) {\n var message = {\n msgGuid: guid.raw(),\n msgType: MessageTypes_1.MessageType.Command,\n verbId: verbId,\n parameters: parameters,\n };\n return this.prepareMessage(message);\n };\n CrossFrameMessenger.prototype.prepareCommandResponseMessage = function (commandGuid, data, error) {\n var message = {\n msgGuid: guid.raw(),\n msgType: MessageTypes_1.MessageType.CommandResponse,\n commandGuid: commandGuid,\n data: data,\n error: error,\n };\n if (error) {\n // stringify error object to remove unserializable fields like functions and prevent serialization errors\n message.error = JSON.parse(JSON.stringify(error));\n }\n return this.prepareMessage(message);\n };\n CrossFrameMessenger.prototype.prepareNotificationMessage = function (notificationId, data) {\n var message = {\n msgGuid: guid.raw(),\n msgType: MessageTypes_1.MessageType.Notification,\n notificationId: notificationId,\n data: data,\n };\n return this.prepareMessage(message);\n };\n CrossFrameMessenger.prototype.prepareAckMessage = function () {\n var message = {\n msgGuid: guid.raw(),\n msgType: MessageTypes_1.MessageType.Ack,\n platformVersion: JsApiInternalContract_1.INTERNAL_CONTRACT_VERSION,\n };\n return this.prepareMessage(message);\n };\n /**\n * Prepares a pending message for sending and returns the prepared message\n *\n * @param msg The message to be sent to this.otherWindow\n * @returns The prepared message\n */\n CrossFrameMessenger.prototype.prepareMessage = function (msg) {\n if (!this.otherWindow || !this.otherWindowOrigin) {\n throw 'Other window not initialized, cannot dispatch messages';\n }\n var preparedMessage = new CrossFramePreparedMessage_1.CrossFramePreparedMessage(msg, this.otherWindow, this.otherWindowOrigin);\n return preparedMessage;\n };\n /**\n * Called when a message is received. Does some validation of the message, and then\n * calls an appropriate message handler if one is defined\n *\n * @param event The incoming MessageEvent\n */\n CrossFrameMessenger.prototype.onMessageReceived = function (event) {\n // If we have an otherWindow defined, make sure the message is coming from there\n if (this.otherWindow && event.source !== this.otherWindow) {\n return;\n }\n // Do some validation on event.data to make sure that we have received a real message\n if (!event.data) {\n return;\n }\n var message = event.data;\n if (!MessageTypeChecks_1.isMessage(message)) {\n return;\n }\n // Check the declared message type, validate the message, and call an appropriate hander if one exists\n switch (message.msgType) {\n case MessageTypes_1.MessageType.Initialize: {\n if (!MessageTypeChecks_1.isInitMessage(message) || !this.initializeMessageHandler) {\n return;\n }\n this.initializeMessageHandler(message, event.source);\n break;\n }\n case MessageTypes_1.MessageType.CommandResponse: {\n if (!MessageTypeChecks_1.isCommandResponseMessage(message) || !this.commandResponseMessageHandler) {\n return;\n }\n this.commandResponseMessageHandler(message, event.source);\n break;\n }\n case MessageTypes_1.MessageType.Command: {\n if (!MessageTypeChecks_1.isCommandMessage(message) || !this.commandMessageHandler) {\n return;\n }\n this.commandMessageHandler(message, event.source);\n break;\n }\n case MessageTypes_1.MessageType.Notification: {\n if (!MessageTypeChecks_1.isNotificationMessage(message) || !this.notificationMessageHandler) {\n return;\n }\n this.notificationMessageHandler(message, event.source);\n break;\n }\n case MessageTypes_1.MessageType.Handshake: {\n if (!MessageTypeChecks_1.isHandshakeMessage(message) || !this.handshakeMessageHandler) {\n return;\n }\n this.handshakeMessageHandler(message, event.source);\n break;\n }\n default:\n // Just ignore this since we don't know how to handle the message type\n }\n };\n CrossFrameMessenger.prototype.setOtherWindow = function (otherWindow) {\n this.otherWindow = otherWindow;\n };\n CrossFrameMessenger.prototype.setOtherWindowOrigin = function (origin) {\n this.otherWindowOrigin = origin;\n };\n return CrossFrameMessenger;\n}());\nexports.CrossFrameMessenger = CrossFrameMessenger;\n//# sourceMappingURL=CrossFrameMessenger.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Implementation of the PreparedMessage interface used to post messages between\n * two frames using window.postMessage\n */\nvar CrossFramePreparedMessage = /** @class */ (function () {\n /**\n * Creates an instance of CrossFramePreparedMessage.\n * @param _message The message to be sent\n * @param _target The target window where the message will be sent\n * @param _origin The targetOrigin where this message can be received\n */\n function CrossFramePreparedMessage(_message, _target, _origin) {\n this._message = _message;\n this._target = _target;\n this._origin = _origin;\n }\n Object.defineProperty(CrossFramePreparedMessage.prototype, \"messageGuid\", {\n get: function () {\n return this._message.msgGuid;\n },\n enumerable: true,\n configurable: true\n });\n CrossFramePreparedMessage.prototype.send = function () {\n this._target.postMessage(this._message, this._origin);\n return this;\n };\n return CrossFramePreparedMessage;\n}());\nexports.CrossFramePreparedMessage = CrossFramePreparedMessage;\n//# sourceMappingURL=CrossFramePreparedMessage.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar guid = require(\"guid\");\nvar Notifications_1 = require(\"../contract/Notifications\");\nvar MessageTypes_1 = require(\"./interface/MessageTypes\");\nvar expectedEmptyNotifications = new Set([\n Notifications_1.NotificationId.EditButtonClicked,\n Notifications_1.NotificationId.EditInDesktopButtonClicked,\n Notifications_1.NotificationId.WorkbookPublished,\n Notifications_1.NotificationId.WorkbookReadyToClose,\n Notifications_1.NotificationId.ReadyToReceiveAuthToken,\n]);\n/* tslint:disable no-any */\nfunction isMessage(data) {\n if (!data) {\n return false;\n }\n var message = data;\n if (!message || !message.msgGuid || !message.msgType) {\n return false;\n }\n if (!guid.isGuid(message.msgGuid)) {\n return false;\n }\n if (typeof message.msgType !== 'string') {\n return false;\n }\n var messageTypes = [\n MessageTypes_1.MessageType.Command,\n MessageTypes_1.MessageType.CommandResponse,\n MessageTypes_1.MessageType.Initialize,\n MessageTypes_1.MessageType.Notification,\n MessageTypes_1.MessageType.Handshake,\n ];\n if (messageTypes.indexOf(message.msgType) < 0) {\n return false;\n }\n return true;\n}\nexports.isMessage = isMessage;\nfunction isVersion(versionNumber) {\n if (!versionNumber) {\n return false;\n }\n var v = versionNumber;\n if (typeof v !== 'object') {\n return false;\n }\n if (typeof v.fix !== 'number' || typeof v.minor !== 'number' || typeof v.major !== 'number') {\n return false;\n }\n return true;\n}\nexports.isVersion = isVersion;\nfunction isInitMessage(message) {\n if (!isMessage(message)) {\n return false;\n }\n var initMessage = message;\n if (initMessage.msgType !== MessageTypes_1.MessageType.Initialize) {\n return false;\n }\n if (!initMessage.apiVersion || !isVersion(initMessage.apiVersion)) {\n return false;\n }\n if (!initMessage.crossFrameVersion || !isVersion(initMessage.crossFrameVersion)) {\n return false;\n }\n return true;\n}\nexports.isInitMessage = isInitMessage;\nfunction isCommandResponseMessage(message) {\n if (!isMessage(message)) {\n return false;\n }\n var crMessage = message;\n if (crMessage.msgType !== MessageTypes_1.MessageType.CommandResponse) {\n return false;\n }\n if (!guid.isGuid(crMessage.commandGuid)) {\n return false;\n }\n if (!crMessage.data && !crMessage.error) {\n return false;\n }\n return true;\n}\nexports.isCommandResponseMessage = isCommandResponseMessage;\nfunction isCommandMessage(message) {\n if (!isMessage(message)) {\n return false;\n }\n var commandMessage = message;\n if (commandMessage.msgType !== MessageTypes_1.MessageType.Command) {\n return false;\n }\n if (!commandMessage.parameters || typeof commandMessage.parameters !== 'object') {\n return false;\n }\n if (!commandMessage.verbId || typeof commandMessage.verbId !== 'string') {\n return false;\n }\n return true;\n}\nexports.isCommandMessage = isCommandMessage;\nfunction isNotificationMessage(message) {\n if (!isMessage(message)) {\n return false;\n }\n var notificationMessage = message;\n if (notificationMessage.msgType !== MessageTypes_1.MessageType.Notification) {\n return false;\n }\n if (!notificationMessage.data && !expectedEmptyNotifications.has(notificationMessage.notificationId)) {\n return false;\n }\n if (!notificationMessage.notificationId || typeof notificationMessage.notificationId !== 'string') {\n return false;\n }\n return true;\n}\nexports.isNotificationMessage = isNotificationMessage;\nfunction isHandshakeMessage(message) {\n if (!isMessage(message)) {\n return false;\n }\n var handshakeMessage = message;\n if (handshakeMessage.msgType !== MessageTypes_1.MessageType.Handshake) {\n return false;\n }\n return true;\n}\nexports.isHandshakeMessage = isHandshakeMessage;\n//# sourceMappingURL=MessageTypeChecks.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Enum defining the 4 different types of messages we have defined\n */\nvar MessageType;\n(function (MessageType) {\n MessageType[\"Initialize\"] = \"initialize\";\n MessageType[\"Notification\"] = \"notification\";\n MessageType[\"Command\"] = \"command\";\n MessageType[\"CommandResponse\"] = \"command-response\";\n MessageType[\"Handshake\"] = \"v-handshake\";\n MessageType[\"Ack\"] = \"v-ack\";\n})(MessageType = exports.MessageType || (exports.MessageType = {}));\n//# sourceMappingURL=MessageTypes.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// tslint:disable:no-any\n/**\n * This version converter doesn't actually do anything but is useful for testing or when we have\n * a matching platform and internal version number\n */\nvar IdentityVersionConverter = /** @class */ (function () {\n function IdentityVersionConverter() {\n }\n IdentityVersionConverter.prototype.upgradeExecuteCall = function (verb, parameters) {\n return {\n verb: verb,\n parameters: parameters,\n };\n };\n IdentityVersionConverter.prototype.downgradeExecuteReturn = function (executeResponse) {\n return executeResponse;\n };\n IdentityVersionConverter.prototype.downgradeNotification = function (notification) {\n return notification;\n };\n return IdentityVersionConverter;\n}());\nexports.IdentityVersionConverter = IdentityVersionConverter;\n//# sourceMappingURL=IdentityVersionConverter.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// tslint:disable:no-any\n/**\n * The version converter is designed to allow the platform and external modules\n * to seemlessly communicate over two different versions of the internal API. The only\n * mode it supports is external's version <= platform's version. When executing\n * commands, it is used to upgrade the external representation to what platform knows on the way in\n * and downgrade the representations on the way out. Similarly for notifications, it can\n * downgrade those on the way from platform to external.\n */\nvar StackingVersionConverter = /** @class */ (function () {\n /**\n * Creates a new instance of the StackingVersionConverter\n *\n * @param _externalMajorVersion The major version of the internal contract api-external-js is using\n * @param _platformMajorVersion The major version of the internal contract the api-platform-js is using\n * @param _upgradeExecuteTranslations Ordered list of the translations to perform when upgrading cmd parameters\n * @param _downgradeExecuteTranslations Ordered list of downgrade translations to perform after a cmd\n * @param _downgradeNotificationTranslations Ordered list of downgrade translations to perform on a notification\n */\n function StackingVersionConverter(_externalMajorVersion, _platformMajorVersion, _upgradeExecuteTranslations, _downgradeExecuteTranslations, _downgradeNotificationTranslations) {\n this._externalMajorVersion = _externalMajorVersion;\n this._platformMajorVersion = _platformMajorVersion;\n this._upgradeExecuteTranslations = _upgradeExecuteTranslations;\n this._downgradeExecuteTranslations = _downgradeExecuteTranslations;\n this._downgradeNotificationTranslations = _downgradeNotificationTranslations;\n if (this._externalMajorVersion > this._platformMajorVersion) {\n throw new Error(\"Cannot convert between external version \" + this._externalMajorVersion + \" and \" + this._platformMajorVersion);\n }\n }\n /**\n * Creates a new instance of the StackingVersionConverter\n *\n * @param _externalVersion The version of the internal contract api-external-js is using\n * @param _platformVersion The version of the internal contract the api-platform-js is using\n * @param _upgradeExecuteTranslations Ordered list of the translations to perform when upgrading cmd parameters\n * @param _downgradeExecuteTranslations Ordered list of downgrade translations to perform after a cmd\n * @param _downgradeNotificationTranslations Ordered list of downgrade translations to perform on a notification\n */\n StackingVersionConverter.fromData = function (externalVersion, platformVersion, upgradeExecuteTranslations, downgradeExecuteTranslations, downgradeNotificationTranslations) {\n return new this(externalVersion.major, platformVersion.major, upgradeExecuteTranslations, downgradeExecuteTranslations, downgradeNotificationTranslations);\n };\n StackingVersionConverter.prototype.upgradeExecuteCall = function (verb, parameters) {\n // Perform the upgrade of the verb and parameters to the level that platform is using\n var upgraded = { verb: verb, parameters: parameters };\n for (var _i = 0, _a = this._upgradeExecuteTranslations; _i < _a.length; _i++) {\n var upgradeTranslation = _a[_i];\n upgraded = upgradeTranslation(upgraded.verb, upgraded.parameters);\n }\n return upgraded;\n };\n StackingVersionConverter.prototype.downgradeExecuteReturn = function (executeResponse) {\n // Downgrade the response to what the external module is expecting\n var downgraded = executeResponse;\n for (var _i = 0, _a = this._downgradeExecuteTranslations; _i < _a.length; _i++) {\n var downgradeTranslation = _a[_i];\n downgraded = downgradeTranslation(downgraded);\n }\n return downgraded;\n };\n StackingVersionConverter.prototype.downgradeNotification = function (notification) {\n // Downgrade the notification to what the external module is expecting\n var downgraded = notification;\n for (var _i = 0, _a = this._downgradeNotificationTranslations; _i < _a.length; _i++) {\n var downgradeTranslation = _a[_i];\n downgraded = downgradeTranslation(downgraded);\n }\n return downgraded;\n };\n return StackingVersionConverter;\n}());\nexports.StackingVersionConverter = StackingVersionConverter;\n//# sourceMappingURL=StackingVersionConverter.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar IdentityVersionConverter_1 = require(\"./IdentityVersionConverter\");\nvar StackingVersionConverter_1 = require(\"./StackingVersionConverter\");\nvar VersionTranslations_1 = require(\"./VersionTranslations\");\n/**\n * @returns true if lhs < rhs (ignoring fix number)\n * @param lhs\n * @param rhs\n */\nfunction VersionLessThan(lhs, rhs) {\n if (lhs.major > rhs.major) {\n return false;\n }\n if (lhs.major < rhs.major) {\n return true;\n }\n return lhs.minor < rhs.minor;\n}\nexports.VersionLessThan = VersionLessThan;\n/**\n * @returns true if lhs == rhs (ignoring fix number)\n * @param lhs\n * @param rhs\n */\nfunction VersionEqualTo(lhs, rhs) {\n return lhs.major === rhs.major && lhs.minor === rhs.minor;\n}\nexports.VersionEqualTo = VersionEqualTo;\n// A mapping from an older client version of internal-contract to the current platform version of this contract.\n// Each version bump can have an array of translations to perform in order. Notice that this is\n// different than the major upgrades/downgrades above because it handles both major and minor version changes.\n// Also please note: downgradeExecuteCall is handled on the client/external side rather than platform side.\n// When updating the major or minor version of our internal-contract, you will need to update these data structures.\n// * If there are translations to add, add them to the version to \"upgrade from\" or \"downgrade to\".\nexports.ExecuteMinorUpgrades = {\n 1: {\n 9: [],\n },\n};\nexports.ExecuteMinorDowngrades = {\n 1: {\n 5: [VersionTranslations_1.DowngradeWorksheetNames],\n 9: [],\n },\n};\nexports.NotificationMinorDowngrades = {\n 1: {\n 9: [],\n 10: [VersionTranslations_1.DowngradeFlipboardZoneID],\n },\n};\n/**\n * Creates a new InternalContractVersionConverter which has the ability to upgrade and downgrade the contract\n * between the two versions, which are specified. If externalMajorVersion is greater than platformMajorVersion,\n * an error will be thrown because we won't know how to do those conversions.\n * This converter can handle both major and minor updates when the platform version is greater than external version.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n */\nfunction CreateVersionConverter(externalVersion, platformVersion) {\n return CreateVersionConverterWithTranslators(externalVersion, platformVersion, exports.ExecuteMinorUpgrades, exports.ExecuteMinorDowngrades, exports.NotificationMinorDowngrades);\n}\nexports.CreateVersionConverter = CreateVersionConverter;\n/**\n * Implementation of CreateVersionConverter. This function takes the upgrade, downgrade, and\n * notification arrays so that all the logic can be tested.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n * @param upgrades MajorMinorTranslators for upgrades\n * @param downgrades MajorMinorTranslators for downgrades\n * @param notificationDowngrades MajorMinorTranslators for notification downgrades\n */\nfunction CreateVersionConverterWithTranslators(externalVersion, platformVersion, upgrades, downgrades, notificationDowngrades) {\n var externalMajorVersion = externalVersion.major;\n var externalMinorVersion = externalVersion.minor;\n var platformMajorVersion = platformVersion.major;\n if (externalMajorVersion > platformMajorVersion) {\n throw new Error(\"External version must be less than or equal to platform version.\\n externalMajorVersion=\" + externalMajorVersion + \" platformMajorVersion=\" + platformMajorVersion);\n }\n // If we are using the exact same versions (major.minor), just use the identity converter\n if (VersionEqualTo(externalVersion, platformVersion)) {\n return new IdentityVersionConverter_1.IdentityVersionConverter();\n }\n // Walk the span between the versions we have here and collect the upgrade and downgrades necessary\n var neededExecuteUpgrades = GetNeededTranslations(externalMajorVersion, platformMajorVersion, externalMinorVersion, upgrades);\n var neededExecuteDowngrades = GetNeededTranslations(externalMajorVersion, platformMajorVersion, externalMinorVersion, downgrades);\n var neededNotificationDowngrades = GetNeededTranslations(externalMajorVersion, platformMajorVersion, externalMinorVersion, notificationDowngrades);\n // We want to apply the downgrades in reverse order in case of dependencies between them\n neededExecuteDowngrades.reverse();\n neededNotificationDowngrades.reverse();\n return StackingVersionConverter_1.StackingVersionConverter.fromData(externalVersion, platformVersion, neededExecuteUpgrades, neededExecuteDowngrades, neededNotificationDowngrades);\n}\nexports.CreateVersionConverterWithTranslators = CreateVersionConverterWithTranslators;\nfunction GetNeededTranslations(externalMajorVersion, platformMajorVersion, externalMinorVersion, majorMinorTranslators) {\n var neededTranslations = [];\n for (var major = externalMajorVersion; major <= platformMajorVersion; major++) {\n if (major in majorMinorTranslators) {\n var start = major === externalMajorVersion ? externalMinorVersion : 0;\n var maximumMinorVersion = GetMaximumMinorIndex(Object.keys(majorMinorTranslators[major]));\n for (var minor = start; minor <= maximumMinorVersion; minor++) {\n if (minor in majorMinorTranslators[major]) {\n neededTranslations.push.apply(neededTranslations, majorMinorTranslators[major][minor]);\n }\n }\n }\n }\n return neededTranslations;\n}\nfunction GetMaximumMinorIndex(minorVersions) {\n return minorVersions.map(function (a) { return Number(a); }).reduce(function (a, b) { return (a > b ? a : b); });\n}\nexports.GetMaximumMinorIndex = GetMaximumMinorIndex;\n//# sourceMappingURL=VersionConverterFactory.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Notifications_1 = require(\"../contract/Notifications\");\n// This is where we will start to define some of these translations.\n// When modifying existing models, add the requisite conversion functions here, then use them\n// in the VersionConverterFactory implementation. Import old versions as you would any other module\n// 0 <-> Translations\n// Uncomment this line to import from the V0 definition of the API\n// import * as V0 from '@tableau-api-internal-contract-js_v0';\n// 1 <-> 2 Translations\n// Uncomment this line to import from the V1 definition of the API\n// import * as V1 from '@tableau-api-internal-contract-js_v1';\nfunction DowngradeWorksheetNames(executeResponse) {\n // Fix the dashboard friendly name issue. The structures are compatible,\n // so we still return the original reply, but we copy the SheetInfo.name\n // into the DashboardZone.name, where v1 wants to find it.\n var bootstrapInfo = executeResponse.result;\n if (bootstrapInfo.extensionDashboardInfo !== undefined) {\n bootstrapInfo.extensionDashboardInfo.zones.forEach(function (zone) {\n if (zone.sheetInfo) {\n zone.name = zone.sheetInfo.name;\n }\n });\n }\n return executeResponse;\n}\nexports.DowngradeWorksheetNames = DowngradeWorksheetNames;\nfunction DowngradeFlipboardZoneID(notification) {\n // Fix the FlipboardZoneId issue. Older external versions still check for flipboardZoneIDs.\n // When running against a newer server, if flipboardZoneId is absent, set it to default(0).\n if (notification.notificationId === Notifications_1.NotificationId.SelectedMarksChanged) {\n var visualModel = notification.data;\n if (visualModel.flipboardZoneID === undefined) {\n visualModel.flipboardZoneID = 0;\n }\n }\n return notification;\n}\nexports.DowngradeFlipboardZoneID = DowngradeFlipboardZoneID;\n//# sourceMappingURL=VersionTranslations.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// tslint:disable:no-any\n/**\n * This version converter doesn't actually do anything but is useful for testing or when we have\n * a matching platform and external version number\n */\nvar ExternalIdentityVersionConverter = /** @class */ (function () {\n function ExternalIdentityVersionConverter() {\n }\n ExternalIdentityVersionConverter.prototype.downgradeExecuteCall = function (verb, parameters) {\n return {\n verb: verb,\n parameters: parameters,\n };\n };\n ExternalIdentityVersionConverter.prototype.upgradeExecuteReturn = function (executeResponse, verb, parameters) {\n return executeResponse;\n };\n ExternalIdentityVersionConverter.prototype.upgradeNotification = function (notification) {\n return notification;\n };\n return ExternalIdentityVersionConverter;\n}());\nexports.ExternalIdentityVersionConverter = ExternalIdentityVersionConverter;\n//# sourceMappingURL=ExternalIdentityVersionConverter.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// tslint:disable:no-any\n/**\n * The version converter is designed to allow the platform and external modules\n * to seemlessly communicate over two different versions of the internal API. This converter\n * supports external's version(minor) >= platform's version(minor). When executing\n * commands, it is used to downgrade the external representation to what platform knows on the way in\n * and upgrade the representations on the way out.\n */\nvar ExternalStackingVersionConverter = /** @class */ (function () {\n /**\n * Creates a new instance of the StackingVersionConverter\n *\n * @param _externalVersion The version of the internal contract api-external-js is using\n * @param _platformVersion The version of the internal contract the api-platform-js is using\n * @param _downgradeExecuteCallTranslations Ordered list of the translations to perform when downgrading cmd parameters\n * @param _upgradeExecuteReturnTranslations Ordered list of upgrade translations to perform after a cmd is executed\n * @param _upgradeNotificationTranslations Ordered list of upgrade notfications to perform on events\n */\n function ExternalStackingVersionConverter(_externalVersion, _platformVersion, _downgradeExecuteCallTranslations, _upgradeExecuteReturnTranslations, _upgradeNotificationTranslations) {\n this._externalVersion = _externalVersion;\n this._platformVersion = _platformVersion;\n this._downgradeExecuteCallTranslations = _downgradeExecuteCallTranslations;\n this._upgradeExecuteReturnTranslations = _upgradeExecuteReturnTranslations;\n this._upgradeNotificationTranslations = _upgradeNotificationTranslations;\n if (this._externalVersion.major > this._platformVersion.major) {\n throw new Error(\"Cannot convert between external version \" + this._externalVersion.major + \"\\n and \" + this._platformVersion.major);\n }\n }\n ExternalStackingVersionConverter.prototype.downgradeExecuteCall = function (verb, parameters) {\n // Perform the downgrade of the verb and parameters to the level that platform is using\n var downgraded = { verb: verb, parameters: parameters };\n for (var _i = 0, _a = this._downgradeExecuteCallTranslations; _i < _a.length; _i++) {\n var downgradeTranslation = _a[_i];\n downgraded = downgradeTranslation(downgraded.verb, downgraded.parameters);\n }\n return downgraded;\n };\n ExternalStackingVersionConverter.prototype.upgradeExecuteReturn = function (executeResponse, verb, parameters) {\n // Perform the upgrade of the response to what the external module is expecting\n var upgraded = executeResponse;\n for (var _i = 0, _a = this._upgradeExecuteReturnTranslations; _i < _a.length; _i++) {\n var upgradeTranslation = _a[_i];\n upgraded = upgradeTranslation(upgraded, verb, parameters);\n }\n return upgraded;\n };\n ExternalStackingVersionConverter.prototype.upgradeNotification = function (notification) {\n // Perform the upgrade of notification to what the external module is expecting\n var upgraded = notification;\n for (var _i = 0, _a = this._upgradeNotificationTranslations; _i < _a.length; _i++) {\n var upgradeNotification = _a[_i];\n upgraded = upgradeNotification(upgraded);\n }\n return upgraded;\n };\n return ExternalStackingVersionConverter;\n}());\nexports.ExternalStackingVersionConverter = ExternalStackingVersionConverter;\n//# sourceMappingURL=ExternalStackingVersionConverter.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar VersionConverterFactory_1 = require(\"../VersionConverterFactory\");\nvar ExternalIdentityVersionConverter_1 = require(\"./ExternalIdentityVersionConverter\");\nvar ExternalStackingVersionConverter_1 = require(\"./ExternalStackingVersionConverter\");\nvar ExternalVersionTranslations_1 = require(\"./ExternalVersionTranslations\");\n// A mapping from the current client version of internal-contract to an older platform version of the contract.\n// Each version bump can have an array of translations to perform in order.\n// These translations handle downgradeExecuteCall and upgradeExecuteReturn and are meant to be called on the\n// client/external side.\n// When updating the major or minor version of our internal-contract, you will need to update these data structures.\n// * If there are translations to add, add them to the version to 'upgrade from' or 'downgrade to'.\nexports.ExecuteMinorDowngradeCallExternal = {\n 1: {\n 9: [],\n 13: [ExternalVersionTranslations_1.DowngradeUnderlyingTableDataAsync, ExternalVersionTranslations_1.DowngradeLogicalTableDataAsync],\n },\n};\nexports.ExecuteMinorUpgradeReturnExternal = {\n 1: {\n 9: [ExternalVersionTranslations_1.UpgradeDataTableTypes],\n 29: [ExternalVersionTranslations_1.UpgradeDataTableRowsAndColumns],\n },\n};\nexports.ExecuteMinorUpgradeNotification = {\n 1: {\n 9: [],\n },\n};\n/**\n * Creates a new ExternalContractVersionConverter which has the ability to upgrade and downgrade\n * the contract between the two versions which are specified. If externalMajorVersion is less than\n * platformMajorVersion, an ExternalIdentityVersionConverter will be returned.\n * Handles upgrade/downgrade for both major and minor updates.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n */\nfunction CreateExternalCompatibleVersionConverter(externalVersion, platformVersion) {\n return CreateExternalCompatibleVersionConverterWithTranslators(externalVersion, platformVersion, exports.ExecuteMinorDowngradeCallExternal, exports.ExecuteMinorUpgradeReturnExternal, exports.ExecuteMinorUpgradeNotification);\n}\nexports.CreateExternalCompatibleVersionConverter = CreateExternalCompatibleVersionConverter;\n/**\n * Implementation of CreateExternalCompatibleVersionConverterWithTranslators.\n * This function takes the upgrade, downgrade arrays so that all the logic can be tested.\n *\n * @param externalVersion VersionNumber of the internal contract which the external module is using\n * @param platformVersion VersionNumber of the internal contract which the platform is using\n * @param upgrades MajorMinorTranslators for response upgrades\n * @param downgrades MajorMinorTranslators for execute call downgrades\n */\nfunction CreateExternalCompatibleVersionConverterWithTranslators(externalVersion, platformVersion, downgrades, upgrades, upgradeNotifications) {\n var externalMajorVersion = externalVersion.major;\n var platformMajorVersion = platformVersion.major;\n var platformMinorVersion = platformVersion.minor;\n // This check is present in VersionConverterFactory. We throw the same error here as well.\n // Hence we only need to check the minor versions for translations.\n if (externalMajorVersion > platformMajorVersion) {\n throw new Error(\"External version must be less than or equal to platform version.\\n externalMajorVersion=\" + externalMajorVersion + \" platformMajorVersion=\" + platformMajorVersion);\n }\n if (externalMajorVersion < platformMajorVersion || VersionConverterFactory_1.VersionEqualTo(externalVersion, platformVersion)) {\n return new ExternalIdentityVersionConverter_1.ExternalIdentityVersionConverter();\n }\n // Walk the span between the versions we have here and collect the upgrade and downgrades necessary\n var neededExecuteCallDowngrade = GetNeededExternalTranslations(platformMajorVersion, platformMinorVersion, downgrades);\n var neededExecuteReturnUpgrades = GetNeededExternalTranslations(platformMajorVersion, platformMinorVersion, upgrades);\n var neededNotificationUpgrades = GetNeededExternalTranslations(platformMajorVersion, platformMinorVersion, upgradeNotifications);\n // Reverse the downgrade calls, so that we start the downgrade from the external version to the platform version\n neededExecuteCallDowngrade.reverse();\n return new ExternalStackingVersionConverter_1.ExternalStackingVersionConverter(externalVersion, platformVersion, neededExecuteCallDowngrade, neededExecuteReturnUpgrades, neededNotificationUpgrades);\n}\nexports.CreateExternalCompatibleVersionConverterWithTranslators = CreateExternalCompatibleVersionConverterWithTranslators;\nfunction GetNeededExternalTranslations(platformMajorVersion, platformMinorVersion, majorMinorTranslators) {\n var neededTranslations = [];\n if (platformMajorVersion in majorMinorTranslators) {\n var start = platformMinorVersion;\n var maximumMinorVersion = VersionConverterFactory_1.GetMaximumMinorIndex(Object.keys(majorMinorTranslators[platformMajorVersion]));\n for (var minor = start; minor <= maximumMinorVersion; minor++) {\n if (minor in majorMinorTranslators[platformMajorVersion]) {\n neededTranslations.push.apply(neededTranslations, majorMinorTranslators[platformMajorVersion][minor]);\n }\n }\n }\n return neededTranslations;\n}\n//# sourceMappingURL=ExternalVersionConverterFactory.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar JsApiInternalContract_1 = require(\"../../JsApiInternalContract\");\n// 1.2 -> 1.0 Translations\n// Uncomment this line to import from the V1 definition of the API\n// import * as V1 from '@tableau-api-internal-contract-js_v1';\n/**\n * Prior to 2019.2 (internal-contract v1.9), DataValue.value were all strings.\n * Go through all DataValue objects. If we have a string, but the type should not be a string,\n * convert it to the correct type. The type of DataValue.value is 'any' in the contract, so\n * this change doesn't need any updates to classes or types.\n */\nfunction UpgradeDataTableTypes(executeResponse, verb, parameters) {\n if (!executeResponse) {\n return executeResponse;\n }\n var oldUnderlyingDataTable = executeResponse.result;\n if (oldUnderlyingDataTable.data !== undefined && oldUnderlyingDataTable.isSummary !== undefined) {\n convertDataValues(oldUnderlyingDataTable.data);\n return executeResponse;\n }\n var oldSelectedMarksTable = executeResponse.result;\n if (oldSelectedMarksTable.data !== undefined && Array.isArray(oldSelectedMarksTable.data)) {\n oldSelectedMarksTable.data.forEach(function (marksTable) {\n convertDataValues(marksTable);\n });\n return executeResponse;\n }\n return executeResponse;\n}\nexports.UpgradeDataTableTypes = UpgradeDataTableTypes;\n/**\n * Prior to 2020.2 (internal-contract v1.13 and older), worksheet.getUnderlyingTableDataAsync doesn't exist.\n * Map it to the older GetUnderlyingData verb and validate the the logical table Id.\n **/\nfunction DowngradeUnderlyingTableDataAsync(verb, parameters) {\n if (verb === JsApiInternalContract_1.VerbId.GetUnderlyingTableData) {\n validateParametersForObjectModel(verb, parameters);\n verb = JsApiInternalContract_1.VerbId.GetUnderlyingData;\n }\n return {\n verb: verb,\n parameters: parameters,\n };\n}\nexports.DowngradeUnderlyingTableDataAsync = DowngradeUnderlyingTableDataAsync;\n/**\n * Prior to 2020.2 (internal-contract v1.13 and older), datasource.getLogicalTableDataAsync doesn't exist.\n * Map it to the older GetDataSourceData verb and validate the the logical table Id.\n **/\nfunction DowngradeLogicalTableDataAsync(verb, parameters) {\n if (verb === JsApiInternalContract_1.VerbId.GetLogicalTableData) {\n validateParametersForObjectModel(verb, parameters);\n verb = JsApiInternalContract_1.VerbId.GetDataSourceData;\n }\n return {\n verb: verb,\n parameters: parameters,\n };\n}\nexports.DowngradeLogicalTableDataAsync = DowngradeLogicalTableDataAsync;\nfunction convertDataValues(table) {\n // dataTable is a two-dimensional array of data. First index is the row, second is the column.\n if (table === undefined || table.dataTable === undefined || !Array.isArray(table.dataTable)) {\n return;\n }\n table.dataTable.forEach(function (row) {\n row.forEach(function (dataValue, columnIndex) {\n var value = dataValue.value;\n if (value !== null) {\n dataValue.value = JsApiInternalContract_1.DataTypeConverter.convertValueAsStringToValue(value, table.headers[columnIndex].dataType);\n }\n });\n });\n}\n// ToDo: TFS1069027 Refactor input verbs & parameters in api-internal-contract Upgrade/Downgrade framework\nfunction validateParametersForObjectModel(verb, parameters) {\n if (parameters[JsApiInternalContract_1.ParameterId.LogicalTableId] !== JsApiInternalContract_1.ApiShowDataTableSentinel.SingleTableId) {\n throw new Error(\"Invalid logical table id passed to \" + verb + \".\");\n }\n}\n/**\n * Prior to 2021.2 (internal-contract v1.29 and below), getSummaryDataAsync did not support maxRows,\n * and any get...DataAsync did not support columnsToIncludeById.\n * Trim result to maxRows if it is included in the parameters for getSummaryDataAsync\n * Trim columns to columnsToInclude if included in the parameters for any get...DataAsync\n */\nfunction UpgradeDataTableRowsAndColumns(executeResponse, verb, parameters) {\n if (isGetSummaryDataVerb(verb) && parameters[JsApiInternalContract_1.ParameterId.MaxRows]) {\n executeResponse = adjustDataRowLength(executeResponse, parameters[JsApiInternalContract_1.ParameterId.MaxRows]);\n }\n if (isGetTableDataVerb(verb) && parameters[JsApiInternalContract_1.ParameterId.ColumnsToIncludeById]) {\n executeResponse = adjustDataColumns(executeResponse, parameters[JsApiInternalContract_1.ParameterId.ColumnsToIncludeById]);\n }\n return executeResponse;\n}\nexports.UpgradeDataTableRowsAndColumns = UpgradeDataTableRowsAndColumns;\nfunction isGetSummaryDataVerb(verb) {\n return verb === JsApiInternalContract_1.VerbId.GetDataSummaryData;\n}\nfunction isGetTableDataVerb(verb) {\n return (verb === JsApiInternalContract_1.VerbId.GetDataSummaryData ||\n verb === JsApiInternalContract_1.VerbId.GetUnderlyingTableData ||\n verb === JsApiInternalContract_1.VerbId.GetLogicalTableData ||\n verb === JsApiInternalContract_1.VerbId.GetDataSourceData ||\n verb === JsApiInternalContract_1.VerbId.GetUnderlyingData);\n}\nfunction adjustDataRowLength(executeResponse, maxRows) {\n var underlyingDataTable = executeResponse.result;\n if (!underlyingDataTable.data || !Array.isArray(underlyingDataTable.data.dataTable)) {\n return executeResponse;\n }\n if (maxRows > 0 && maxRows < underlyingDataTable.data.dataTable.length) {\n underlyingDataTable.data.dataTable.length = maxRows;\n }\n return executeResponse;\n}\nfunction adjustDataColumns(executeResponse, columnsToInclude) {\n if (columnsToInclude.length === 0) {\n return executeResponse;\n }\n // verify that we have a valid UnderlyingDataTable\n var underlyingDataTable = executeResponse.result;\n if (!underlyingDataTable.data || !Array.isArray(underlyingDataTable.data.dataTable) || !Array.isArray(underlyingDataTable.data.headers)) {\n return executeResponse;\n }\n // 1. filter the headers to only columnsToInclude\n // 2. use the new headers to filter all rows\n // 3. update the indices in our new headers\n var newHeaders = underlyingDataTable.data.headers.filter(function (header, index) {\n return columnsToInclude.find(function (name) { return name === header.fieldName; });\n });\n underlyingDataTable.data.dataTable.forEach(function (row, index) {\n underlyingDataTable.data.dataTable[index] = row.filter(function (value, valueIndex) { return newHeaders.findIndex(function (header) { return header.index === valueIndex; }) !== -1; });\n });\n var newIndex = 0;\n underlyingDataTable.data.headers = newHeaders.map(function (header) {\n header.index = newIndex++;\n return header;\n });\n return executeResponse;\n}\n//# sourceMappingURL=ExternalVersionTranslations.js.map","\"use strict\";\n// Export everything which had been previously in the api-shared module\nfunction __export(m) {\n for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ApiVersion_1 = require(\"./ApiShared/ApiVersion\");\nexports.ApiVersion = ApiVersion_1.ApiVersion;\n__export(require(\"./ApiShared/CrossFrame/CrossFrameBootstrap\"));\nvar CrossFrameDispatcher_1 = require(\"./ApiShared/CrossFrame/CrossFrameDispatcher\");\nexports.CrossFrameDispatcher = CrossFrameDispatcher_1.CrossFrameDispatcher;\nvar DataSource_1 = require(\"./ApiShared/DataSource\");\nexports.DataSource = DataSource_1.DataSource;\nvar ExternalToInternalEnumMappings_1 = require(\"./ApiShared/EnumMappings/ExternalToInternalEnumMappings\");\nexports.ExternalToInternalEnumMappings = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings;\nvar InternalToExternalEnumMappings_1 = require(\"./ApiShared/EnumMappings/InternalToExternalEnumMappings\");\nexports.InternalToExternalEnumMappings = InternalToExternalEnumMappings_1.InternalToExternalEnumMappings;\nvar EventListenerManager_1 = require(\"./ApiShared/EventListenerManager\");\nexports.EventListenerManager = EventListenerManager_1.EventListenerManager;\nvar Field_1 = require(\"./ApiShared/Field\");\nexports.Field = Field_1.Field;\nvar CustomViewImpl_1 = require(\"./ApiShared/Impl/CustomViewImpl\");\nexports.CustomViewImpl = CustomViewImpl_1.CustomViewImpl;\nvar DashboardImpl_1 = require(\"./ApiShared/Impl/DashboardImpl\");\nexports.DashboardImpl = DashboardImpl_1.DashboardImpl;\nvar DashboardObjectImpl_1 = require(\"./ApiShared/Impl/DashboardObjectImpl\");\nexports.DashboardObjectImpl = DashboardObjectImpl_1.DashboardObjectImpl;\nvar DataSourceImpl_1 = require(\"./ApiShared/Impl/DataSourceImpl\");\nexports.DataSourceImpl = DataSourceImpl_1.DataSourceImpl;\nvar ParameterImpl_1 = require(\"./ApiShared/Impl/ParameterImpl\");\nexports.ParameterImpl = ParameterImpl_1.ParameterImpl;\nvar SheetImpl_1 = require(\"./ApiShared/Impl/SheetImpl\");\nexports.SheetImpl = SheetImpl_1.SheetImpl;\nvar SheetInfoImpl_1 = require(\"./ApiShared/Impl/SheetInfoImpl\");\nexports.SheetInfoImpl = SheetInfoImpl_1.SheetInfoImpl;\nvar SingleEventManagerImpl_1 = require(\"./ApiShared/Impl/SingleEventManagerImpl\");\nexports.SingleEventManagerImpl = SingleEventManagerImpl_1.SingleEventManagerImpl;\nvar StoryImpl_1 = require(\"./ApiShared/Impl/StoryImpl\");\nexports.StoryImpl = StoryImpl_1.StoryImpl;\nvar StoryPointImpl_1 = require(\"./ApiShared/Impl/StoryPointImpl\");\nexports.StoryPointImpl = StoryPointImpl_1.StoryPointImpl;\nvar StoryPointInfoImpl_1 = require(\"./ApiShared/Impl/StoryPointInfoImpl\");\nexports.StoryPointInfoImpl = StoryPointInfoImpl_1.StoryPointInfoImpl;\nvar WorkbookImpl_1 = require(\"./ApiShared/Impl/WorkbookImpl\");\nexports.WorkbookImpl = WorkbookImpl_1.WorkbookImpl;\nvar WorksheetImpl_1 = require(\"./ApiShared/Impl/WorksheetImpl\");\nexports.WorksheetImpl = WorksheetImpl_1.WorksheetImpl;\nvar Point_1 = require(\"./ApiShared/Point\");\nexports.Point = Point_1.Point;\n__export(require(\"./ApiShared/Services/RegisterAllSharedServices\"));\n__export(require(\"./ApiShared/Services/ServiceRegistry\"));\nvar ClientInfoServiceImpl_1 = require(\"./ApiShared/Services/impl/ClientInfoServiceImpl\");\nexports.ClientInfoServiceImpl = ClientInfoServiceImpl_1.ClientInfoServiceImpl;\nvar NotificationServiceImpl_1 = require(\"./ApiShared/Services/impl/NotificationServiceImpl\");\nexports.NotificationServiceImpl = NotificationServiceImpl_1.NotificationServiceImpl;\nvar NotificationServiceImplBase_1 = require(\"./ApiShared/Services/impl/NotificationServiceImplBase\");\nexports.NotificationServiceImplBase = NotificationServiceImplBase_1.NotificationServiceImplBase;\nexports.Registration = NotificationServiceImplBase_1.Registration;\nvar ServiceImplBase_1 = require(\"./ApiShared/Services/impl/ServiceImplBase\");\nexports.ServiceImplBase = ServiceImplBase_1.ServiceImplBase;\nvar SizeServiceImpl_1 = require(\"./ApiShared/Services/impl/SizeServiceImpl\");\nexports.SizeServiceImpl = SizeServiceImpl_1.SizeServiceImpl;\nvar StoryActivationServiceImpl_1 = require(\"./ApiShared/Services/impl/StoryActivationServiceImpl\");\nexports.StoryActivationServiceImpl = StoryActivationServiceImpl_1.StoryActivationServiceImpl;\nvar TableauError_1 = require(\"./ApiShared/TableauError\");\nexports.TableauError = TableauError_1.TableauError;\nvar Deferred_1 = require(\"./ApiShared/Utils/Deferred\");\nexports.Deferred = Deferred_1.Deferred;\nvar ErrorHelpers_1 = require(\"./ApiShared/Utils/ErrorHelpers\");\nexports.ErrorHelpers = ErrorHelpers_1.ErrorHelpers;\nvar ExportHelpers_1 = require(\"./ApiShared/Utils/ExportHelpers\");\nexports.ExportHelpers = ExportHelpers_1.ExportHelpers;\nvar SheetUtils_1 = require(\"./ApiShared/Utils/SheetUtils\");\nexports.SheetUtils = SheetUtils_1.SheetUtils;\nvar VersionNumber_1 = require(\"./ApiShared/VersionNumber\");\nexports.VersionNumber = VersionNumber_1.VersionNumber;\nvar VersionedExternalApiDispatcher_1 = require(\"./VersionedExternalApiDispatcher\");\nexports.VersionedExternalApiDispatcher = VersionedExternalApiDispatcher_1.VersionedExternalApiDispatcher;\n//# sourceMappingURL=ApiShared.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar VersionNumber_1 = require(\"./VersionNumber\");\n/**\n * This is the singleton wrapper of VersionNumber\n */\nvar ApiVersion = /** @class */ (function () {\n function ApiVersion() {\n }\n Object.defineProperty(ApiVersion, \"Instance\", {\n /**\n * Gets the singleton instance of the version number.\n */\n get: function () {\n return ApiVersion._instance;\n },\n enumerable: true,\n configurable: true\n });\n ApiVersion.SetVersionNumber = function (numString, isAlpha) {\n ApiVersion._instance = new VersionNumber_1.VersionNumber(numString, isAlpha);\n };\n return ApiVersion;\n}());\nexports.ApiVersion = ApiVersion;\n//# sourceMappingURL=ApiVersion.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Implementation of a connection summary.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nvar ConnectionSummary = /** @class */ (function () {\n function ConnectionSummary(_connectionInfo) {\n this._connectionInfo = _connectionInfo;\n }\n Object.defineProperty(ConnectionSummary.prototype, \"name\", {\n get: function () {\n return this._connectionInfo.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectionSummary.prototype, \"id\", {\n get: function () {\n return this._connectionInfo.id;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectionSummary.prototype, \"serverURI\", {\n get: function () {\n return this._connectionInfo.serverURI;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ConnectionSummary.prototype, \"type\", {\n get: function () {\n return this._connectionInfo.type;\n },\n enumerable: true,\n configurable: true\n });\n return ConnectionSummary;\n}());\nexports.ConnectionSummary = ConnectionSummary;\n//# sourceMappingURL=ConnectionSummary.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar CrossFrameDispatcher_1 = require(\"./CrossFrameDispatcher\");\n// Checks to see if we are running in an iframe currently: https://stackoverflow.com/a/326076/8821153\nfunction inIframe(thisWindow) {\n try {\n return thisWindow.self !== thisWindow.parent;\n }\n catch (e) {\n return true;\n }\n}\n/**\n * Attempts to bootstrap the extension with a cross-frame parent where Tableau is running\n *\n * @param thisWindow The window which we are running in (injected for unit testing purposes)\n * @param internalContractVersion The version number of the internal contract we are using\n * @returns A promise which is doing the actual bootstrapping\n */\nfunction doCrossFrameBootstrap(thisWindow, internalContractVersion, options) {\n return new Promise(function (resolve, reject) {\n var parent;\n // Normally, we are running inside an iframe. The exception to this is\n // when we are running as an extension inside a dialog as part of the UINamespace\n // functionality. In that case, we want the opener of this window rather than the parent.\n if (!inIframe(thisWindow)) {\n parent = thisWindow.opener;\n }\n else {\n parent = thisWindow.parent;\n }\n if (!parent) {\n reject('This extension is not running inside an iframe, desktop, or popup window. Initialization failed.');\n }\n // Create the messenger which will do he communication between this window and our parent\n // Since we don't know where we are running yet, we have to make this initial origin '*'. Once\n // we have successfully initialized our extension, we will limit where we send messages\n var messenger = new api_internal_contract_js_1.CrossFrameMessenger(thisWindow, parent, '*');\n // Prepare to send an initialization message to the parent frame\n var initializationMessage = messenger.prepareInitializationMessage(internalContractVersion, api_internal_contract_js_1.MESSAGING_VERSION, options);\n // When we receive a response back from the parent, we check to make sure the guids match and then we know\n // that the parent is aware of us and we can start communicating\n messenger.setCommandResponseMessageHandler(function (msg) {\n // Verify we are getting a response from our initialize message\n if (msg.commandGuid === initializationMessage.messageGuid) {\n // The versioning of the dispatcher happens on the other side of our frame, and\n // in a wrapper on this side. This one doesn't have any version knowledge.\n var dispatcherFactory = function () { return new CrossFrameDispatcher_1.CrossFrameDispatcher(messenger); };\n resolve(dispatcherFactory);\n }\n });\n // Now that our handlers are ready, start listening and send our initialization message\n messenger.startListening();\n initializationMessage.send();\n });\n}\nexports.doCrossFrameBootstrap = doCrossFrameBootstrap;\n//# sourceMappingURL=CrossFrameBootstrap.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\n/**\n * This is an implementation of the InternalApiDispatcher interface which functions by passing messages\n * across a frame boundary. This is usually between the code where our javscript library has been included\n * by a 3rd party dev and another frame where Tableau server has content.\n */\nvar CrossFrameDispatcher = /** @class */ (function () {\n /**\n * Creates an instance of CrossFrameDispatcher which will use the given messenger to communicate\n * @param _messenger an instantiated and listening messenger object\n */\n function CrossFrameDispatcher(_messenger) {\n this._messenger = _messenger;\n // Collection of pending promises which are waiting to be resolved. When we receive a response back from the other frame,\n // these promises can be either resolved or rejected\n this._pendingPromises = {};\n // The collection of notification handlers which have been registered with this dispatcher\n this._notificationHandlers = [];\n if (!this._messenger) {\n throw 'Missing messenger object';\n }\n // Set up our message handlers. We only care about incoming notifications and command responses\n this._messenger.setCommandResponseMessageHandler(this.onCommandResponse.bind(this));\n this._messenger.setNotificationMessageHandler(this.onNotification.bind(this));\n }\n ////// Start InternalApiDispatcher implementation\n CrossFrameDispatcher.prototype.execute = function (verb, parameters) {\n var _this = this;\n // To execute a verb, we first prepare a command message and then define a promise.\n var preparedMessage = this._messenger.prepareCommandMessage(verb, parameters);\n var promise = new Promise(function (resolve, reject) {\n // Save off the pending promise by the messageGuid we are about to send. When a response is\n // received, we'll be able to resolve this promise with the result\n _this._pendingPromises[preparedMessage.messageGuid] = { resolve: resolve, reject: reject };\n });\n // Actually send the message and return the promise\n preparedMessage.send();\n return promise;\n };\n CrossFrameDispatcher.prototype.registerNotificationHandler = function (handler) {\n this._notificationHandlers.push(handler);\n };\n CrossFrameDispatcher.prototype.unregisterNotificationHandler = function (handler) {\n this._notificationHandlers = this._notificationHandlers.filter(function (h) { return h !== handler; });\n };\n ////// End InternalApiDispatcher implementation\n CrossFrameDispatcher.prototype.onCommandResponse = function (response) {\n // We got a command response, look through the pending promises and resolve\n if (Object.keys(this._pendingPromises).indexOf(response.commandGuid) < 0) {\n return; // We don't have any reference to this command, just return\n }\n var pendingPromise = this._pendingPromises[response.commandGuid];\n // If we have an error defined, reject the promise\n if (response.error) {\n pendingPromise.reject(response.error);\n }\n // If we have data defined, resolve the promise\n if (response.data) {\n pendingPromise.resolve({ result: response.data });\n }\n // Clean up our pending promises object\n delete this._pendingPromises[response.commandGuid];\n };\n CrossFrameDispatcher.prototype.onNotification = function (notificationMessage) {\n // Go through each notification handler we have registered and let them know a notification came in\n for (var _i = 0, _a = this._notificationHandlers; _i < _a.length; _i++) {\n var handler = _a[_i];\n try {\n handler({ notificationId: notificationMessage.notificationId, data: notificationMessage.data });\n }\n catch (e) {\n // Incase of a IncompatibleVersionError, re-throw the error.\n if (e.errorCode === api_external_contract_js_1.EmbeddingErrorCodes.IncompatibleVersionError) {\n throw e;\n }\n // Else Ignore so if one handler errors, the other still get the message.\n }\n }\n };\n return CrossFrameDispatcher;\n}());\nexports.CrossFrameDispatcher = CrossFrameDispatcher;\n//# sourceMappingURL=CrossFrameDispatcher.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar DataSource = /** @class */ (function () {\n function DataSource(_dataSourceImpl) {\n this._dataSourceImpl = _dataSourceImpl;\n }\n Object.defineProperty(DataSource.prototype, \"name\", {\n get: function () {\n return this._dataSourceImpl.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataSource.prototype, \"id\", {\n get: function () {\n return this._dataSourceImpl.id;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataSource.prototype, \"fields\", {\n get: function () {\n return this._dataSourceImpl.fields;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataSource.prototype, \"extractUpdateTime\", {\n get: function () {\n return this._dataSourceImpl.extractUpdateTime;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataSource.prototype, \"isExtract\", {\n get: function () {\n return this._dataSourceImpl.isExtract;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataSource.prototype, \"isPublished\", {\n get: function () {\n return this._dataSourceImpl.isPublished;\n },\n enumerable: true,\n configurable: true\n });\n DataSource.prototype.publishedUrl = function () {\n return this._dataSourceImpl.publishedUrl();\n };\n DataSource.prototype.refreshAsync = function () {\n return this._dataSourceImpl.refreshAsync();\n };\n DataSource.prototype.getActiveTablesAsync = function () {\n console.warn('DataSource.getActiveTablesAsync is deprecated. Please use DataSource.getLogicalTablesAsync.');\n return this._dataSourceImpl.getActiveTablesAsync();\n };\n DataSource.prototype.getConnectionSummariesAsync = function () {\n return this._dataSourceImpl.getConnectionSummariesAsync();\n };\n DataSource.prototype.getUnderlyingDataAsync = function (options) {\n console.warn('DataSource.getUnderlyingDataAsync is deprecated. Please use ' +\n 'DataSource.getLogicalTablesAsync and DataSource.getLogicalTableDataAsync.');\n return this._dataSourceImpl.getUnderlyingDataAsync(options);\n };\n DataSource.prototype.getLogicalTablesAsync = function () {\n return this._dataSourceImpl.getLogicalTablesAsync();\n };\n DataSource.prototype.getLogicalTableDataAsync = function (logicalTableId, options) {\n return this._dataSourceImpl.getLogicalTableDataAsync(logicalTableId, options);\n };\n DataSource.prototype.getLogicalTableDataReaderAsync = function (logicalTableId, pageRowCount, options) {\n return this._dataSourceImpl.getLogicalTableDataReaderAsync(logicalTableId, pageRowCount, options);\n };\n return DataSource;\n}());\nexports.DataSource = DataSource;\n//# sourceMappingURL=DataSource.js.map","\"use strict\";\nvar _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar EnumConverter_1 = require(\"../Utils/EnumConverter\");\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\n/**\n * Maps enums used by the external-api-contract to the enums used\n * in the internal-api-contract, which developers code against.\n */\nvar ExternalToInternalEnumMappings = /** @class */ (function () {\n function ExternalToInternalEnumMappings() {\n }\n ExternalToInternalEnumMappings.filterDomainType = new EnumConverter_1.EnumConverter((_a = {},\n _a[api_external_contract_js_1.FilterDomainType.Relevant] = api_internal_contract_js_1.FilterDomainType.Relevant,\n _a[api_external_contract_js_1.FilterDomainType.Database] = api_internal_contract_js_1.FilterDomainType.Database,\n _a));\n ExternalToInternalEnumMappings.nullOptions = new EnumConverter_1.EnumConverter((_b = {},\n _b[api_external_contract_js_1.FilterNullOption.AllValues] = api_internal_contract_js_1.FilterNullOption.AllValues,\n _b[api_external_contract_js_1.FilterNullOption.NonNullValues] = api_internal_contract_js_1.FilterNullOption.NonNullValues,\n _b[api_external_contract_js_1.FilterNullOption.NullValues] = api_internal_contract_js_1.FilterNullOption.NullValues,\n _b));\n ExternalToInternalEnumMappings.filterUpdateType = new EnumConverter_1.EnumConverter((_c = {},\n _c[api_external_contract_js_1.FilterUpdateType.Add] = api_internal_contract_js_1.FilterUpdateType.Add,\n _c[api_external_contract_js_1.FilterUpdateType.All] = api_internal_contract_js_1.FilterUpdateType.All,\n _c[api_external_contract_js_1.FilterUpdateType.Remove] = api_internal_contract_js_1.FilterUpdateType.Remove,\n _c[api_external_contract_js_1.FilterUpdateType.Replace] = api_internal_contract_js_1.FilterUpdateType.Replace,\n _c));\n ExternalToInternalEnumMappings.setVisibilityType = new EnumConverter_1.EnumConverter((_d = {},\n _d[api_external_contract_js_1.ZoneVisibilityType.Show] = true,\n _d[api_external_contract_js_1.ZoneVisibilityType.Hide] = false,\n _d));\n ExternalToInternalEnumMappings.setReplaySpeedType = new EnumConverter_1.EnumConverter((_e = {},\n // these numbers are duration multipliers\n // 2.0, for example, doubles the duration of the replay, slowing it down to 0.5x speed\n _e[api_external_contract_js_1.ReplaySpeedType.Slow] = 2.0,\n _e[api_external_contract_js_1.ReplaySpeedType.Normal] = 1.0,\n _e[api_external_contract_js_1.ReplaySpeedType.Fast] = 0.5,\n _e));\n ExternalToInternalEnumMappings.sheetType = new EnumConverter_1.EnumConverter((_f = {},\n _f[api_external_contract_js_1.SheetType.Dashboard] = api_internal_contract_js_1.SheetType.Dashboard,\n _f[api_external_contract_js_1.SheetType.Worksheet] = api_internal_contract_js_1.SheetType.Worksheet,\n _f[api_external_contract_js_1.SheetType.Story] = api_internal_contract_js_1.SheetType.Story,\n _f));\n ExternalToInternalEnumMappings.showDataTableFormatType = new EnumConverter_1.EnumConverter((_g = {},\n _g[api_external_contract_js_1.IncludeDataValuesOption.AllValues] = api_internal_contract_js_1.ApiShowDataTableFormat.NativeAndFormattedValues,\n _g[api_external_contract_js_1.IncludeDataValuesOption.OnlyNativeValues] = api_internal_contract_js_1.ApiShowDataTableFormat.NativeValuesOnly,\n _g[api_external_contract_js_1.IncludeDataValuesOption.OnlyFormattedValues] = api_internal_contract_js_1.ApiShowDataTableFormat.FormattedValuesOnly,\n _g));\n ExternalToInternalEnumMappings.periodType = new EnumConverter_1.EnumConverter((_h = {},\n _h[api_external_contract_js_1.PeriodType.Years] = api_internal_contract_js_1.DateStepPeriod.Years,\n _h[api_external_contract_js_1.PeriodType.Quarters] = api_internal_contract_js_1.DateStepPeriod.Quarters,\n _h[api_external_contract_js_1.PeriodType.Months] = api_internal_contract_js_1.DateStepPeriod.Months,\n _h[api_external_contract_js_1.PeriodType.Weeks] = api_internal_contract_js_1.DateStepPeriod.Weeks,\n _h[api_external_contract_js_1.PeriodType.Days] = api_internal_contract_js_1.DateStepPeriod.Days,\n _h[api_external_contract_js_1.PeriodType.Hours] = api_internal_contract_js_1.DateStepPeriod.Hours,\n _h[api_external_contract_js_1.PeriodType.Minutes] = api_internal_contract_js_1.DateStepPeriod.Minutes,\n _h[api_external_contract_js_1.PeriodType.Seconds] = api_internal_contract_js_1.DateStepPeriod.Seconds,\n _h));\n ExternalToInternalEnumMappings.dateRangeType = new EnumConverter_1.EnumConverter((_j = {},\n _j[api_external_contract_js_1.DateRangeType.Last] = api_internal_contract_js_1.DateRangeType.Last,\n _j[api_external_contract_js_1.DateRangeType.LastN] = api_internal_contract_js_1.DateRangeType.LastN,\n _j[api_external_contract_js_1.DateRangeType.Next] = api_internal_contract_js_1.DateRangeType.Next,\n _j[api_external_contract_js_1.DateRangeType.NextN] = api_internal_contract_js_1.DateRangeType.NextN,\n _j[api_external_contract_js_1.DateRangeType.Current] = api_internal_contract_js_1.DateRangeType.Current,\n _j[api_external_contract_js_1.DateRangeType.ToDate] = api_internal_contract_js_1.DateRangeType.ToDate,\n _j));\n ExternalToInternalEnumMappings.dialogStyles = new EnumConverter_1.EnumConverter((_k = {},\n _k[api_external_contract_js_1.DialogStyle.Window] = api_internal_contract_js_1.DialogStyle.Window,\n _k[api_external_contract_js_1.DialogStyle.Modal] = api_internal_contract_js_1.DialogStyle.Modal,\n _k[api_external_contract_js_1.DialogStyle.Modeless] = api_internal_contract_js_1.DialogStyle.Modeless,\n _k));\n return ExternalToInternalEnumMappings;\n}());\nexports.ExternalToInternalEnumMappings = ExternalToInternalEnumMappings;\n/* tslint:enable:typedef */\n//# sourceMappingURL=ExternalToInternalEnumMappings.js.map","\"use strict\";\nvar _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar EnumConverter_1 = require(\"../Utils/EnumConverter\");\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\n/**\n * Maps enums used by the internal-api-contract to the enums used\n * in the external-api-contract, which developers code against.\n */\nvar InternalToExternalEnumMappings = /** @class */ (function () {\n function InternalToExternalEnumMappings() {\n }\n InternalToExternalEnumMappings.extensionContext = new EnumConverter_1.EnumConverter((_a = {},\n _a[api_internal_contract_js_1.ExtensionContext.Desktop] = api_external_contract_js_1.ExtensionContext.Desktop,\n _a[api_internal_contract_js_1.ExtensionContext.Server] = api_external_contract_js_1.ExtensionContext.Server,\n _a));\n InternalToExternalEnumMappings.extensionMode = new EnumConverter_1.EnumConverter((_b = {},\n _b[api_internal_contract_js_1.ExtensionMode.Authoring] = api_external_contract_js_1.ExtensionMode.Authoring,\n _b[api_internal_contract_js_1.ExtensionMode.Viewing] = api_external_contract_js_1.ExtensionMode.Viewing,\n _b));\n InternalToExternalEnumMappings.columnType = new EnumConverter_1.EnumConverter((_c = {},\n _c[api_internal_contract_js_1.ColumnType.Continuous] = api_external_contract_js_1.ColumnType.Continuous,\n _c[api_internal_contract_js_1.ColumnType.Discrete] = api_external_contract_js_1.ColumnType.Discrete,\n _c[api_internal_contract_js_1.ColumnType.Unknown] = api_external_contract_js_1.ColumnType.Unknown,\n _c));\n InternalToExternalEnumMappings.fieldAggregationType = new EnumConverter_1.EnumConverter((_d = {},\n _d[api_internal_contract_js_1.FieldAggregationType.Attr] = api_external_contract_js_1.FieldAggregationType.Attr,\n _d[api_internal_contract_js_1.FieldAggregationType.Avg] = api_external_contract_js_1.FieldAggregationType.Avg,\n _d[api_internal_contract_js_1.FieldAggregationType.Collect] = api_external_contract_js_1.FieldAggregationType.Collect,\n _d[api_internal_contract_js_1.FieldAggregationType.Count] = api_external_contract_js_1.FieldAggregationType.Count,\n _d[api_internal_contract_js_1.FieldAggregationType.Countd] = api_external_contract_js_1.FieldAggregationType.Countd,\n _d[api_internal_contract_js_1.FieldAggregationType.Day] = api_external_contract_js_1.FieldAggregationType.Day,\n _d[api_internal_contract_js_1.FieldAggregationType.End] = api_external_contract_js_1.FieldAggregationType.End,\n _d[api_internal_contract_js_1.FieldAggregationType.Hour] = api_external_contract_js_1.FieldAggregationType.Hour,\n _d[api_internal_contract_js_1.FieldAggregationType.InOut] = api_external_contract_js_1.FieldAggregationType.InOut,\n _d[api_internal_contract_js_1.FieldAggregationType.Kurtosis] = api_external_contract_js_1.FieldAggregationType.Kurtosis,\n _d[api_internal_contract_js_1.FieldAggregationType.Max] = api_external_contract_js_1.FieldAggregationType.Max,\n _d[api_internal_contract_js_1.FieldAggregationType.Mdy] = api_external_contract_js_1.FieldAggregationType.Mdy,\n _d[api_internal_contract_js_1.FieldAggregationType.Median] = api_external_contract_js_1.FieldAggregationType.Median,\n _d[api_internal_contract_js_1.FieldAggregationType.Min] = api_external_contract_js_1.FieldAggregationType.Min,\n _d[api_internal_contract_js_1.FieldAggregationType.Minute] = api_external_contract_js_1.FieldAggregationType.Minute,\n _d[api_internal_contract_js_1.FieldAggregationType.MonthYear] = api_external_contract_js_1.FieldAggregationType.MonthYear,\n _d[api_internal_contract_js_1.FieldAggregationType.None] = api_external_contract_js_1.FieldAggregationType.None,\n _d[api_internal_contract_js_1.FieldAggregationType.Qtr] = api_external_contract_js_1.FieldAggregationType.Qtr,\n _d[api_internal_contract_js_1.FieldAggregationType.Quart1] = api_external_contract_js_1.FieldAggregationType.Quart1,\n _d[api_internal_contract_js_1.FieldAggregationType.Quart3] = api_external_contract_js_1.FieldAggregationType.Quart3,\n _d[api_internal_contract_js_1.FieldAggregationType.Second] = api_external_contract_js_1.FieldAggregationType.Second,\n _d[api_internal_contract_js_1.FieldAggregationType.Skewness] = api_external_contract_js_1.FieldAggregationType.Skewness,\n _d[api_internal_contract_js_1.FieldAggregationType.Stdev] = api_external_contract_js_1.FieldAggregationType.Stdev,\n _d[api_internal_contract_js_1.FieldAggregationType.Stdevp] = api_external_contract_js_1.FieldAggregationType.Stdevp,\n _d[api_internal_contract_js_1.FieldAggregationType.Sum] = api_external_contract_js_1.FieldAggregationType.Sum,\n _d[api_internal_contract_js_1.FieldAggregationType.TruncDay] = api_external_contract_js_1.FieldAggregationType.TruncDay,\n _d[api_internal_contract_js_1.FieldAggregationType.TruncHour] = api_external_contract_js_1.FieldAggregationType.TruncHour,\n _d[api_internal_contract_js_1.FieldAggregationType.TruncMinute] = api_external_contract_js_1.FieldAggregationType.TruncMinute,\n _d[api_internal_contract_js_1.FieldAggregationType.TruncMonth] = api_external_contract_js_1.FieldAggregationType.TruncMonth,\n _d[api_internal_contract_js_1.FieldAggregationType.TruncQtr] = api_external_contract_js_1.FieldAggregationType.TruncQtr,\n _d[api_internal_contract_js_1.FieldAggregationType.TruncSecond] = api_external_contract_js_1.FieldAggregationType.TruncSecond,\n _d[api_internal_contract_js_1.FieldAggregationType.TruncWeek] = api_external_contract_js_1.FieldAggregationType.TruncWeek,\n _d[api_internal_contract_js_1.FieldAggregationType.TruncYear] = api_external_contract_js_1.FieldAggregationType.TruncYear,\n _d[api_internal_contract_js_1.FieldAggregationType.User] = api_external_contract_js_1.FieldAggregationType.User,\n _d[api_internal_contract_js_1.FieldAggregationType.Var] = api_external_contract_js_1.FieldAggregationType.Var,\n _d[api_internal_contract_js_1.FieldAggregationType.Varp] = api_external_contract_js_1.FieldAggregationType.Varp,\n _d[api_internal_contract_js_1.FieldAggregationType.Week] = api_external_contract_js_1.FieldAggregationType.Week,\n _d[api_internal_contract_js_1.FieldAggregationType.Weekday] = api_external_contract_js_1.FieldAggregationType.Weekday,\n _d[api_internal_contract_js_1.FieldAggregationType.Year] = api_external_contract_js_1.FieldAggregationType.Year,\n _d));\n InternalToExternalEnumMappings.fieldRoleType = new EnumConverter_1.EnumConverter((_e = {},\n _e[api_internal_contract_js_1.FieldRoleType.Dimension] = api_external_contract_js_1.FieldRoleType.Dimension,\n _e[api_internal_contract_js_1.FieldRoleType.Measure] = api_external_contract_js_1.FieldRoleType.Measure,\n _e[api_internal_contract_js_1.FieldRoleType.Unknown] = api_external_contract_js_1.FieldRoleType.Unknown,\n _e));\n InternalToExternalEnumMappings.sheetType = new EnumConverter_1.EnumConverter((_f = {},\n _f[api_internal_contract_js_1.SheetType.Dashboard] = api_external_contract_js_1.SheetType.Dashboard,\n _f[api_internal_contract_js_1.SheetType.Story] = api_external_contract_js_1.SheetType.Story,\n _f[api_internal_contract_js_1.SheetType.Worksheet] = api_external_contract_js_1.SheetType.Worksheet,\n _f));\n InternalToExternalEnumMappings.dashboardObjectType = new EnumConverter_1.EnumConverter((_g = {},\n _g[api_internal_contract_js_1.DashboardObjectType.Extension] = api_external_contract_js_1.DashboardObjectType.Extension,\n _g[api_internal_contract_js_1.DashboardObjectType.Blank] = api_external_contract_js_1.DashboardObjectType.Blank,\n _g[api_internal_contract_js_1.DashboardObjectType.Image] = api_external_contract_js_1.DashboardObjectType.Image,\n _g[api_internal_contract_js_1.DashboardObjectType.Legend] = api_external_contract_js_1.DashboardObjectType.Legend,\n _g[api_internal_contract_js_1.DashboardObjectType.PageFilter] = api_external_contract_js_1.DashboardObjectType.PageFilter,\n _g[api_internal_contract_js_1.DashboardObjectType.ParameterControl] = api_external_contract_js_1.DashboardObjectType.ParameterControl,\n _g[api_internal_contract_js_1.DashboardObjectType.QuickFilter] = api_external_contract_js_1.DashboardObjectType.QuickFilter,\n _g[api_internal_contract_js_1.DashboardObjectType.Text] = api_external_contract_js_1.DashboardObjectType.Text,\n _g[api_internal_contract_js_1.DashboardObjectType.Title] = api_external_contract_js_1.DashboardObjectType.Title,\n _g[api_internal_contract_js_1.DashboardObjectType.WebPage] = api_external_contract_js_1.DashboardObjectType.WebPage,\n _g[api_internal_contract_js_1.DashboardObjectType.Worksheet] = api_external_contract_js_1.DashboardObjectType.Worksheet,\n _g));\n InternalToExternalEnumMappings.dataType = new EnumConverter_1.EnumConverter((_h = {},\n _h[api_internal_contract_js_1.DataType.Bool] = api_external_contract_js_1.DataType.Bool,\n _h[api_internal_contract_js_1.DataType.Date] = api_external_contract_js_1.DataType.Date,\n _h[api_internal_contract_js_1.DataType.DateTime] = api_external_contract_js_1.DataType.DateTime,\n _h[api_internal_contract_js_1.DataType.Float] = api_external_contract_js_1.DataType.Float,\n _h[api_internal_contract_js_1.DataType.Int] = api_external_contract_js_1.DataType.Int,\n _h[api_internal_contract_js_1.DataType.Spatial] = api_external_contract_js_1.DataType.Spatial,\n _h[api_internal_contract_js_1.DataType.String] = api_external_contract_js_1.DataType.String,\n _h));\n InternalToExternalEnumMappings.filterUpdateType = new EnumConverter_1.EnumConverter((_j = {},\n _j[api_internal_contract_js_1.FilterUpdateType.Add] = api_external_contract_js_1.FilterUpdateType.Add,\n _j[api_internal_contract_js_1.FilterUpdateType.All] = api_external_contract_js_1.FilterUpdateType.All,\n _j[api_internal_contract_js_1.FilterUpdateType.Remove] = api_external_contract_js_1.FilterUpdateType.Remove,\n _j[api_internal_contract_js_1.FilterUpdateType.Replace] = api_external_contract_js_1.FilterUpdateType.Replace,\n _j));\n InternalToExternalEnumMappings.allowableValues = new EnumConverter_1.EnumConverter((_k = {},\n _k[api_internal_contract_js_1.DomainRestrictionType.All] = api_external_contract_js_1.ParameterValueType.All,\n _k[api_internal_contract_js_1.DomainRestrictionType.List] = api_external_contract_js_1.ParameterValueType.List,\n _k[api_internal_contract_js_1.DomainRestrictionType.Range] = api_external_contract_js_1.ParameterValueType.Range,\n _k));\n InternalToExternalEnumMappings.dateStepPeriod = new EnumConverter_1.EnumConverter((_l = {},\n _l[api_internal_contract_js_1.DateStepPeriod.Years] = api_external_contract_js_1.PeriodType.Years,\n _l[api_internal_contract_js_1.DateStepPeriod.Quarters] = api_external_contract_js_1.PeriodType.Quarters,\n _l[api_internal_contract_js_1.DateStepPeriod.Months] = api_external_contract_js_1.PeriodType.Months,\n _l[api_internal_contract_js_1.DateStepPeriod.Weeks] = api_external_contract_js_1.PeriodType.Weeks,\n _l[api_internal_contract_js_1.DateStepPeriod.Days] = api_external_contract_js_1.PeriodType.Days,\n _l[api_internal_contract_js_1.DateStepPeriod.Hours] = api_external_contract_js_1.PeriodType.Hours,\n _l[api_internal_contract_js_1.DateStepPeriod.Minutes] = api_external_contract_js_1.PeriodType.Minutes,\n _l[api_internal_contract_js_1.DateStepPeriod.Seconds] = api_external_contract_js_1.PeriodType.Seconds,\n _l));\n InternalToExternalEnumMappings.dateRangeType = new EnumConverter_1.EnumConverter((_m = {},\n _m[api_internal_contract_js_1.DateRangeType.Current] = api_external_contract_js_1.DateRangeType.Current,\n _m[api_internal_contract_js_1.DateRangeType.Last] = api_external_contract_js_1.DateRangeType.Last,\n _m[api_internal_contract_js_1.DateRangeType.LastN] = api_external_contract_js_1.DateRangeType.LastN,\n _m[api_internal_contract_js_1.DateRangeType.Next] = api_external_contract_js_1.DateRangeType.Next,\n _m[api_internal_contract_js_1.DateRangeType.NextN] = api_external_contract_js_1.DateRangeType.NextN,\n _m[api_internal_contract_js_1.DateRangeType.ToDate] = api_external_contract_js_1.DateRangeType.ToDate,\n _m));\n InternalToExternalEnumMappings.errorCode = new EnumConverter_1.EnumConverter((_o = {},\n _o[api_internal_contract_js_1.ErrorCodes.INITIALIZATION_ERROR] = api_external_contract_js_1.ErrorCodes.InternalError,\n _o[api_internal_contract_js_1.ErrorCodes.INTERNAL_ERROR] = api_external_contract_js_1.ErrorCodes.InternalError,\n _o[api_internal_contract_js_1.ErrorCodes.MISSING_ENUM_MAPPING] = api_external_contract_js_1.ErrorCodes.InternalError,\n _o[api_internal_contract_js_1.ErrorCodes.MISSING_PARAMETER] = api_external_contract_js_1.ErrorCodes.InternalError,\n _o[api_internal_contract_js_1.ErrorCodes.PERMISSION_DENIED] = api_external_contract_js_1.ErrorCodes.InternalError,\n _o[api_internal_contract_js_1.ErrorCodes.PRES_MODEL_PARSING_ERROR] = api_external_contract_js_1.ErrorCodes.InternalError,\n _o[api_internal_contract_js_1.ErrorCodes.UNKNOWN_VERB_ID] = api_external_contract_js_1.ErrorCodes.InternalError,\n _o[api_internal_contract_js_1.ErrorCodes.VERSION_NOT_CONFIGURED] = api_external_contract_js_1.ErrorCodes.APINotInitialized,\n _o[api_internal_contract_js_1.ErrorCodes.VISIBILITY_ERROR] = api_external_contract_js_1.ErrorCodes.VisibilityError,\n _o), api_external_contract_js_1.ErrorCodes.InternalError);\n InternalToExternalEnumMappings.filterType = new EnumConverter_1.EnumConverter((_p = {},\n _p[api_internal_contract_js_1.FilterType.Categorical] = api_external_contract_js_1.FilterType.Categorical,\n _p[api_internal_contract_js_1.FilterType.Range] = api_external_contract_js_1.FilterType.Range,\n _p[api_internal_contract_js_1.FilterType.RelativeDate] = api_external_contract_js_1.FilterType.RelativeDate,\n _p[api_internal_contract_js_1.FilterType.Hierarchical] = api_external_contract_js_1.FilterType.Hierarchical,\n _p));\n InternalToExternalEnumMappings.classNameKey = new EnumConverter_1.EnumConverter((_q = {},\n _q[\"tableau-dashboard-title\" /* DashboardTitle */] = api_external_contract_js_1.ClassNameKey.DashboardTitle,\n _q[\"tableau-story-title\" /* StoryTitle */] = api_external_contract_js_1.ClassNameKey.StoryTitle,\n _q[\"tableau-tooltip\" /* Tooltip */] = api_external_contract_js_1.ClassNameKey.Tooltip,\n _q[\"tableau-worksheet\" /* Worksheet */] = api_external_contract_js_1.ClassNameKey.Worksheet,\n _q[\"tableau-worksheet-title\" /* WorksheetTitle */] = api_external_contract_js_1.ClassNameKey.WorksheetTitle,\n // Temporary until we fix 1317266 - Platform hasn't been updated currently because near branch is closed\n _q['dashboard-title'] = api_external_contract_js_1.ClassNameKey.DashboardTitle,\n _q['story-title'] = api_external_contract_js_1.ClassNameKey.StoryTitle,\n _q['tooltip'] = api_external_contract_js_1.ClassNameKey.Tooltip,\n _q['worksheet'] = api_external_contract_js_1.ClassNameKey.Worksheet,\n _q['worksheet-title'] = api_external_contract_js_1.ClassNameKey.WorksheetTitle,\n _q));\n InternalToExternalEnumMappings.hierarchicalLevelSelectionState = new EnumConverter_1.EnumConverter((_r = {},\n _r[api_internal_contract_js_1.HierarchicalLevelSelectionState.AllSelected] = api_external_contract_js_1.HierarchicalLevelSelectionState.AllSelected,\n _r[api_internal_contract_js_1.HierarchicalLevelSelectionState.NoneSelected] = api_external_contract_js_1.HierarchicalLevelSelectionState.NoneSelected,\n _r[api_internal_contract_js_1.HierarchicalLevelSelectionState.SomeSelected] = api_external_contract_js_1.HierarchicalLevelSelectionState.SomeSelected,\n _r[api_internal_contract_js_1.HierarchicalLevelSelectionState.UnknownSelected] = api_external_contract_js_1.HierarchicalLevelSelectionState.UnknownSelected,\n _r));\n InternalToExternalEnumMappings.annotationType = new EnumConverter_1.EnumConverter((_s = {},\n _s[api_internal_contract_js_1.AnnotateEnum.Area] = api_external_contract_js_1.AnnotationType.Area,\n _s[api_internal_contract_js_1.AnnotateEnum.Mark] = api_external_contract_js_1.AnnotationType.Mark,\n _s[api_internal_contract_js_1.AnnotateEnum.Point] = api_external_contract_js_1.AnnotationType.Point,\n _s));\n InternalToExternalEnumMappings.markType = new EnumConverter_1.EnumConverter((_t = {},\n _t[api_internal_contract_js_1.MarkType.Area] = api_external_contract_js_1.MarkType.Area,\n _t[api_internal_contract_js_1.MarkType.Bar] = api_external_contract_js_1.MarkType.Bar,\n _t[api_internal_contract_js_1.MarkType.Circle] = api_external_contract_js_1.MarkType.Circle,\n _t[api_internal_contract_js_1.MarkType.GanttBar] = api_external_contract_js_1.MarkType.GanttBar,\n _t[api_internal_contract_js_1.MarkType.Heatmap] = api_external_contract_js_1.MarkType.Heatmap,\n _t[api_internal_contract_js_1.MarkType.Line] = api_external_contract_js_1.MarkType.Line,\n _t[api_internal_contract_js_1.MarkType.Map] = api_external_contract_js_1.MarkType.Map,\n _t[api_internal_contract_js_1.MarkType.Pie] = api_external_contract_js_1.MarkType.Pie,\n _t[api_internal_contract_js_1.MarkType.Polygon] = api_external_contract_js_1.MarkType.Polygon,\n _t[api_internal_contract_js_1.MarkType.Shape] = api_external_contract_js_1.MarkType.Shape,\n _t[api_internal_contract_js_1.MarkType.Square] = api_external_contract_js_1.MarkType.Square,\n _t[api_internal_contract_js_1.MarkType.Text] = api_external_contract_js_1.MarkType.Text,\n _t[api_internal_contract_js_1.MarkType.VizExtension] = api_external_contract_js_1.MarkType.VizExtension,\n _t));\n return InternalToExternalEnumMappings;\n}());\nexports.InternalToExternalEnumMappings = InternalToExternalEnumMappings;\n/* tslint:enable:typedef */\n//# sourceMappingURL=InternalToExternalEnumMappings.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar TableauError_1 = require(\"./TableauError\");\n/**\n * Class designed to register and unregister handlers from a user. Only those events\n * which are added via AddNewEventType will be supported by this instance\n */\nvar EventListenerManager = /** @class */ (function () {\n function EventListenerManager() {\n this._eventListenerManagers = {};\n }\n EventListenerManager.prototype.addEventListener = function (eventType, handler) {\n if (!this._eventListenerManagers.hasOwnProperty(eventType)) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.UnsupportedEventName, \"Cannot add event, unsupported event type: \" + eventType);\n }\n return this._eventListenerManagers[eventType].addEventListener(handler);\n };\n EventListenerManager.prototype.removeEventListener = function (eventType, handler) {\n if (!this._eventListenerManagers.hasOwnProperty(eventType)) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.UnsupportedEventName, \"Cannot remove event, unsupported event type: \" + eventType);\n }\n return this._eventListenerManagers[eventType].removeEventListener(handler);\n };\n EventListenerManager.prototype.addNewEventType = function (eventManager) {\n this._eventListenerManagers[eventManager.eventType] = eventManager;\n };\n return EventListenerManager;\n}());\nexports.EventListenerManager = EventListenerManager;\n//# sourceMappingURL=EventListenerManager.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Field = /** @class */ (function () {\n function Field(_fieldImpl) {\n this._fieldImpl = _fieldImpl;\n }\n Object.defineProperty(Field.prototype, \"name\", {\n get: function () {\n return this._fieldImpl.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"id\", {\n get: function () {\n return this._fieldImpl.id;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"description\", {\n get: function () {\n return this._fieldImpl.description;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"dataType\", {\n get: function () {\n return this._fieldImpl.dataType;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"aggregation\", {\n get: function () {\n return this._fieldImpl.aggregation;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"dataSource\", {\n get: function () {\n return this._fieldImpl.dataSource;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"role\", {\n get: function () {\n return this._fieldImpl.role;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"columnType\", {\n get: function () {\n return this._fieldImpl.columnType;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"isCalculatedField\", {\n get: function () {\n return this._fieldImpl.isCalculatedField;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"isCombinedField\", {\n get: function () {\n return this._fieldImpl.isCombinedField;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"isGenerated\", {\n get: function () {\n return this._fieldImpl.isGenerated;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"isGeospatial\", {\n get: function () {\n return this._fieldImpl.isGeospatial;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"isHidden\", {\n get: function () {\n return this._fieldImpl.isHidden;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Field.prototype, \"isPresentOnPublishedDatasource\", {\n get: function () {\n return this._fieldImpl.isPresentOnPublishedDatasource;\n },\n enumerable: true,\n configurable: true\n });\n return Field;\n}());\nexports.Field = Field;\n//# sourceMappingURL=Field.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ApiShared_1 = require(\"../../ApiShared\");\nvar CustomViewImpl = /** @class */ (function () {\n function CustomViewImpl(customViewModel, _registryId) {\n this._registryId = _registryId;\n this._luid = customViewModel.luid;\n this._name = customViewModel.name;\n this._shared = customViewModel.shared;\n this._isDefault = customViewModel.isDefault;\n this._ownerName = customViewModel.owner.userFriendlyName;\n this._url = customViewModel.url;\n }\n Object.defineProperty(CustomViewImpl.prototype, \"luid\", {\n get: function () {\n return this._luid;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(CustomViewImpl.prototype, \"name\", {\n get: function () {\n return this._name;\n },\n set: function (name) {\n this._name = name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(CustomViewImpl.prototype, \"shared\", {\n get: function () {\n return this._shared;\n },\n set: function (shared) {\n this._shared = shared;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(CustomViewImpl.prototype, \"isDefault\", {\n get: function () {\n return this._isDefault;\n },\n set: function (isDefault) {\n this._isDefault = isDefault;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(CustomViewImpl.prototype, \"ownerName\", {\n get: function () {\n return this._ownerName;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(CustomViewImpl.prototype, \"url\", {\n get: function () {\n return this._url;\n },\n enumerable: true,\n configurable: true\n });\n CustomViewImpl.prototype.saveAsync = function () {\n var service = ApiShared_1.ApiServiceRegistry.get(this._registryId).getService(\"viz-service\" /* Viz */);\n return service.saveAsync(this);\n };\n return CustomViewImpl;\n}());\nexports.CustomViewImpl = CustomViewImpl;\n//# sourceMappingURL=CustomViewImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar InternalToExternalEnumMappings_1 = require(\"../EnumMappings/InternalToExternalEnumMappings\");\nvar Point_1 = require(\"../Point\");\nvar ServiceRegistry_1 = require(\"../Services/ServiceRegistry\");\nvar TableauError_1 = require(\"../TableauError\");\nvar ErrorHelpers_1 = require(\"../Utils/ErrorHelpers\");\nvar DashboardObjectImpl_1 = require(\"./DashboardObjectImpl\");\nvar SheetImpl_1 = require(\"./SheetImpl\");\nvar SheetInfoImpl_1 = require(\"./SheetInfoImpl\");\nvar WorksheetImpl_1 = require(\"./WorksheetImpl\");\nvar DashboardImpl = /** @class */ (function (_super) {\n __extends(DashboardImpl, _super);\n function DashboardImpl(_sheetInfo, _zones, _sheetPath, _registryId, _parentStoryPointImpl, _activeDashboardObjectId) {\n if (_activeDashboardObjectId === void 0) { _activeDashboardObjectId = 0; }\n var _this = _super.call(this, _sheetInfo, _registryId) || this;\n _this._zones = _zones;\n _this._sheetPath = _sheetPath;\n _this._parentStoryPointImpl = _parentStoryPointImpl;\n _this._activeDashboardObjectId = _activeDashboardObjectId;\n return _this;\n }\n Object.defineProperty(DashboardImpl.prototype, \"worksheetsImpl\", {\n get: function () {\n return this._worksheetsImpl;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardImpl.prototype, \"objects\", {\n get: function () {\n return this._objects;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardImpl.prototype, \"parentStoryPoint\", {\n get: function () {\n return this._parentStoryPointImpl;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardImpl.prototype, \"activeDashboardObjectId\", {\n get: function () {\n return this._activeDashboardObjectId;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardImpl.prototype, \"activeDashboardName\", {\n get: function () {\n return this._sheetPath.sheetName;\n },\n enumerable: true,\n configurable: true\n });\n DashboardImpl.prototype.initializeWithPublicInterfaces = function () {\n this._worksheetsImpl = new Array();\n this._objects = new Array();\n this.zoneMap = new Map();\n // Process all the zones which are contained in this dashboard\n for (var _i = 0, _a = this._zones; _i < _a.length; _i++) {\n var zone = _a[_i];\n var worksheetImpl = undefined;\n var zoneSize = { width: zone.width, height: zone.height };\n // As the dashboard is active, all other zones in the dashboard are inactive.\n var isActive = false;\n if (zone.zoneType === api_internal_contract_js_1.DashboardObjectType.Worksheet || zone.zoneType === api_internal_contract_js_1.DashboardObjectType.QuickFilter) {\n var worksheetName = '';\n var worksheetUrl = '';\n var isHidden = false;\n if (zone.sheetInfo) {\n // zone.sheetInfo was not initialized prior to internal-contract 1.6.0\n worksheetName = zone.sheetInfo.name;\n // worksheetUrl & isHidden is for Embedding only\n worksheetUrl = zone.sheetInfo.url || '';\n // If there's a url, then it's not hidden\n isHidden = worksheetUrl === '';\n }\n else {\n worksheetName = zone.name;\n }\n // Indexes, isActive and some more properties in sheetInfoImpl are embedding specific.\n // But we init them for both extensions and embedding as the Models will only use what is relevant.\n var sheetInfoImpl = new SheetInfoImpl_1.SheetInfoImpl(worksheetName, api_external_contract_js_1.SheetType.Worksheet, zoneSize, this._worksheetsImpl.length, isActive, isHidden, worksheetUrl);\n var vizId = {\n worksheet: worksheetName,\n dashboard: this._sheetInfoImpl.name,\n storyboard: this._sheetPath.storyboard,\n flipboardZoneID: this._sheetPath.flipboardZoneID,\n storyPointID: this._sheetPath.storyPointID,\n };\n worksheetImpl = new WorksheetImpl_1.WorksheetImpl(sheetInfoImpl, this._registryId, vizId, this, this._parentStoryPointImpl);\n if (zone.zoneType === api_internal_contract_js_1.DashboardObjectType.Worksheet) {\n this._worksheetsImpl.push(worksheetImpl);\n }\n }\n var zonePoint = new Point_1.Point(zone.x, zone.y);\n var dashboardObjectImpl = new DashboardObjectImpl_1.DashboardObjectImpl(this, InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dashboardObjectType.convert(zone.zoneType), zonePoint, zoneSize, worksheetImpl, zone.name, zone.isFloating !== undefined ? zone.isFloating : false, // before 1.6.0 we didn't have isFloating, so we assume false\n zone.isVisible !== undefined ? zone.isVisible : true, // before 1.6.0 we didn't have isVisible, so we assume true\n zone.zoneId, zone.fieldId);\n this._objects.push(dashboardObjectImpl);\n this.zoneMap.set(zone.zoneId, dashboardObjectImpl);\n }\n };\n DashboardImpl.prototype.setDashboardObjectVisibilityAsync = function (dashboardObjectVisibilityMap) {\n var zoneService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"zone-service\" /* Zone */);\n return zoneService.setVisibilityAsync(/*Dashboard Name*/ this.name, this.zoneMap, dashboardObjectVisibilityMap);\n };\n DashboardImpl.prototype.getDashboardObjectById = function (dashboardObjectId) {\n return this.zoneMap.get(dashboardObjectId);\n };\n DashboardImpl.prototype.updateZones = function (newZones, newActiveZoneId, newActiveDashboardName) {\n var _this = this;\n if (newActiveZoneId === void 0) { newActiveZoneId = 0; }\n if (newActiveDashboardName === void 0) { newActiveDashboardName = ''; }\n // getting previous dashboard objects, active zone ID and active dashboard name\n var oldDashboardObjects = this._objects;\n var oldZoneMap = this.zoneMap;\n var oldActiveZoneId = this._activeDashboardObjectId;\n var oldActiveDashboardName = this._sheetPath.sheetName;\n // updating zones and reinitializing instance variables\n this._zones = newZones;\n this._activeDashboardObjectId = newActiveZoneId;\n this._sheetPath.sheetName = newActiveDashboardName;\n this._sheetInfoImpl.name = newActiveDashboardName;\n this.initializeWithPublicInterfaces();\n // getting new dashboard objects\n var newDashboardObjects = this._objects;\n var newZoneMap = this.zoneMap;\n // initializing map for changes\n var zoneChanges = new Map();\n // comparing old dashboard objects with new ones\n oldDashboardObjects.forEach(function (oldObject) {\n var oldId = oldObject.id;\n // checking if zone was removed\n if (!newZoneMap.has(oldId)) {\n _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.Removed);\n return;\n }\n var newObject = newZoneMap.get(oldId);\n if (oldObject.isFloating !== newObject.isFloating) {\n _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.IsFloatingChanged);\n }\n if (oldObject.isVisible !== newObject.isVisible) {\n _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.IsVisibleChanged);\n }\n if (oldObject.name !== newObject.name) {\n _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.NameChanged);\n }\n if (oldObject.position.x !== newObject.position.x || oldObject.position.y !== newObject.position.y) {\n _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.PositionChanged);\n }\n if (oldObject.size.width !== newObject.size.width || oldObject.size.height !== newObject.size.height) {\n _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.SizeChanged);\n }\n });\n // Checking for any added zones\n newDashboardObjects.forEach(function (newObject) {\n if (!oldZoneMap.has(newObject.id)) {\n _this.addChange(newObject.id, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.Added);\n }\n });\n // Checking if zone selection has changed\n if (oldActiveZoneId !== newActiveZoneId) {\n if (newActiveZoneId !== 0) {\n this.addChange(newActiveZoneId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.Selected);\n }\n if (oldActiveZoneId !== 0) {\n this.addChange(oldActiveZoneId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.Deselected);\n }\n }\n // Checking if switched to another dashboard\n if (oldActiveDashboardName !== newActiveDashboardName) {\n this.addChange(0, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.DashboardChanged);\n }\n return zoneChanges;\n };\n DashboardImpl.prototype.addChange = function (zoneId, zoneChanges, change) {\n if (!zoneChanges.has(zoneId)) {\n zoneChanges.set(zoneId, []);\n }\n zoneChanges.get(zoneId).push(change);\n };\n DashboardImpl.prototype.moveAndResizeDashboardObjectsAsync = function (dashboardObjectPositionAndSizeUpdateArray) {\n var zoneService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"zone-service\" /* Zone */);\n return zoneService.moveAndResizeAsync(/*Dashboard Name*/ this.name, this.zoneMap, dashboardObjectPositionAndSizeUpdateArray);\n };\n DashboardImpl.prototype.replayAnimationAsync = function (replaySpeed) {\n var animationService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"animation-service\" /* Animation */);\n return animationService.replayAsync(replaySpeed);\n };\n DashboardImpl.prototype.getFiltersAsync = function () {\n this.verifyActiveSheetOrEmbeddedInActiveStoryPoint();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.getDashboardFiltersAsync();\n };\n DashboardImpl.prototype.applyFilterAsync = function (fieldName, values, updateType, options) {\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(updateType, Contract.FilterUpdateType, 'FilterUpdateType');\n ErrorHelpers_1.ErrorHelpers.verifyStringParameter(fieldName, 'fieldName');\n if (!Array.isArray(values)) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'values parameter for applyDashboardFilterAsync must be an array');\n }\n this.verifyActiveSheetOrEmbeddedInActiveStoryPoint();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.applyDashboardFilterAsync(fieldName, values, updateType, options);\n };\n // @W-12986439: remove once initializeWithPublicInterfaces is moved to the constructor for this class\n // This method only exists since worksheetsImpl can be undefined, but we need the worksheet names in the Export APIs\n DashboardImpl.prototype.getWorksheetNamesFromZones = function () {\n var worksheetNames = [];\n for (var _i = 0, _a = this._zones; _i < _a.length; _i++) {\n var zone = _a[_i];\n if (zone.zoneType !== api_internal_contract_js_1.DashboardObjectType.Worksheet) {\n continue;\n }\n // zone.sheetInfo was not initialized prior to internal-contract 1.6.0\n var worksheetName = zone.sheetInfo ? zone.sheetInfo.name : zone.name;\n worksheetNames.push(worksheetName);\n }\n return worksheetNames;\n };\n DashboardImpl.prototype.verifyActiveSheetOrEmbeddedInActiveStoryPoint = function () {\n var isRootAndActiveDashboard = this.active;\n var isWithinActiveStoryPoint = this.parentStoryPoint != null && this.parentStoryPoint.active;\n if (!isRootAndActiveDashboard && !isWithinActiveStoryPoint) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.NotActiveSheet, 'Operation not allowed on non-active sheet');\n }\n };\n return DashboardImpl;\n}(SheetImpl_1.SheetImpl));\nexports.DashboardImpl = DashboardImpl;\n//# sourceMappingURL=DashboardImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Implementation of the dashboard objects - the zones in a dashboard.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nvar DashboardObjectImpl = /** @class */ (function () {\n function DashboardObjectImpl(_dashboardImpl, _type, _position, _size, _worksheetImpl, _name, _isFloating, _isVisible, _id, _fieldId) {\n this._dashboardImpl = _dashboardImpl;\n this._type = _type;\n this._position = _position;\n this._size = _size;\n this._worksheetImpl = _worksheetImpl;\n this._name = _name;\n this._isFloating = _isFloating;\n this._isVisible = _isVisible;\n this._id = _id;\n this._fieldId = _fieldId;\n }\n Object.defineProperty(DashboardObjectImpl.prototype, \"dashboardImpl\", {\n get: function () {\n return this._dashboardImpl;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObjectImpl.prototype, \"type\", {\n get: function () {\n return this._type;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObjectImpl.prototype, \"position\", {\n get: function () {\n return this._position;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObjectImpl.prototype, \"size\", {\n get: function () {\n return this._size;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObjectImpl.prototype, \"worksheetImpl\", {\n get: function () {\n return this._worksheetImpl;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObjectImpl.prototype, \"name\", {\n get: function () {\n return this._name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObjectImpl.prototype, \"isFloating\", {\n get: function () {\n return this._isFloating;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObjectImpl.prototype, \"isVisible\", {\n get: function () {\n return this._isVisible;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObjectImpl.prototype, \"id\", {\n get: function () {\n return this._id;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DashboardObjectImpl.prototype, \"fieldId\", {\n get: function () {\n return this._fieldId;\n },\n enumerable: true,\n configurable: true\n });\n return DashboardObjectImpl;\n}());\nexports.DashboardObjectImpl = DashboardObjectImpl;\n//# sourceMappingURL=DashboardObjectImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar ConnectionSummary_1 = require(\"../ConnectionSummary\");\nvar Field_1 = require(\"../Field\");\nvar LogicalTable_1 = require(\"../LogicalTable\");\nvar ServiceRegistry_1 = require(\"../Services/ServiceRegistry\");\nvar TableSummary_1 = require(\"../TableSummary\");\nvar ErrorHelpers_1 = require(\"../Utils/ErrorHelpers\");\nvar FieldImpl_1 = require(\"./FieldImpl\");\nvar DataSourceImpl = /** @class */ (function () {\n function DataSourceImpl(_dataSourceInfo, _registryId) {\n var _this = this;\n this._dataSourceInfo = _dataSourceInfo;\n this._registryId = _registryId;\n this._fields = _dataSourceInfo.fields.map(function (fieldModel) {\n var fieldImpl = new FieldImpl_1.FieldImpl(fieldModel, _this);\n return new Field_1.Field(fieldImpl);\n });\n }\n Object.defineProperty(DataSourceImpl.prototype, \"name\", {\n get: function () {\n return this._dataSourceInfo.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataSourceImpl.prototype, \"id\", {\n get: function () {\n return this._dataSourceInfo.id;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataSourceImpl.prototype, \"extractUpdateTime\", {\n get: function () {\n return this._dataSourceInfo.extractUpdateTime;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataSourceImpl.prototype, \"fields\", {\n get: function () {\n return this._fields;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataSourceImpl.prototype, \"isExtract\", {\n get: function () {\n return this._dataSourceInfo.isExtract;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataSourceImpl.prototype, \"isPublished\", {\n get: function () {\n return this._dataSourceInfo.isPublished;\n },\n enumerable: true,\n configurable: true\n });\n DataSourceImpl.prototype.publishedUrl = function () {\n return this._dataSourceInfo.publishedUrl;\n };\n DataSourceImpl.prototype.getMaxPageRowLimit = function () {\n return 10000;\n };\n DataSourceImpl.prototype.refreshAsync = function () {\n var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"data-source-service\" /* DataSourceService */);\n return dataSourceService.refreshAsync(this._dataSourceInfo.id);\n };\n DataSourceImpl.prototype.getConnectionSummariesAsync = function () {\n var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"data-source-service\" /* DataSourceService */);\n return dataSourceService.getConnectionSummariesAsync(this._dataSourceInfo.id).then(function (summaries) {\n return summaries.map(function (summary) { return new ConnectionSummary_1.ConnectionSummary(summary); });\n });\n };\n DataSourceImpl.prototype.getActiveTablesAsync = function () {\n var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"data-source-service\" /* DataSourceService */);\n return dataSourceService.getActiveTablesAsync(this._dataSourceInfo.id).then(function (tableInfos) {\n return tableInfos.map(function (tableInfo) { return new TableSummary_1.TableSummary(tableInfo); });\n });\n };\n DataSourceImpl.prototype.getUnderlyingDataAsync = function (options) {\n var getDataService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n options = options || {};\n return getDataService.getDataSourceDataAsync(this.id, !!options.ignoreAliases, options.maxRows || 0, // 0 and [] are defaults\n options.columnsToInclude || [], options.columnsToIncludeById || [], options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues);\n };\n DataSourceImpl.prototype.getLogicalTableDataAsync = function (logicalTableId, options) {\n var getDataService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n options = options || {};\n return getDataService.getLogicalTableDataAsync(this.id, logicalTableId, !!options.ignoreAliases, options.maxRows || 0, // 0 and [] are defaults\n options.columnsToInclude || [], options.columnsToIncludeById || [], options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues);\n };\n DataSourceImpl.prototype.getLogicalTableDataReaderAsync = function (logicalTableId, pageRowCount, options) {\n var getDataService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n options = options || {};\n return getDataService.getLogicalTableDataReaderAsync(this.id, logicalTableId, pageRowCount || this.getMaxPageRowLimit(), !!options.ignoreAliases, options.columnsToIncludeById || [], options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues);\n };\n DataSourceImpl.prototype.initializeWithPublicInterfaces = function (dataSource) {\n ErrorHelpers_1.ErrorHelpers.verifyInternalValue(dataSource, 'dataSource');\n this._fields = this._dataSourceInfo.fields.map(function (fieldModel) {\n var fieldImpl = new FieldImpl_1.FieldImpl(fieldModel, dataSource);\n return new Field_1.Field(fieldImpl);\n });\n };\n DataSourceImpl.prototype.getLogicalTablesAsync = function () {\n var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"data-source-service\" /* DataSourceService */);\n return dataSourceService.getLogicalTablesAsync(this.id).then(function (logicalTableInfos) {\n return logicalTableInfos.map(function (logicalTableInfo) { return new LogicalTable_1.LogicalTable(logicalTableInfo); });\n });\n };\n return DataSourceImpl;\n}());\nexports.DataSourceImpl = DataSourceImpl;\n//# sourceMappingURL=DataSourceImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar InternalContract = require(\"@tableau/api-internal-contract-js\");\nvar InternalToExternalEnumMappings_1 = require(\"../EnumMappings/InternalToExternalEnumMappings\");\nvar FieldImpl = /** @class */ (function () {\n function FieldImpl(_fieldInfo, _parentDataSource) {\n this._fieldInfo = _fieldInfo;\n this._parentDataSource = _parentDataSource;\n }\n Object.defineProperty(FieldImpl.prototype, \"name\", {\n get: function () {\n return this._fieldInfo.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"id\", {\n get: function () {\n return this._fieldInfo.id;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"description\", {\n get: function () {\n return this._fieldInfo.description;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"dataType\", {\n get: function () {\n var _a;\n return _a = this._fieldInfo.dataType, (_a !== null && _a !== void 0 ? _a : Contract.DataType.Unknown);\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"aggregation\", {\n get: function () {\n return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.fieldAggregationType.convert(this._fieldInfo.aggregation);\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"dataSource\", {\n get: function () {\n if (!this._parentDataSource)\n throw new Error(\"Data source information is not available for this field. Please use getFieldAsync method to get field's data source information\");\n return this._parentDataSource;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"role\", {\n get: function () {\n return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.fieldRoleType.convert(this._fieldInfo.role);\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"columnType\", {\n get: function () {\n var definedValue = this._fieldInfo.columnType || InternalContract.ColumnType.Unknown;\n return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.columnType.convert(definedValue);\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"isCalculatedField\", {\n get: function () {\n return this._fieldInfo.isCalculatedField;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"isCombinedField\", {\n get: function () {\n return this._fieldInfo.isCombinedField;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"isGenerated\", {\n get: function () {\n return this._fieldInfo.isGenerated;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"isGeospatial\", {\n get: function () {\n return this._fieldInfo.isGeospatial;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"isHidden\", {\n get: function () {\n return this._fieldInfo.isHidden;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(FieldImpl.prototype, \"isPresentOnPublishedDatasource\", {\n get: function () {\n return this._fieldInfo.isPresentOnPublishedDatasource;\n },\n enumerable: true,\n configurable: true\n });\n return FieldImpl;\n}());\nexports.FieldImpl = FieldImpl;\n//# sourceMappingURL=FieldImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar InternalToExternalEnumMappings_1 = require(\"../EnumMappings/InternalToExternalEnumMappings\");\nvar ServiceRegistry_1 = require(\"../Services/ServiceRegistry\");\nvar DataValueFactory_1 = require(\"../Utils/DataValueFactory\");\nvar ErrorHelpers_1 = require(\"../Utils/ErrorHelpers\");\nvar Param_1 = require(\"../Utils/Param\");\nvar ParameterImpl = /** @class */ (function () {\n function ParameterImpl(parameterInfo, _registryId) {\n this._registryId = _registryId;\n this.setParameterInfo(parameterInfo);\n }\n Object.defineProperty(ParameterImpl.prototype, \"name\", {\n get: function () {\n return this._parameterInfo.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ParameterImpl.prototype, \"currentValue\", {\n get: function () {\n return DataValueFactory_1.DataValueFactory.MakeParameterDataValue(this._parameterInfo.currentValue, this._parameterInfo.dataType);\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ParameterImpl.prototype, \"dataType\", {\n get: function () {\n return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dataType.convert(this._parameterInfo.dataType);\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ParameterImpl.prototype, \"id\", {\n get: function () {\n return this._globalFieldName;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ParameterImpl.prototype, \"allowableValues\", {\n get: function () {\n return this._allowableValues;\n },\n enumerable: true,\n configurable: true\n });\n ParameterImpl.prototype.changeValueAsync = function (newValue) {\n var _this = this;\n ErrorHelpers_1.ErrorHelpers.verifyParameter(newValue, 'newValue');\n var coercedValue = Param_1.Param.serializeParameterValue(newValue);\n var parametersService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"parameters-service\" /* Parameters */);\n return parametersService.changeParameterValueAsync(this._globalFieldName, coercedValue).then(function (parameterInfo) {\n _this.setParameterInfo(parameterInfo);\n return _this.currentValue;\n });\n };\n ParameterImpl.prototype.setParameterInfo = function (parameterInfo) {\n this._parameterInfo = parameterInfo;\n this._globalFieldName = parameterInfo.fieldName;\n var type = InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.allowableValues.convert(parameterInfo.allowableValuesType);\n var listValues;\n var minValue;\n var maxValue;\n var stepSize;\n var dateStepPeriod;\n if (type === api_external_contract_js_1.ParameterValueType.List) {\n var values = parameterInfo.allowableValues || [];\n listValues = values.map(function (val) { return DataValueFactory_1.DataValueFactory.MakeParameterDataValue(val, parameterInfo.dataType); });\n }\n else if (type === api_external_contract_js_1.ParameterValueType.Range) {\n minValue = parameterInfo.minValue && DataValueFactory_1.DataValueFactory.MakeParameterDataValue(parameterInfo.minValue, parameterInfo.dataType);\n maxValue = parameterInfo.maxValue && DataValueFactory_1.DataValueFactory.MakeParameterDataValue(parameterInfo.maxValue, parameterInfo.dataType);\n stepSize = parameterInfo.stepSize;\n dateStepPeriod = parameterInfo.dateStepPeriod && InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dateStepPeriod.convert(parameterInfo.dateStepPeriod);\n }\n this._allowableValues = {\n type: type,\n allowableValues: listValues,\n minValue: minValue,\n maxValue: maxValue,\n stepSize: stepSize,\n dateStepPeriod: dateStepPeriod,\n };\n };\n return ParameterImpl;\n}());\nexports.ParameterImpl = ParameterImpl;\n//# sourceMappingURL=ParameterImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar ServiceRegistry_1 = require(\"../Services/ServiceRegistry\");\nvar TableauError_1 = require(\"../TableauError\");\nvar ErrorHelpers_1 = require(\"../Utils/ErrorHelpers\");\nvar Param_1 = require(\"../Utils/Param\");\nvar SheetUtils_1 = require(\"../Utils/SheetUtils\");\nvar SheetImpl = /** @class */ (function () {\n function SheetImpl(_sheetInfoImpl, _registryId) {\n this._sheetInfoImpl = _sheetInfoImpl;\n this._registryId = _registryId;\n }\n Object.defineProperty(SheetImpl.prototype, \"name\", {\n get: function () {\n return this._sheetInfoImpl.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetImpl.prototype, \"sheetType\", {\n get: function () {\n return this._sheetInfoImpl.sheetType;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetImpl.prototype, \"sheetPath\", {\n get: function () {\n return this._sheetInfoImpl.sheetPath;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetImpl.prototype, \"size\", {\n get: function () {\n return this._sheetInfoImpl.sheetSize;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetImpl.prototype, \"hidden\", {\n get: function () {\n if (this._sheetInfoImpl.isHidden !== undefined) {\n return this._sheetInfoImpl.isHidden;\n }\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.ImplementationError, \"isHidden not implemented\");\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetImpl.prototype, \"active\", {\n get: function () {\n if (this._sheetInfoImpl.isActive !== undefined) {\n return this._sheetInfoImpl.isActive;\n }\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.ImplementationError, \"active not implemented\");\n },\n set: function (active) {\n if (this._sheetInfoImpl.isActive !== undefined) {\n this._sheetInfoImpl.active = active;\n }\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetImpl.prototype, \"index\", {\n get: function () {\n if (this._sheetInfoImpl.index !== undefined) {\n return this._sheetInfoImpl.index;\n }\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.ImplementationError, \"index not implemented\");\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetImpl.prototype, \"url\", {\n get: function () {\n if (this._sheetInfoImpl.url !== undefined) {\n return this._sheetInfoImpl.url;\n }\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.ImplementationError, \"url not implemented\");\n },\n enumerable: true,\n configurable: true\n });\n SheetImpl.prototype.getSheetSize = function () {\n if (!SheetUtils_1.SheetUtils.isValidSheetSize(this.size)) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InternalError, 'size is not of type SheetSize');\n }\n return this.size;\n };\n SheetImpl.prototype.findParameterAsync = function (parameterName) {\n ErrorHelpers_1.ErrorHelpers.verifyParameter(parameterName, 'parameterName');\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"parameters-service\" /* Parameters */);\n return service.findParameterByNameAsync(parameterName);\n };\n SheetImpl.prototype.getParametersAsync = function () {\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"parameters-service\" /* Parameters */);\n return service.getParametersForSheetAsync(this.sheetPath);\n };\n SheetImpl.prototype.changeSizeAsync = function (newSize) {\n var _this = this;\n var invalidSizeError = new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Invalid sheet size parameter');\n if (!newSize || !newSize.behavior) {\n throw invalidSizeError;\n }\n var partialSheetSize = this.normalizeSheetSize(newSize);\n var isAutomatic = partialSheetSize.behavior === Contract.SheetSizeBehavior.Automatic;\n if (!isAutomatic && !partialSheetSize.minSize && !partialSheetSize.maxSize) {\n throw invalidSizeError;\n }\n if (!isAutomatic && this.sheetType === Contract.SheetType.Worksheet) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSizeBehaviorOnWorksheet, 'Only SheetSizeBehavior.Automatic is allowed on Worksheets');\n }\n if (isAutomatic && this.getSheetSize().behavior === partialSheetSize.behavior) {\n return Promise.resolve(newSize);\n }\n var processedNewSize = this.processNewSize(partialSheetSize);\n var sizeService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"size-service\" /* Size */);\n return sizeService.changeSizeAsync(this.name, processedNewSize).then(function () {\n var clientInfoService = ServiceRegistry_1.ApiServiceRegistry.get(_this._registryId).getService(\"client-info-service\" /* ClientInfo */);\n return clientInfoService.getClientInfoAsync().then(function (bootstrapInfo) {\n var sheet = bootstrapInfo.publishedSheets.find(function (s) { return s.name === _this.name; });\n if (!sheet) {\n throw new TableauError_1.TableauError(Contract.SharedErrorCodes.InternalError, \"Can't find sheet with name \" + _this.name);\n }\n var sheetSize = SheetUtils_1.SheetUtils.getSheetSizeFromSizeConstraints(sheet.sizeConstraint);\n _this._sheetInfoImpl.sheetSize = sheetSize;\n return sheetSize;\n });\n });\n };\n SheetImpl.prototype.normalizeSheetSize = function (newSize) {\n var behavior = newSize.behavior;\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(behavior, Contract.SheetSizeBehavior, 'SheetSizeBehavior');\n var minSize = SheetImpl.parseDimensions(newSize.minSize);\n var maxSize = SheetImpl.parseDimensions(newSize.maxSize);\n return { behavior: behavior, minSize: minSize, maxSize: maxSize };\n };\n SheetImpl.prototype.processNewSize = function (newSize) {\n var _a, _b, _c, _d;\n var behavior = newSize.behavior, minSizeMaybe = newSize.minSize, maxSizeMaybe = newSize.maxSize;\n var hasMinWidth = !Param_1.Param.isNullOrUndefined((_a = minSizeMaybe) === null || _a === void 0 ? void 0 : _a.width);\n var hasMinHeight = !Param_1.Param.isNullOrUndefined((_b = minSizeMaybe) === null || _b === void 0 ? void 0 : _b.height);\n var hasMaxWidth = !Param_1.Param.isNullOrUndefined((_c = maxSizeMaybe) === null || _c === void 0 ? void 0 : _c.width);\n var hasMaxHeight = !Param_1.Param.isNullOrUndefined((_d = maxSizeMaybe) === null || _d === void 0 ? void 0 : _d.height);\n var hasValidMinSize = hasMinWidth && hasMinHeight;\n var hasValidMaxSize = hasMaxWidth && hasMaxHeight;\n switch (behavior) {\n case Contract.SheetSizeBehavior.Automatic: {\n return { behavior: behavior };\n }\n case Contract.SheetSizeBehavior.AtMost: {\n if (!maxSizeMaybe || !hasValidMaxSize) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.MissingMaxSize, 'Missing maxSize for SheetSizeBehavior.AtMost');\n }\n var maxSize = { width: maxSizeMaybe.width, height: maxSizeMaybe.height };\n if (maxSize.width < 0 || maxSize.height < 0) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Size value cannot be less than zero');\n }\n return { behavior: behavior, maxSize: maxSize };\n }\n case Contract.SheetSizeBehavior.AtLeast: {\n if (!minSizeMaybe || !hasValidMinSize) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.MissingMinSize, 'Missing minSize for SheetSizeBehavior.AtLeast');\n }\n var minSize = { width: minSizeMaybe.width, height: minSizeMaybe.height };\n if (minSize.width < 0 || minSize.height < 0) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Size value cannot be less than zero');\n }\n return { behavior: behavior, minSize: minSize };\n }\n case Contract.SheetSizeBehavior.Range: {\n if (!minSizeMaybe || !maxSizeMaybe || !hasValidMinSize || !hasValidMaxSize) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.MissingMinMaxSize, 'Missing minSize or maxSize for SheetSizeBehavior.Range');\n }\n var minSize = { width: minSizeMaybe.width, height: minSizeMaybe.height };\n var maxSize = { width: maxSizeMaybe.width, height: maxSizeMaybe.height };\n if (minSize.width < 0 ||\n minSize.height < 0 ||\n maxSize.width < 0 ||\n maxSize.height < 0 ||\n minSize.width > maxSize.width ||\n minSize.height > maxSize.height) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Missing minSize or maxSize for SheetSizeBehavior.Range');\n }\n return { behavior: behavior, minSize: minSize, maxSize: maxSize };\n }\n case Contract.SheetSizeBehavior.Exactly: {\n if (minSizeMaybe && maxSizeMaybe) {\n if (hasValidMinSize && hasValidMaxSize) {\n var minSize = { width: minSizeMaybe.width, height: minSizeMaybe.height };\n var maxSize = { width: maxSizeMaybe.width, height: maxSizeMaybe.height };\n if (minSize.width !== maxSize.width || minSize.height !== maxSize.height) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Conflicting size values for SheetSizeBehavior.Exactly');\n }\n return { behavior: behavior, minSize: minSize, maxSize: maxSize };\n }\n if (hasValidMinSize) {\n var minSize = { width: minSizeMaybe.width, height: minSizeMaybe.height };\n return { behavior: behavior, minSize: minSize, maxSize: minSize };\n }\n if (hasValidMaxSize) {\n var maxSize = { width: maxSizeMaybe.width, height: maxSizeMaybe.height };\n return { behavior: behavior, minSize: maxSize, maxSize: maxSize };\n }\n }\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Invalid sheet size parameter');\n }\n default: {\n throw new TableauError_1.TableauError(Contract.SharedErrorCodes.InternalError, \"Unsupported sheet size behavior: \" + behavior);\n }\n }\n };\n SheetImpl.parseDimensions = function (size) {\n var empty = { width: undefined, height: undefined };\n if (!size) {\n return empty;\n }\n var _a = Param_1.Param.tryParseNumber(size.width), widthParsed = _a.success, parsedWidth = _a.parsed;\n var _b = Param_1.Param.tryParseNumber(size.height), heightParsed = _b.success, parsedHeight = _b.parsed;\n if (widthParsed && heightParsed) {\n return { width: parsedWidth, height: parsedHeight };\n }\n if (widthParsed) {\n return { width: parsedWidth };\n }\n if (heightParsed) {\n return { height: parsedHeight };\n }\n return empty;\n };\n return SheetImpl;\n}());\nexports.SheetImpl = SheetImpl;\n//# sourceMappingURL=SheetImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar SheetInfoImpl = /** @class */ (function () {\n function SheetInfoImpl(_name, _sheetType, _sheetSize, _index, _isActive, _isHidden, _url) {\n this._name = _name;\n this._sheetType = _sheetType;\n this._sheetSize = _sheetSize;\n this._index = _index;\n this._isActive = _isActive;\n this._isHidden = _isHidden;\n this._url = _url;\n }\n Object.defineProperty(SheetInfoImpl.prototype, \"name\", {\n get: function () {\n return this._name;\n },\n set: function (sheetName) {\n this._name = sheetName;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetInfoImpl.prototype, \"sheetSize\", {\n get: function () {\n return this._sheetSize;\n },\n set: function (value) {\n this._sheetSize = value;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetInfoImpl.prototype, \"sheetType\", {\n get: function () {\n return this._sheetType;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetInfoImpl.prototype, \"sheetPath\", {\n get: function () {\n return {\n sheetName: this.name,\n isDashboard: this.sheetType === api_external_contract_js_1.SheetType.Dashboard,\n };\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetInfoImpl.prototype, \"index\", {\n get: function () {\n return this._index;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetInfoImpl.prototype, \"isActive\", {\n get: function () {\n return this._isActive;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetInfoImpl.prototype, \"active\", {\n set: function (active) {\n this._isActive = active;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetInfoImpl.prototype, \"isHidden\", {\n get: function () {\n return this._isHidden;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(SheetInfoImpl.prototype, \"url\", {\n get: function () {\n return this._url;\n },\n enumerable: true,\n configurable: true\n });\n return SheetInfoImpl;\n}());\nexports.SheetInfoImpl = SheetInfoImpl;\n//# sourceMappingURL=SheetInfoImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * This class implements the SingleEventManager interface for a single type of Tableau event\n *\n * @template TEventType The Tableau event type this class specializes\n */\nvar SingleEventManagerImpl = /** @class */ (function () {\n function SingleEventManagerImpl(eventType) {\n this._eventType = eventType;\n this._handlers = [];\n }\n Object.defineProperty(SingleEventManagerImpl.prototype, \"eventType\", {\n get: function () {\n return this._eventType;\n },\n enumerable: true,\n configurable: true\n });\n SingleEventManagerImpl.prototype.addEventListener = function (handler) {\n var _this = this;\n this._handlers.push(handler);\n return function () { return _this.removeEventListener(handler); };\n };\n SingleEventManagerImpl.prototype.removeEventListener = function (handler) {\n var beforeCount = this._handlers.length;\n this._handlers = this._handlers.filter(function (h) { return h !== handler; });\n return beforeCount > this._handlers.length;\n };\n SingleEventManagerImpl.prototype.triggerEvent = function (eventGenerator) {\n for (var _i = 0, _a = this._handlers; _i < _a.length; _i++) {\n var handler = _a[_i];\n try {\n var eventModel = eventGenerator();\n handler(eventModel);\n }\n catch (e) {\n // Since this handler could be outside our control, just catch anything it throws and continue on\n continue;\n }\n }\n };\n return SingleEventManagerImpl;\n}());\nexports.SingleEventManagerImpl = SingleEventManagerImpl;\n//# sourceMappingURL=SingleEventManagerImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar ServiceRegistry_1 = require(\"../Services/ServiceRegistry\");\nvar TableauError_1 = require(\"../TableauError\");\nvar ErrorHelpers_1 = require(\"../Utils/ErrorHelpers\");\nvar ShortLivedDeferred_1 = require(\"../Utils/ShortLivedDeferred\");\nvar SheetImpl_1 = require(\"./SheetImpl\");\nvar StoryPointImpl_1 = require(\"./StoryPointImpl\");\nvar StoryPointInfoImpl_1 = require(\"./StoryPointInfoImpl\");\nvar StoryImpl = /** @class */ (function (_super) {\n __extends(StoryImpl, _super);\n function StoryImpl(_sheetInfoImpl, storyModel, _publishedSheetInfos, _registryId) {\n var _this = _super.call(this, _sheetInfoImpl, _registryId) || this;\n _this._sheetInfoImpl = _sheetInfoImpl;\n _this._publishedSheetInfos = _publishedSheetInfos;\n _this._registryId = _registryId;\n _this._storyPointInfoImpls = [];\n _this._deferred = new ShortLivedDeferred_1.ShortLivedDeferred();\n _this.initializeStory(storyModel);\n return _this;\n }\n StoryImpl.prototype.initializeStory = function (storyModel) {\n var _this = this;\n storyModel.storyPoints.forEach(function (storyPointModel) {\n var isActive = storyPointModel.index === storyModel.activeStoryPointIndex;\n var storyPointInfoImpl = new StoryPointInfoImpl_1.StoryPointInfoImpl(storyPointModel.caption, storyPointModel.index, storyPointModel.storyPointId, isActive, storyPointModel.updated, _this);\n _this._storyPointInfoImpls.push(storyPointInfoImpl);\n if (isActive) {\n _this._activeStoryPointImpl = new StoryPointImpl_1.StoryPointImpl(storyPointInfoImpl, _this._publishedSheetInfos, _this._registryId, storyPointModel.containedSheetInfo);\n }\n });\n };\n StoryImpl.prototype.updateStoryInfo = function (index, storyPointModel) {\n if (!this._storyPointInfoImpls) {\n return;\n }\n var storyInfoImpl = this._storyPointInfoImpls[index];\n if (storyInfoImpl.storyPointId !== storyPointModel.storyPointId) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.StoryPointIdMismatch, \"We should not be updating a story point when the IDs don't match. Existing storyPointID=\" + storyInfoImpl.storyPointId + \", newStoryPointID=\" + storyPointModel.storyPointId);\n }\n storyInfoImpl.caption = storyPointModel.caption;\n storyInfoImpl.updated = storyPointModel.updated;\n if (this._activeStoryPointImpl.storyPointId === storyPointModel.storyPointId) {\n this._activeStoryPointImpl.updated = storyInfoImpl.updated;\n }\n };\n StoryImpl.prototype.updateStory = function (storyPointModel) {\n var _this = this;\n if (!this._storyPointInfoImpls) {\n return;\n }\n this._storyPointInfoImpls.forEach(function (storyPointInfoImpl) {\n var isActive = storyPointInfoImpl.storyPointId === storyPointModel.storyPointId;\n if (isActive) {\n // update the state\n storyPointInfoImpl.caption = storyPointModel.caption;\n storyPointInfoImpl.index = storyPointModel.index;\n storyPointInfoImpl.active = true;\n storyPointInfoImpl.updated = storyPointModel.updated;\n // re-initialize activeStoryPointImpl\n _this._activeStoryPointImpl = new StoryPointImpl_1.StoryPointImpl(storyPointInfoImpl, _this._publishedSheetInfos, _this._registryId, storyPointModel.containedSheetInfo);\n }\n else {\n // set old ones to false\n storyPointInfoImpl.active = false;\n }\n });\n if (this.activeStoryPoint) {\n this._deferred.resolve(this.activeStoryPoint);\n }\n };\n Object.defineProperty(StoryImpl.prototype, \"activeStoryPoint\", {\n get: function () {\n return this._activeStoryPointImpl;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryImpl.prototype, \"storyPointsInfo\", {\n get: function () {\n return this._storyPointInfoImpls;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryImpl.prototype, \"isActive\", {\n get: function () {\n return this._sheetInfoImpl.active;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryImpl.prototype, \"isHidden\", {\n get: function () {\n return !!this._sheetInfoImpl.isHidden;\n },\n enumerable: true,\n configurable: true\n });\n StoryImpl.prototype.activateNextStoryPointAsync = function () {\n if (this._activeStoryPointImpl.index === this._storyPointInfoImpls.length - 1) {\n return Promise.resolve(this._activeStoryPointImpl);\n }\n var promise = this._deferred.getNewPromiseOrThrowIfBusy();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"story-activation-service\" /* StoryActivation */);\n service.activateNextStoryPointAsync();\n return promise;\n };\n StoryImpl.prototype.activatePreviousStoryPointAsync = function () {\n if (this._activeStoryPointImpl.index === 0) {\n return Promise.resolve(this._activeStoryPointImpl);\n }\n var promise = this._deferred.getNewPromiseOrThrowIfBusy();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"story-activation-service\" /* StoryActivation */);\n service.activatePreviousStoryPointAsync();\n return promise;\n };\n StoryImpl.prototype.activateStoryPointAsync = function (index) {\n ErrorHelpers_1.ErrorHelpers.verifyParameter(index, 'index');\n ErrorHelpers_1.ErrorHelpers.verifyParameterType(index, 'number', 'index');\n if (index < 0 || index >= this._storyPointInfoImpls.length) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.IndexOutOfRange, 'The index passed to this command is out of range.');\n }\n if (index === this._activeStoryPointImpl.index) {\n return Promise.resolve(this._activeStoryPointImpl);\n }\n var promise = this._deferred.getNewPromiseOrThrowIfBusy();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"story-activation-service\" /* StoryActivation */);\n service.activateStoryPointAsync(index);\n return promise;\n };\n StoryImpl.prototype.revertStoryPointAsync = function (index) {\n var _this = this;\n ErrorHelpers_1.ErrorHelpers.verifyParameter(index, 'index');\n ErrorHelpers_1.ErrorHelpers.verifyParameterType(index, 'number', 'index');\n if (index < 0 || index >= this._storyPointInfoImpls.length) {\n throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.IndexOutOfRange, 'The index passed to this command is out of range.');\n }\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"story-activation-service\" /* StoryActivation */);\n return service.revertStoryPointAsync(index).then(function (response) {\n _this.updateStoryInfo(response.index, response);\n var storyPointInfoImpl = new StoryPointInfoImpl_1.StoryPointInfoImpl(response.caption, response.index, response.storyPointId, false, response.updated, _this);\n return storyPointInfoImpl;\n });\n };\n StoryImpl.prototype.clearPendingPromises = function () {\n if (this._deferred) {\n this._deferred.reject('All pending promises cleared');\n }\n };\n return StoryImpl;\n}(SheetImpl_1.SheetImpl));\nexports.StoryImpl = StoryImpl;\n//# sourceMappingURL=StoryImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar TableauError_1 = require(\"../TableauError\");\nvar SheetUtils_1 = require(\"../Utils/SheetUtils\");\nvar DashboardImpl_1 = require(\"./DashboardImpl\");\nvar SheetInfoImpl_1 = require(\"./SheetInfoImpl\");\nvar WorksheetImpl_1 = require(\"./WorksheetImpl\");\nvar StoryPointImpl = /** @class */ (function () {\n function StoryPointImpl(_storyPointInfoImpl, sheetInfos, registryId, containedSheetInfo) {\n this._storyPointInfoImpl = _storyPointInfoImpl;\n if (containedSheetInfo) {\n this._containedSheetImpl = this.createContainedSheet(containedSheetInfo, sheetInfos, registryId);\n }\n }\n Object.defineProperty(StoryPointImpl.prototype, \"index\", {\n get: function () {\n return this._storyPointInfoImpl.index;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointImpl.prototype, \"caption\", {\n get: function () {\n return this._storyPointInfoImpl.caption;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointImpl.prototype, \"active\", {\n get: function () {\n return this._storyPointInfoImpl.active;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointImpl.prototype, \"updated\", {\n get: function () {\n return this._storyPointInfoImpl.updated;\n },\n set: function (updated) {\n this._storyPointInfoImpl.updated = updated;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointImpl.prototype, \"parentStory\", {\n get: function () {\n return this._storyPointInfoImpl.parentStory;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointImpl.prototype, \"containedSheet\", {\n get: function () {\n return this._containedSheetImpl;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointImpl.prototype, \"storyPointId\", {\n get: function () {\n return this._storyPointInfoImpl.storyPointId;\n },\n enumerable: true,\n configurable: true\n });\n StoryPointImpl.prototype.createContainedSheet = function (containedSheetInfo, sheetInfos, registryId) {\n var containedSheetIdx = -1;\n var publishedSheetInfo = SheetUtils_1.SheetUtils.getPublishedSheetInfoByName(containedSheetInfo.name, sheetInfos);\n var containedSheetSize = SheetUtils_1.SheetUtils.createAutomaticSize();\n var isContainedSheetHidden = publishedSheetInfo === undefined;\n var containedSheetUrl = publishedSheetInfo ? publishedSheetInfo.url : '';\n // Contained sheets aren't active - the containing sheet is active.\n var containedSheetActive = false;\n var containedSheetInfoImpl = new SheetInfoImpl_1.SheetInfoImpl(containedSheetInfo.name, SheetUtils_1.SheetUtils.getSheetTypeEnum(containedSheetInfo.sheetType), containedSheetSize, containedSheetIdx, containedSheetActive, isContainedSheetHidden, containedSheetUrl);\n var sheetImpl;\n switch (containedSheetInfoImpl.sheetType) {\n case Contract.SheetType.Worksheet: {\n var vizId = {\n worksheet: containedSheetInfoImpl.name,\n };\n sheetImpl = new WorksheetImpl_1.WorksheetImpl(containedSheetInfoImpl, registryId, vizId, null, this);\n break;\n }\n case Contract.SheetType.Dashboard: {\n var sheetPath = {\n sheetName: containedSheetInfoImpl.name,\n isDashboard: true,\n };\n sheetImpl = new DashboardImpl_1.DashboardImpl(containedSheetInfoImpl, containedSheetInfo.dashboardZones, sheetPath, registryId, this);\n break;\n }\n default: {\n throw new TableauError_1.TableauError(Contract.SharedErrorCodes.ServerError, 'Invalid SheetType');\n }\n }\n return sheetImpl;\n };\n return StoryPointImpl;\n}());\nexports.StoryPointImpl = StoryPointImpl;\n//# sourceMappingURL=StoryPointImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar StoryPointInfoImpl = /** @class */ (function () {\n function StoryPointInfoImpl(_caption, _index, _storyPointId, _active, _updated, _parentStoryImpl) {\n this._caption = _caption;\n this._index = _index;\n this._storyPointId = _storyPointId;\n this._active = _active;\n this._updated = _updated;\n this._parentStoryImpl = _parentStoryImpl;\n }\n Object.defineProperty(StoryPointInfoImpl.prototype, \"caption\", {\n get: function () {\n return this._caption;\n },\n set: function (caption) {\n this._caption = caption;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointInfoImpl.prototype, \"index\", {\n get: function () {\n return this._index;\n },\n set: function (index) {\n this._index = index;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointInfoImpl.prototype, \"storyPointId\", {\n get: function () {\n return this._storyPointId;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointInfoImpl.prototype, \"active\", {\n get: function () {\n return this._active;\n },\n set: function (isActive) {\n this._active = isActive;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointInfoImpl.prototype, \"updated\", {\n get: function () {\n return this._updated;\n },\n set: function (isUpdated) {\n this._updated = isUpdated;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(StoryPointInfoImpl.prototype, \"parentStory\", {\n get: function () {\n return this._parentStoryImpl;\n },\n enumerable: true,\n configurable: true\n });\n return StoryPointInfoImpl;\n}());\nexports.StoryPointInfoImpl = StoryPointInfoImpl;\n//# sourceMappingURL=StoryPointInfoImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar WorkbookImpl = /** @class */ (function () {\n function WorkbookImpl() {\n }\n return WorkbookImpl;\n}());\nexports.WorkbookImpl = WorkbookImpl;\n//# sourceMappingURL=WorkbookImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar DataSource_1 = require(\"../DataSource\");\nvar LogicalTable_1 = require(\"../LogicalTable\");\nvar GetDataService_1 = require(\"../Services/GetDataService\");\nvar ServiceRegistry_1 = require(\"../Services/ServiceRegistry\");\nvar TableauError_1 = require(\"../TableauError\");\nvar ErrorHelpers_1 = require(\"../Utils/ErrorHelpers\");\nvar DataSourceImpl_1 = require(\"./DataSourceImpl\");\nvar SheetImpl_1 = require(\"./SheetImpl\");\nvar WorksheetImpl = /** @class */ (function (_super) {\n __extends(WorksheetImpl, _super);\n function WorksheetImpl(sheetInfoImpl, _registryId, _visualId, _parentDashboardImpl, _parentStoryPointImpl) {\n var _this = _super.call(this, sheetInfoImpl, _registryId) || this;\n _this._visualId = _visualId;\n _this._parentDashboardImpl = _parentDashboardImpl;\n _this._parentStoryPointImpl = _parentStoryPointImpl;\n return _this;\n }\n Object.defineProperty(WorksheetImpl.prototype, \"parentDashboard\", {\n get: function () {\n return this._parentDashboardImpl;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(WorksheetImpl.prototype, \"parentStoryPoint\", {\n get: function () {\n return this._parentStoryPointImpl;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(WorksheetImpl.prototype, \"visualId\", {\n get: function () {\n return this._visualId;\n },\n enumerable: true,\n configurable: true\n });\n WorksheetImpl.prototype.getMaxPageRowLimit = function () {\n return 10000;\n };\n WorksheetImpl.prototype.applyFilterAsync = function (fieldName, values, updateType, options) {\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(updateType, Contract.FilterUpdateType, 'Contract.FilterUpdateType');\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.applyFilterAsync(this.visualId, fieldName, values, updateType, options);\n };\n WorksheetImpl.prototype.applyRangeFilterAsync = function (fieldName, filterOptions) {\n ErrorHelpers_1.ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n ErrorHelpers_1.ErrorHelpers.verifyParameter(filterOptions, 'filterOptions');\n if (filterOptions.nullOption) {\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(filterOptions.nullOption, api_external_contract_js_1.FilterNullOption, 'FilterNullOption');\n }\n else {\n ErrorHelpers_1.ErrorHelpers.verifyRangeParamType(filterOptions.min, filterOptions.max);\n }\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.applyRangeFilterAsync(this.visualId, fieldName, filterOptions);\n };\n WorksheetImpl.prototype.applyHierarchicalFilterAsync = function (fieldName, values, updateType, options) {\n ErrorHelpers_1.ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n ErrorHelpers_1.ErrorHelpers.verifyParameter(values, 'values');\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(updateType, Contract.FilterUpdateType, 'Contract.FilterUpdateType');\n if (!Array.isArray(values) && !values.levels) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'values parameter for applyHierarchicalFilterAsync must be an array or contain a levels key');\n }\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.applyHierarchicalFilterAsync(this.visualId, fieldName, values, updateType, options);\n };\n WorksheetImpl.prototype.clearFilterAsync = function (fieldName) {\n ErrorHelpers_1.ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.clearFilterAsync(this.visualId, fieldName);\n };\n WorksheetImpl.prototype.applyRelativeDateFilterAsync = function (fieldName, options) {\n ErrorHelpers_1.ErrorHelpers.verifyStringParameter(fieldName, 'fieldName');\n ErrorHelpers_1.ErrorHelpers.verifyParameter(options, 'options');\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(options.periodType, api_external_contract_js_1.PeriodType, 'PeriodType');\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(options.rangeType, api_external_contract_js_1.DateRangeType, 'DateRangeType');\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.applyRelativeDateFilterAsync(this.visualId, fieldName, options);\n };\n WorksheetImpl.prototype.getDataSourcesAsync = function () {\n var _this = this;\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"data-source-service\" /* DataSourceService */);\n return service.getDataSourcesAsync(this.visualId).then(function (result) {\n var dataSchema = result;\n var worksheetDataSourceInfo = dataSchema.worksheetDataSchemaMap[_this.name];\n var dataSources = [];\n // First, add the primary datasource. By convention, it comes first in the returned array.\n var primaryId = worksheetDataSourceInfo.primaryDataSource;\n dataSources.push(_this.createDataSourceFromInfo(dataSchema.dataSources[primaryId]));\n // Then, loop through any secondary data sources and add them.\n for (var _i = 0, _a = worksheetDataSourceInfo.referencedDataSourceList; _i < _a.length; _i++) {\n var secondaryId = _a[_i];\n if (secondaryId !== primaryId) {\n dataSources.push(_this.createDataSourceFromInfo(dataSchema.dataSources[secondaryId]));\n }\n }\n return dataSources;\n });\n };\n WorksheetImpl.prototype.getFiltersAsync = function () {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.getFiltersAsync(this.visualId);\n };\n WorksheetImpl.prototype.getSelectedMarksAsync = function () {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n return service.getSelectedMarksAsync(this.visualId);\n };\n WorksheetImpl.prototype.getHighlightedMarksAsync = function () {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n return service.getHighlightedMarksAsync(this.visualId);\n };\n WorksheetImpl.prototype.getSummaryDataAsync = function (options) {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n options = options || {};\n return service.getUnderlyingDataAsync(this.visualId, GetDataService_1.GetDataType.Summary, !!options.ignoreAliases, !!options.ignoreSelection, true, options.columnsToIncludeById || [], options.maxRows || 0, options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues);\n };\n WorksheetImpl.prototype.getSummaryDataReaderAsync = function (pageRowCount, options) {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n options = options || {};\n return service.getSummaryDataReaderAsync(this.visualId, pageRowCount || this.getMaxPageRowLimit(), !!options.ignoreAliases, !!options.ignoreSelection, true, // includeAllColumns (can be overridden by columnsToIncludeById)\n options.columnsToIncludeById || [], options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues);\n };\n WorksheetImpl.prototype.getVisualSpecificationAsync = function () {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"visual-model-service\" /* VisualModel */);\n return service.getVisualSpecificationAsync(this.visualId);\n };\n WorksheetImpl.prototype.getSummaryColumnsInfoAsync = function () {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n return service.getSummaryColumnsInfoAsync(this.visualId);\n };\n WorksheetImpl.prototype.getUnderlyingDataAsync = function (options) {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n options = options || {};\n return service.getUnderlyingDataAsync(this.visualId, GetDataService_1.GetDataType.Underlying, !!options.ignoreAliases, !!options.ignoreSelection, !!options.includeAllColumns, options.columnsToIncludeById || [], options.maxRows || 0, options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues);\n };\n WorksheetImpl.prototype.getUnderlyingTablesAsync = function () {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"data-source-service\" /* DataSourceService */);\n return service.getUnderlyingTablesAsync(this.visualId).then(function (logicalTableInfos) {\n return logicalTableInfos.map(function (logicalTableInfo) { return new LogicalTable_1.LogicalTable(logicalTableInfo); });\n });\n };\n WorksheetImpl.prototype.getUnderlyingTableDataAsync = function (logicalTableId, options) {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n options = options || {};\n return service.getUnderlyingTableDataAsync(this.visualId, logicalTableId, !!options.ignoreAliases, !!options.ignoreSelection, !!options.includeAllColumns, options.columnsToIncludeById || [], options.maxRows || 0, options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues);\n };\n WorksheetImpl.prototype.getUnderlyingTableDataReaderAsync = function (logicalTableId, pageRowCount, options) {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n options = options || {};\n return service.getUnderlyingTableDataReaderAsync(this.visualId, logicalTableId, pageRowCount || this.getMaxPageRowLimit(), !!options.ignoreAliases, !!options.ignoreSelection, !!options.includeAllColumns, options.columnsToIncludeById || [], options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues);\n };\n WorksheetImpl.prototype.clearSelectedMarksAsync = function () {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"selection-service\" /* Selection */);\n return service.clearSelectedMarksAsync(this.visualId);\n };\n WorksheetImpl.prototype.selectMarksByValueAsync = function (selections, selectionUpdateType) {\n ErrorHelpers_1.ErrorHelpers.verifyParameter(selections, 'fieldName');\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(selectionUpdateType, api_external_contract_js_1.SelectionUpdateType, 'SelectionUpdateType');\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"selection-service\" /* Selection */);\n return service.selectMarksByValueAsync(this.visualId, selections, selectionUpdateType);\n };\n WorksheetImpl.prototype.selectMarksByIdAsync = function (selections, selectionUpdateType) {\n ErrorHelpers_1.ErrorHelpers.verifyParameter(selections, 'fieldName');\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(selectionUpdateType, api_external_contract_js_1.SelectionUpdateType, 'SelectionUpdateType');\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"selection-service\" /* Selection */);\n return service.selectMarksByIdAsync(this.visualId, selections, selectionUpdateType);\n };\n WorksheetImpl.prototype.annotateMarkAsync = function (mark, annotationText) {\n ErrorHelpers_1.ErrorHelpers.verifyParameter(mark, 'mark');\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"annotation-service\" /* Annotation */);\n return service.annotateMarkAsync(this.visualId, mark, annotationText);\n };\n WorksheetImpl.prototype.getAnnotationsAsync = function () {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"annotation-service\" /* Annotation */);\n return service.getAnnotationsAsync(this.visualId);\n };\n WorksheetImpl.prototype.removeAnnotationAsync = function (annotation) {\n ErrorHelpers_1.ErrorHelpers.verifyParameter(annotation, 'annotation');\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"annotation-service\" /* Annotation */);\n return service.removeAnnotationAsync(this.visualId, annotation);\n };\n WorksheetImpl.prototype.appendContextMenuAsync = function (targetMenu, config) {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"external-context-menu-service\" /* ExternalContextMenu */);\n return service.appendContextMenuAsync(this.visualId.worksheet, targetMenu, config);\n };\n WorksheetImpl.prototype.removeContextMenuAsync = function (targetMenu, menuItemId) {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"external-context-menu-service\" /* ExternalContextMenu */);\n return service.removeContextMenuAsync(this.visualId.worksheet, targetMenu, menuItemId);\n };\n WorksheetImpl.prototype.executeContextMenuAsync = function (targetMenu, menuItemId) {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"external-context-menu-service\" /* ExternalContextMenu */);\n return service.executeContextMenuAsync(this.visualId.worksheet, targetMenu, menuItemId);\n };\n WorksheetImpl.prototype.renameContextMenuAsync = function (targetMenu, menuHeader, menuDescription) {\n this.verifyActiveSheet();\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"external-context-menu-service\" /* ExternalContextMenu */);\n return service.renameContextMenuAsync(this.visualId.worksheet, targetMenu, menuHeader, menuDescription);\n };\n WorksheetImpl.prototype.hoverTupleAsync = function (hoveredTuple, tooltip, allowHoverActions) {\n if (this.isInsideDashboardExtension()) {\n return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, \"hoverTupleAsync is not supported in dashboard extensions\"));\n }\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"selection-service\" /* Selection */);\n return service.hoverTupleAsync(this.visualId, hoveredTuple, tooltip, allowHoverActions);\n };\n WorksheetImpl.prototype.selectTuplesAsync = function (selectedTuples, selectOption, tooltip) {\n if (this.isInsideDashboardExtension()) {\n return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, \"selectTuplesAsync is not supported in dashboard extensions\"));\n }\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"selection-service\" /* Selection */);\n return service.selectTuplesAsync(this.visualId, selectedTuples, selectOption, tooltip);\n };\n WorksheetImpl.prototype.getTooltipTextAsync = function (tupleId) {\n if (this.isInsideDashboardExtension()) {\n return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, \"getTooltipTextAsync is not supported in dashboard extensions\"));\n }\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"accessibility\" /* Accessibility */);\n return service.getTooltipTextAsync(this.visualId, tupleId);\n };\n WorksheetImpl.prototype.leaveMarkNavigationAsync = function () {\n if (this.isInsideDashboardExtension()) {\n return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, \"leaveMarkNavigationAsync is not supported in dashboard extensions\"));\n }\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"accessibility\" /* Accessibility */);\n return service.leaveMarkNavigationAsync(this.visualId);\n };\n WorksheetImpl.prototype.createDataSourceFromInfo = function (dataSourceInfo) {\n var dataSourceImpl = new DataSourceImpl_1.DataSourceImpl(dataSourceInfo, this._registryId);\n var dataSource = new DataSource_1.DataSource(dataSourceImpl);\n dataSourceImpl.initializeWithPublicInterfaces(dataSource);\n return dataSource;\n };\n WorksheetImpl.prototype.verifyActiveSheet = function () {\n var isRootAndActiveWorksheet = this.active;\n var isInsideActiveDashboard = this.isInsideActiveDashboard();\n var isInsideActiveStoryPoint = this.isInsideActiveStoryPoint();\n if (!isRootAndActiveWorksheet && !isInsideActiveDashboard && !isInsideActiveStoryPoint) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.NotActiveSheet, 'Operation not allowed on non-active sheet');\n }\n };\n WorksheetImpl.prototype.isInsideActiveStoryPoint = function () {\n return this._parentStoryPointImpl && this._parentStoryPointImpl.active;\n };\n WorksheetImpl.prototype.isInsideActiveDashboard = function () {\n return this._parentDashboardImpl && this._parentDashboardImpl.active;\n };\n WorksheetImpl.prototype.isInsideDashboardExtension = function () {\n return this._parentDashboardImpl !== null;\n };\n return WorksheetImpl;\n}(SheetImpl_1.SheetImpl));\nexports.WorksheetImpl = WorksheetImpl;\n//# sourceMappingURL=WorksheetImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Implementation of a logical table.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nvar LogicalTable = /** @class */ (function () {\n function LogicalTable(_logicalTable) {\n this._logicalTable = _logicalTable;\n }\n Object.defineProperty(LogicalTable.prototype, \"id\", {\n get: function () {\n return this._logicalTable.id;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(LogicalTable.prototype, \"caption\", {\n get: function () {\n return this._logicalTable.caption;\n },\n enumerable: true,\n configurable: true\n });\n return LogicalTable;\n}());\nexports.LogicalTable = LogicalTable;\n//# sourceMappingURL=LogicalTable.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar TooltipTextRequestModel = /** @class */ (function () {\n function TooltipTextRequestModel(visualIdPresModel, tupleId) {\n this.visualIdPresModel = visualIdPresModel;\n this.tupleId = tupleId;\n }\n return TooltipTextRequestModel;\n}());\nexports.TooltipTextRequestModel = TooltipTextRequestModel;\n//# sourceMappingURL=AccessibilityModels.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar ServiceRegistry_1 = require(\"../Services/ServiceRegistry\");\nvar ErrorHelpers_1 = require(\"../Utils/ErrorHelpers\");\nvar Filter = /** @class */ (function () {\n function Filter(_worksheetName, _fieldName, _filterType, _fieldId, _registryId) {\n this._worksheetName = _worksheetName;\n this._fieldName = _fieldName;\n this._filterType = _filterType;\n this._fieldId = _fieldId;\n this._registryId = _registryId;\n }\n Object.defineProperty(Filter.prototype, \"worksheetName\", {\n get: function () {\n return this._worksheetName;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Filter.prototype, \"fieldName\", {\n get: function () {\n return this._fieldName;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Filter.prototype, \"fieldId\", {\n get: function () {\n return this._fieldId;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Filter.prototype, \"filterType\", {\n get: function () {\n return this._filterType;\n },\n enumerable: true,\n configurable: true\n });\n Filter.prototype.getFieldAsync = function () {\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"data-source-service\" /* DataSourceService */);\n return service.getFieldAsync(this._fieldId);\n };\n Filter.prototype.getAppliedWorksheetsAsync = function () {\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.getAppliedWorksheetsAsync(this._worksheetName, this._fieldId);\n };\n Filter.prototype.setAppliedWorksheetsAsync = function (applyToWorksheets) {\n ErrorHelpers_1.ErrorHelpers.verifyParameter(applyToWorksheets, 'applyToWorksheets');\n var uniqueWorksheets = new Set(applyToWorksheets);\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.setAppliedWorksheetsAsync(this._worksheetName, this._fieldName, this._fieldId, Array.from(uniqueWorksheets));\n };\n return Filter;\n}());\nexports.Filter = Filter;\nvar CategoricalFilter = /** @class */ (function (_super) {\n __extends(CategoricalFilter, _super);\n function CategoricalFilter(worksheetName, fieldName, fieldId, filterType, registryId, _appliedValues, _isExcludeMode, _isAllSelected) {\n var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId, registryId) || this;\n _this._appliedValues = _appliedValues;\n _this._isExcludeMode = _isExcludeMode;\n _this._isAllSelected = _isAllSelected;\n return _this;\n }\n Object.defineProperty(CategoricalFilter.prototype, \"isAllSelected\", {\n get: function () {\n return this._isAllSelected;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(CategoricalFilter.prototype, \"appliedValues\", {\n get: function () {\n return this._appliedValues;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(CategoricalFilter.prototype, \"isExcludeMode\", {\n get: function () {\n return this._isExcludeMode;\n },\n enumerable: true,\n configurable: true\n });\n CategoricalFilter.prototype.getDomainAsync = function (domainType) {\n if (!domainType) {\n domainType = api_external_contract_js_1.FilterDomainType.Relevant;\n }\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(domainType, api_external_contract_js_1.FilterDomainType, 'FilterDomainType');\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n return service.getCategoricalDomainAsync(this._worksheetName, this._fieldId, domainType);\n };\n return CategoricalFilter;\n}(Filter));\nexports.CategoricalFilter = CategoricalFilter;\nvar HierarchicalDataValue = /** @class */ (function () {\n function HierarchicalDataValue(_value, _hierarchicalPath, _level) {\n this._value = _value;\n this._hierarchicalPath = _hierarchicalPath;\n this._level = _level;\n }\n Object.defineProperty(HierarchicalDataValue.prototype, \"value\", {\n get: function () {\n return this._value;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(HierarchicalDataValue.prototype, \"hierarchicalPath\", {\n get: function () {\n return this._hierarchicalPath;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(HierarchicalDataValue.prototype, \"level\", {\n get: function () {\n return this._level;\n },\n enumerable: true,\n configurable: true\n });\n return HierarchicalDataValue;\n}());\nexports.HierarchicalDataValue = HierarchicalDataValue;\nvar HierarchicalLevelDetail = /** @class */ (function () {\n function HierarchicalLevelDetail(_name, _levelSelectionState) {\n this._name = _name;\n this._levelSelectionState = _levelSelectionState;\n }\n Object.defineProperty(HierarchicalLevelDetail.prototype, \"name\", {\n get: function () {\n return this._name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(HierarchicalLevelDetail.prototype, \"levelSelectionState\", {\n get: function () {\n return this._levelSelectionState;\n },\n enumerable: true,\n configurable: true\n });\n return HierarchicalLevelDetail;\n}());\nexports.HierarchicalLevelDetail = HierarchicalLevelDetail;\nvar HierarchicalFilter = /** @class */ (function (_super) {\n __extends(HierarchicalFilter, _super);\n function HierarchicalFilter(worksheetName, fieldName, fieldId, filterType, registryId, _dimensionName, _hierarchyCaption, _numberOfLevels, _levelDetails, _appliedValues, _isAllSelected) {\n var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId, registryId) || this;\n _this._dimensionName = _dimensionName;\n _this._hierarchyCaption = _hierarchyCaption;\n _this._numberOfLevels = _numberOfLevels;\n _this._levelDetails = _levelDetails;\n _this._appliedValues = _appliedValues;\n _this._isAllSelected = _isAllSelected;\n return _this;\n }\n HierarchicalFilter.prototype.getDomainAsync = function (domainType) {\n throw new Error('Method not implemented.');\n };\n Object.defineProperty(HierarchicalFilter.prototype, \"dimensionName\", {\n get: function () {\n return this._dimensionName;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(HierarchicalFilter.prototype, \"hierarchyCaption\", {\n get: function () {\n return this._hierarchyCaption;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(HierarchicalFilter.prototype, \"numberOfLevels\", {\n get: function () {\n return this._numberOfLevels;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(HierarchicalFilter.prototype, \"levelDetails\", {\n get: function () {\n return this._levelDetails;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(HierarchicalFilter.prototype, \"isAllSelected\", {\n get: function () {\n return this._isAllSelected;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(HierarchicalFilter.prototype, \"appliedValues\", {\n get: function () {\n return this._appliedValues;\n },\n enumerable: true,\n configurable: true\n });\n return HierarchicalFilter;\n}(Filter));\nexports.HierarchicalFilter = HierarchicalFilter;\nvar RangeFilter = /** @class */ (function (_super) {\n __extends(RangeFilter, _super);\n function RangeFilter(worksheetName, fieldName, fieldId, filterType, registryId, _min, _max, _includeNullValues) {\n var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId, registryId) || this;\n _this._min = _min;\n _this._max = _max;\n _this._includeNullValues = _includeNullValues;\n return _this;\n }\n Object.defineProperty(RangeFilter.prototype, \"minValue\", {\n get: function () {\n return this._min;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RangeFilter.prototype, \"maxValue\", {\n get: function () {\n return this._max;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RangeFilter.prototype, \"includeNullValues\", {\n get: function () {\n return this._includeNullValues;\n },\n enumerable: true,\n configurable: true\n });\n RangeFilter.prototype.getDomainAsync = function (domainType) {\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"filter-service\" /* Filter */);\n if (!domainType) {\n domainType = api_external_contract_js_1.FilterDomainType.Relevant;\n }\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(domainType, api_external_contract_js_1.FilterDomainType, 'FilterDomainType');\n return service.getRangeDomainAsync(this._worksheetName, this._fieldId, domainType);\n };\n return RangeFilter;\n}(Filter));\nexports.RangeFilter = RangeFilter;\nvar RelativeDateFilter = /** @class */ (function (_super) {\n __extends(RelativeDateFilter, _super);\n function RelativeDateFilter(worksheetName, fieldName, fieldId, filterType, registryId, _anchorDate, _periodType, _rangeType, _rangeN) {\n var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId, registryId) || this;\n _this._anchorDate = _anchorDate;\n _this._periodType = _periodType;\n _this._rangeType = _rangeType;\n _this._rangeN = _rangeN;\n return _this;\n }\n Object.defineProperty(RelativeDateFilter.prototype, \"anchorDate\", {\n get: function () {\n return this._anchorDate;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RelativeDateFilter.prototype, \"periodType\", {\n get: function () {\n return this._periodType;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RelativeDateFilter.prototype, \"rangeType\", {\n get: function () {\n return this._rangeType;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RelativeDateFilter.prototype, \"rangeN\", {\n get: function () {\n return this._rangeN;\n },\n enumerable: true,\n configurable: true\n });\n return RelativeDateFilter;\n}(Filter));\nexports.RelativeDateFilter = RelativeDateFilter;\nvar CategoricalDomain = /** @class */ (function () {\n function CategoricalDomain(_values, _domainType) {\n this._values = _values;\n this._domainType = _domainType;\n }\n Object.defineProperty(CategoricalDomain.prototype, \"values\", {\n get: function () {\n return this._values;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(CategoricalDomain.prototype, \"type\", {\n get: function () {\n return this._domainType;\n },\n enumerable: true,\n configurable: true\n });\n return CategoricalDomain;\n}());\nexports.CategoricalDomain = CategoricalDomain;\nvar RangeDomain = /** @class */ (function () {\n function RangeDomain(_min, _max, _domainType) {\n this._min = _min;\n this._max = _max;\n this._domainType = _domainType;\n }\n Object.defineProperty(RangeDomain.prototype, \"type\", {\n get: function () {\n return this._domainType;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RangeDomain.prototype, \"min\", {\n get: function () {\n return this._min;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(RangeDomain.prototype, \"max\", {\n get: function () {\n return this._max;\n },\n enumerable: true,\n configurable: true\n });\n return RangeDomain;\n}());\nexports.RangeDomain = RangeDomain;\n//# sourceMappingURL=FilterModels.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar DataTable = /** @class */ (function () {\n function DataTable(_data, _columns, _totalRowCount, _isTotalRowCountLimited, _isSummaryData, _marksInfo) {\n this._data = _data;\n this._columns = _columns;\n this._totalRowCount = _totalRowCount;\n this._isTotalRowCountLimited = _isTotalRowCountLimited;\n this._isSummaryData = _isSummaryData;\n this._marksInfo = _marksInfo;\n this._name = _isSummaryData ? 'Summary Data Table' : 'Underlying Data Table';\n }\n Object.defineProperty(DataTable.prototype, \"name\", {\n get: function () {\n return this._name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataTable.prototype, \"data\", {\n get: function () {\n return this._data;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataTable.prototype, \"columns\", {\n get: function () {\n return this._columns;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataTable.prototype, \"marksInfo\", {\n get: function () {\n return this._marksInfo;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataTable.prototype, \"totalRowCount\", {\n get: function () {\n return this._totalRowCount;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataTable.prototype, \"isTotalRowCountLimited\", {\n get: function () {\n return this._isTotalRowCountLimited;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataTable.prototype, \"isSummaryData\", {\n get: function () {\n return this._isSummaryData;\n },\n enumerable: true,\n configurable: true\n });\n return DataTable;\n}());\nexports.DataTable = DataTable;\nvar MarkInfo = /** @class */ (function () {\n function MarkInfo(_type, _color, _tupleId) {\n this._type = _type;\n this._color = _color;\n this._tupleId = _tupleId;\n }\n Object.defineProperty(MarkInfo.prototype, \"type\", {\n get: function () {\n return this._type;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(MarkInfo.prototype, \"color\", {\n get: function () {\n return this._color;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(MarkInfo.prototype, \"tupleId\", {\n get: function () {\n return this._tupleId;\n },\n enumerable: true,\n configurable: true\n });\n return MarkInfo;\n}());\nexports.MarkInfo = MarkInfo;\nvar Column = /** @class */ (function () {\n function Column(_fieldName, _fieldId, _dataType, _isReferenced, _index) {\n this._fieldName = _fieldName;\n this._fieldId = _fieldId;\n this._dataType = _dataType;\n this._isReferenced = _isReferenced;\n this._index = _index;\n }\n Object.defineProperty(Column.prototype, \"fieldName\", {\n get: function () {\n return this._fieldName;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Column.prototype, \"fieldId\", {\n get: function () {\n return this._fieldId;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Column.prototype, \"dataType\", {\n get: function () {\n return this._dataType;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Column.prototype, \"isReferenced\", {\n get: function () {\n return this._isReferenced;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Column.prototype, \"index\", {\n get: function () {\n return this._index;\n },\n enumerable: true,\n configurable: true\n });\n return Column;\n}());\nexports.Column = Column;\nvar DataValue = /** @class */ (function () {\n /* tslint:disable:no-any */\n function DataValue(_value, _nativeValue, _formattedValue) {\n this._value = _value;\n this._nativeValue = _nativeValue;\n this._formattedValue = _formattedValue;\n }\n Object.defineProperty(DataValue.prototype, \"value\", {\n get: function () {\n return this._value;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataValue.prototype, \"nativeValue\", {\n get: function () {\n return this._nativeValue;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataValue.prototype, \"formattedValue\", {\n get: function () {\n return this._formattedValue;\n },\n enumerable: true,\n configurable: true\n });\n return DataValue;\n}());\nexports.DataValue = DataValue;\n//# sourceMappingURL=GetDataModels.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f) throw new TypeError(\"Generator is already executing.\");\n while (_) try {\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n if (y = 0, t) op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0: case 1: t = op; break;\n case 4: _.label++; return { value: op[1], done: false };\n case 5: _.label++; y = op[1]; op = [0]; continue;\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n if (t[2]) _.ops.pop();\n _.trys.pop(); continue;\n }\n op = body.call(thisArg, _);\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ServiceRegistry_1 = require(\"../Services/ServiceRegistry\");\nvar ErrorHelpers_1 = require(\"../Utils/ErrorHelpers\");\nvar DataTableReader = /** @class */ (function () {\n function DataTableReader(_id, _totalRowCount, _pageRowCount, _registryId) {\n this._id = _id;\n this._totalRowCount = _totalRowCount;\n this._pageRowCount = _pageRowCount;\n this._registryId = _registryId;\n this._pageCount = Math.ceil(_totalRowCount / _pageRowCount);\n }\n Object.defineProperty(DataTableReader.prototype, \"totalRowCount\", {\n get: function () {\n return this._totalRowCount;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(DataTableReader.prototype, \"pageCount\", {\n get: function () {\n return this._pageCount;\n },\n enumerable: true,\n configurable: true\n });\n DataTableReader.prototype.getPageAsync = function (pageNumber) {\n ErrorHelpers_1.ErrorHelpers.verifyRange(pageNumber, 0, this._pageCount);\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n return service.getPageAsync(this._id, pageNumber, this._pageRowCount);\n };\n DataTableReader.prototype.getAllPagesAsync = function (maxRows) {\n return __awaiter(this, void 0, void 0, function () {\n var firstPage, rowsRequested, pagesRequested, pagesToFetch, isDataLimited, remainingData, i, page, fullData;\n var _a;\n return __generator(this, function (_b) {\n switch (_b.label) {\n case 0: return [4 /*yield*/, this.getPageAsync(0)];\n case 1:\n firstPage = _b.sent();\n maxRows = maxRows || this.totalRowCount;\n rowsRequested = Math.min(maxRows, this.totalRowCount);\n pagesRequested = Math.ceil(rowsRequested / this._pageRowCount);\n pagesToFetch = Math.min(pagesRequested, 400);\n isDataLimited = pagesToFetch < pagesRequested;\n remainingData = [];\n i = 1;\n _b.label = 2;\n case 2:\n if (!(i < pagesToFetch)) return [3 /*break*/, 5];\n return [4 /*yield*/, this.getPageAsync(i)];\n case 3:\n page = _b.sent();\n remainingData.push(page.data);\n _b.label = 4;\n case 4:\n i++;\n return [3 /*break*/, 2];\n case 5:\n fullData = (_a = firstPage.data).concat.apply(_a, remainingData);\n // This slices the array only if maxRows has been set and is less than totalRowCount\n fullData.length = rowsRequested;\n return [2 /*return*/, {\n name: firstPage.name,\n data: fullData,\n columns: firstPage.columns,\n totalRowCount: isDataLimited ? pagesToFetch * this._pageRowCount : rowsRequested,\n isTotalRowCountLimited: isDataLimited,\n isSummaryData: firstPage.isSummaryData,\n }];\n }\n });\n });\n };\n DataTableReader.prototype.releaseAsync = function () {\n var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService(\"get-data-service\" /* GetData */);\n return service.releaseAsync(this._id);\n };\n return DataTableReader;\n}());\nexports.DataTableReader = DataTableReader;\n//# sourceMappingURL=GetDataTableReaderModels.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Selection Model.\n */\nvar SelectionModel = /** @class */ (function () {\n function SelectionModel() {\n }\n return SelectionModel;\n}());\nexports.SelectionModel = SelectionModel;\n/**\n * Value based selection model. Meant for hierarchical, range and categorical selections.\n */\nvar ValueSelectionModel = /** @class */ (function (_super) {\n __extends(ValueSelectionModel, _super);\n function ValueSelectionModel() {\n var _this = _super !== null && _super.apply(this, arguments) || this;\n _this.selectValues = [];\n return _this;\n }\n return ValueSelectionModel;\n}(SelectionModel));\nexports.ValueSelectionModel = ValueSelectionModel;\n/**\n * Hierarchical value selection model\n */\nvar HierarchicalSelectionModel = /** @class */ (function (_super) {\n __extends(HierarchicalSelectionModel, _super);\n function HierarchicalSelectionModel() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n return HierarchicalSelectionModel;\n}(ValueSelectionModel));\nexports.HierarchicalSelectionModel = HierarchicalSelectionModel;\n/**\n * Range based value selection model\n */\nvar RangeSelectionModel = /** @class */ (function (_super) {\n __extends(RangeSelectionModel, _super);\n function RangeSelectionModel() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n return RangeSelectionModel;\n}(SelectionModel));\nexports.RangeSelectionModel = RangeSelectionModel;\n/**\n * Dimension value selection model\n */\nvar DimensionSelectionModel = /** @class */ (function (_super) {\n __extends(DimensionSelectionModel, _super);\n function DimensionSelectionModel() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n return DimensionSelectionModel;\n}(ValueSelectionModel));\nexports.DimensionSelectionModel = DimensionSelectionModel;\n/**\n * Tuple based selection model\n */\nvar TupleSelectionModel = /** @class */ (function () {\n function TupleSelectionModel() {\n this.objectIds = [];\n }\n return TupleSelectionModel;\n}());\nexports.TupleSelectionModel = TupleSelectionModel;\n/**\n * Container class to populate all the selection models when parsing input\n */\nvar SelectionModelsContainer = /** @class */ (function () {\n function SelectionModelsContainer() {\n this.hierModelArr = [];\n this.dimModelArr = [];\n this.quantModelArr = [];\n }\n return SelectionModelsContainer;\n}());\nexports.SelectionModelsContainer = SelectionModelsContainer;\nvar SelectTuplesInteractionModel = /** @class */ (function () {\n function SelectTuplesInteractionModel(visualIdPresModel, tupleIds, selectOptions, tooltipContext) {\n if (tupleIds === void 0) { tupleIds = []; }\n this.visualIdPresModel = visualIdPresModel;\n this.tupleIds = tupleIds;\n this.selectOptions = selectOptions;\n this.tooltipContext = tooltipContext;\n }\n return SelectTuplesInteractionModel;\n}());\nexports.SelectTuplesInteractionModel = SelectTuplesInteractionModel;\nvar HoverTupleInteractionModel = /** @class */ (function () {\n function HoverTupleInteractionModel(visualIdPresModel, tupleId, tooltipContext, allowHoverActions) {\n this.visualIdPresModel = visualIdPresModel;\n this.tupleId = tupleId;\n this.tooltipContext = tooltipContext;\n this.allowHoverActions = allowHoverActions;\n }\n return HoverTupleInteractionModel;\n}());\nexports.HoverTupleInteractionModel = HoverTupleInteractionModel;\n//# sourceMappingURL=SelectionModels.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Point = /** @class */ (function () {\n function Point(_x, _y) {\n this._x = _x;\n this._y = _y;\n }\n Object.defineProperty(Point.prototype, \"x\", {\n get: function () {\n return this._x;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(Point.prototype, \"y\", {\n get: function () {\n return this._y;\n },\n enumerable: true,\n configurable: true\n });\n return Point;\n}());\nexports.Point = Point;\n//# sourceMappingURL=Point.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Defines which type of getData call to make.\n */\nvar GetDataType;\n(function (GetDataType) {\n GetDataType[\"Summary\"] = \"summary\";\n GetDataType[\"Underlying\"] = \"underlying\";\n})(GetDataType = exports.GetDataType || (exports.GetDataType = {}));\n//# sourceMappingURL=GetDataService.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar ServiceRegistry_1 = require(\"./ServiceRegistry\");\nvar AccessibilityServiceImpl_1 = require(\"./impl/AccessibilityServiceImpl\");\nvar AnimationServiceImpl_1 = require(\"./impl/AnimationServiceImpl\");\nvar AnnotationServiceImpl_1 = require(\"./impl/AnnotationServiceImpl\");\nvar DataSourceServiceImpl_1 = require(\"./impl/DataSourceServiceImpl\");\nvar ExportServiceImpl_1 = require(\"./impl/ExportServiceImpl\");\nvar ExternalContextMenuServiceImpl_1 = require(\"./impl/ExternalContextMenuServiceImpl\");\nvar FilterServiceImpl_1 = require(\"./impl/FilterServiceImpl\");\nvar GetDataServiceImpl_1 = require(\"./impl/GetDataServiceImpl\");\nvar NotificationServiceImpl_1 = require(\"./impl/NotificationServiceImpl\");\nvar ParametersServiceImpl_1 = require(\"./impl/ParametersServiceImpl\");\nvar SelectionServiceImpl_1 = require(\"./impl/SelectionServiceImpl\");\nvar SizeServiceImpl_1 = require(\"./impl/SizeServiceImpl\");\nvar VisualModelServiceImpl_1 = require(\"./impl/VisualModelServiceImpl\");\nvar VizServiceImpl_1 = require(\"./impl/VizServiceImpl\");\nvar ZoneServiceImpl_1 = require(\"./impl/ZoneServiceImpl\");\nfunction registerAllSharedServices(dispatcher, registryId, platformVersion) {\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new AnimationServiceImpl_1.AnimationServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new DataSourceServiceImpl_1.DataSourceServiceImpl(dispatcher, registryId, platformVersion));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new ExportServiceImpl_1.ExportServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new GetDataServiceImpl_1.GetDataServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new FilterServiceImpl_1.FilterServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new NotificationServiceImpl_1.NotificationServiceImpl(dispatcher));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new ParametersServiceImpl_1.ParametersServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new SelectionServiceImpl_1.SelectionServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new AnnotationServiceImpl_1.AnnotationServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new ZoneServiceImpl_1.ZoneServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new SizeServiceImpl_1.SizeServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new VisualModelServiceImpl_1.VisualModelServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new VizServiceImpl_1.VizServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new ExternalContextMenuServiceImpl_1.ExternalContextMenuServiceImpl(dispatcher, registryId));\n ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new AccessibilityServiceImpl_1.AccessibilityServiceImpl(dispatcher, registryId));\n}\nexports.registerAllSharedServices = registerAllSharedServices;\n//# sourceMappingURL=RegisterAllSharedServices.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar TableauError_1 = require(\"../TableauError\");\nwindow.__tableauApiServiceRegistry = window.__tableauApiServiceRegistry || {};\nvar ServiceRegistryImpl = /** @class */ (function () {\n function ServiceRegistryImpl() {\n this._services = {};\n }\n ServiceRegistryImpl.prototype.registerService = function (service) {\n this._services[service.serviceName] = service;\n };\n ServiceRegistryImpl.prototype.getService = function (serviceName) {\n if (!this._services.hasOwnProperty(serviceName)) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, \"Service not registered: \" + serviceName);\n }\n return this._services[serviceName];\n };\n return ServiceRegistryImpl;\n}());\n/**\n * Static class used for getting access to the single instance\n * of the ApiServiceRegistry associated with the registryId.\n *\n * Extensions by design don't need to store/access multiple service registries. Their single instance of ServiceRegistry is\n * stored/access with registryId = 0.\n *\n * Whereas Embedding needs to be aware of which ServiceRegistry to use when there are multiple vizzes embedded.\n * An example of how window.__tableauApiServiceRegistry will look when there are two vizzes: { 0 : ServiceRegistry, 1 : ServiceRegistry}\n * where registry ID of 0 & 1 refers to viz's internal identifier (which is generated by VizManager).\n */\nvar ApiServiceRegistry = /** @class */ (function () {\n // Private to avoid anyone constructing this\n function ApiServiceRegistry() {\n }\n /**\n * Gets the singleton instance of the ServiceRegistry\n */\n ApiServiceRegistry.get = function (registryId) {\n if (!window.__tableauApiServiceRegistry || !window.__tableauApiServiceRegistry[registryId]) {\n ApiServiceRegistry.setInstance(registryId, new ServiceRegistryImpl());\n }\n if (!window.__tableauApiServiceRegistry[registryId]) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, 'Service registry failed');\n }\n return window.__tableauApiServiceRegistry[registryId];\n };\n /**\n * Helper method that sets the service registry instance for the corresponding registryId. Can be used by unit tests\n *\n * @param {ServiceRegistry} serviceRegistry The new registry\n */\n ApiServiceRegistry.setInstance = function (registryId, serviceRegistry) {\n if (!window.__tableauApiServiceRegistry) {\n window.__tableauApiServiceRegistry = {};\n }\n window.__tableauApiServiceRegistry[registryId] = serviceRegistry;\n };\n /**\n * Only used by unit tests\n */\n ApiServiceRegistry.clearRegistry = function () {\n window.__tableauApiServiceRegistry = {};\n };\n return ApiServiceRegistry;\n}());\nexports.ApiServiceRegistry = ApiServiceRegistry;\n//# sourceMappingURL=ServiceRegistry.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar AccessibilityModels_1 = require(\"../../Models/AccessibilityModels\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar AccessibilityServiceImpl = /** @class */ (function (_super) {\n __extends(AccessibilityServiceImpl, _super);\n function AccessibilityServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(AccessibilityServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"accessibility\" /* Accessibility */;\n },\n enumerable: true,\n configurable: true\n });\n AccessibilityServiceImpl.prototype.getTooltipTextAsync = function (visualId, tupleId) {\n var _a;\n var tooltipTextRequest = new AccessibilityModels_1.TooltipTextRequestModel(visualId, tupleId);\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getTooltipTextAsync',\n _a[api_internal_contract_js_1.ParameterId.TooltipTextRequest] = tooltipTextRequest,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetTooltipText, parameters).then(function (response) {\n return response.result;\n });\n };\n AccessibilityServiceImpl.prototype.leaveMarkNavigationAsync = function (visualId) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'leaveMarkNavigationAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.RaiseLeaveMarkNavNotification, parameters).then(function (response) {\n return;\n });\n };\n return AccessibilityServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.AccessibilityServiceImpl = AccessibilityServiceImpl;\n//# sourceMappingURL=AccessibilityServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar ExternalToInternalEnumMappings_1 = require(\"../../EnumMappings/ExternalToInternalEnumMappings\");\nvar ErrorHelpers_1 = require(\"../../Utils/ErrorHelpers\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar AnimationServiceImpl = /** @class */ (function (_super) {\n __extends(AnimationServiceImpl, _super);\n function AnimationServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(AnimationServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"animation-service\" /* Animation */;\n },\n enumerable: true,\n configurable: true\n });\n AnimationServiceImpl.prototype.replayAsync = function (replaySpeed) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.ReplaySpeed] = 1.0,\n _a);\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(replaySpeed, api_external_contract_js_1.ReplaySpeedType, 'ReplaySpeedType');\n parameters[api_internal_contract_js_1.ParameterId.ReplaySpeed] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.setReplaySpeedType.convert(replaySpeed);\n return this.execute(api_internal_contract_js_1.VerbId.ReplayAnimation, parameters).then(function (response) {\n return;\n });\n };\n return AnimationServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.AnimationServiceImpl = AnimationServiceImpl;\n//# sourceMappingURL=AnimationServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar InternalToExternalEnumMappings_1 = require(\"../../EnumMappings/InternalToExternalEnumMappings\");\nvar SelectionModels_1 = require(\"../../Models/SelectionModels\");\nvar TableauError_1 = require(\"../../TableauError\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar AnnotationServiceImpl = /** @class */ (function (_super) {\n __extends(AnnotationServiceImpl, _super);\n function AnnotationServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(AnnotationServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"annotation-service\" /* Annotation */;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Method to annotate a mark on the given worksheet.\n *\n * @param visualId\n * @param mark\n * @param annotationText\n */\n AnnotationServiceImpl.prototype.annotateMarkAsync = function (visualId, mark, annotationText) {\n var _a;\n var selectionModelContainer = this.parseMarkSelectionIds([mark]);\n var dummyTargetPoint = { x: 0, y: 0 };\n var formattedText = \"\" + annotationText + \"\";\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'annotateMarkAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a[api_internal_contract_js_1.ParameterId.AnnotateEnum] = api_internal_contract_js_1.AnnotateEnum.Mark,\n _a[api_internal_contract_js_1.ParameterId.TargetPoint] = dummyTargetPoint,\n _a[api_internal_contract_js_1.ParameterId.SelectionList] = [selectionModelContainer.selection],\n _a[api_internal_contract_js_1.ParameterId.FormattedText] = formattedText,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.CreateAnnotation, parameters).then(function (response) {\n // Expecting an empty model and hence the void response.\n return;\n });\n };\n /**\n * Method to retrieve annotations for the given worksheet.\n *\n * @param visualId\n * @returns {Promise>}\n */\n AnnotationServiceImpl.prototype.getAnnotationsAsync = function (visualId) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getAnnotationsAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetAnnotations, parameters).then(function (response) {\n var annotationsList = response.result;\n return _this.annotationFilterMap(annotationsList);\n });\n };\n /**\n * Method to remove an annotation from a given worksheet.\n *\n * @param visualId\n * @param annotation\n */\n AnnotationServiceImpl.prototype.removeAnnotationAsync = function (visualId, annotation) {\n var _a;\n var selectionModelContainer = this.parseAnnotationSelectionIds([annotation]);\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'removeAnnotationAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a[api_internal_contract_js_1.ParameterId.SelectionList] = [selectionModelContainer.selection],\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.RemoveAnnotation, parameters).then(function (response) {\n // Expecting an empty model and hence the void response.\n return;\n });\n };\n /**\n * Method to prepare the pres models for selection by MarksInfo\n * @param marks\n */\n AnnotationServiceImpl.prototype.parseMarkSelectionIds = function (marks) {\n var ids = [];\n var selectionModelContainer = new SelectionModels_1.SelectionModelsContainer();\n marks.forEach(function (mark) {\n var tupleId = mark.tupleId;\n if (tupleId !== undefined && tupleId !== null && tupleId > 0) {\n ids.push(tupleId.toString()); // collect the tuple ids\n }\n else {\n throw new TableauError_1.TableauError(Contract.ErrorCodes.InternalError, 'invalid tupleId');\n }\n });\n if (ids.length !== 0) {\n // tuple ids based selection\n var tupleSelectionModel = new SelectionModels_1.TupleSelectionModel();\n tupleSelectionModel.selectionType = 'tuples';\n tupleSelectionModel.objectIds = ids;\n selectionModelContainer.selection = tupleSelectionModel;\n }\n return selectionModelContainer;\n };\n /**\n * Method to prepare the pres models for selection by MarkAnnotationInfo\n * @param marks\n */\n AnnotationServiceImpl.prototype.parseAnnotationSelectionIds = function (annotations) {\n var ids = [];\n var selectionModelContainer = new SelectionModels_1.SelectionModelsContainer();\n annotations.forEach(function (annotation) {\n var annotationId = annotation.annotationId;\n if (annotationId !== undefined && annotationId !== null && annotationId >= 0) {\n ids.push(annotationId.toString()); // collect the annotation ids\n }\n else {\n throw new TableauError_1.TableauError(Contract.ErrorCodes.InternalError, 'invalid annotationId');\n }\n });\n if (ids.length !== 0) {\n // annotation ids based selection\n var tupleSelectionModel = new SelectionModels_1.TupleSelectionModel();\n tupleSelectionModel.selectionType = 'annotations';\n tupleSelectionModel.objectIds = ids;\n selectionModelContainer.selection = tupleSelectionModel;\n }\n return selectionModelContainer;\n };\n /**\n * Method to map Annotation to MarkAnnotationInfo\n * @param annotation\n * @returns {Annotation}\n */\n AnnotationServiceImpl.prototype.mapAnnotation = function (annotation) {\n return {\n annotationHTML: annotation.annotationText,\n annotationId: annotation.annotationId,\n annotationText: annotation.annotationPlainText,\n annotationType: InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.annotationType.convert(annotation.annotateEnum),\n tupleId: annotation.tupleId,\n };\n };\n /**\n * Filter the Annotations to Mark Annotations, and map them to MarkAnnotationInfo\n * @param annotations\n * @returns {Array}\n */\n AnnotationServiceImpl.prototype.annotationFilterMap = function (annotations) {\n var _this = this;\n var annotationInfos = annotations.map(function (annotation) { return _this.mapAnnotation(annotation); });\n return annotationInfos;\n };\n return AnnotationServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.AnnotationServiceImpl = AnnotationServiceImpl;\n//# sourceMappingURL=AnnotationServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar ClientInfoServiceImpl = /** @class */ (function (_super) {\n __extends(ClientInfoServiceImpl, _super);\n function ClientInfoServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(ClientInfoServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"client-info-service\" /* ClientInfo */;\n },\n enumerable: true,\n configurable: true\n });\n ClientInfoServiceImpl.prototype.getClientInfoAsync = function () {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.GetEmbeddingClientInfo;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getClientInfoAsync',\n _a);\n return this.execute(verb, parameters).then(function (response) {\n var clientInfo = response.result;\n return clientInfo;\n });\n };\n return ClientInfoServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.ClientInfoServiceImpl = ClientInfoServiceImpl;\n//# sourceMappingURL=ClientInfoServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar InternalContract = require(\"@tableau/api-internal-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar DataSource_1 = require(\"../../DataSource\");\nvar Field_1 = require(\"../../Field\");\nvar DataSourceImpl_1 = require(\"../../Impl/DataSourceImpl\");\nvar FieldImpl_1 = require(\"../../Impl/FieldImpl\");\nvar TableauError_1 = require(\"../../TableauError\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nexports.SENTINEL_LOGICAL_TABLE_INFO = {\n id: InternalContract.ApiShowDataTableSentinel.SingleTableId,\n caption: InternalContract.ApiShowDataTableSentinel.SingleTableCaption,\n};\n// The minimum platform version when Object Model was supported\nvar platformVersionObjectModelSupport = { major: 1, minor: 20, fix: 1 };\nvar DataSourceServiceImpl = /** @class */ (function (_super) {\n __extends(DataSourceServiceImpl, _super);\n // Since Object Model is supported since Tableau 2020.2, DataSourceServiceImpl can be initialized with the\n // platform version when OM was supported. Once we drop support for Tableau versions <= 2020.1, all additional\n // code in here for Object Model can be removed.\n function DataSourceServiceImpl(dispatcher, registryId, _platformVersion) {\n if (_platformVersion === void 0) { _platformVersion = platformVersionObjectModelSupport; }\n var _this = _super.call(this, dispatcher, registryId) || this;\n _this._platformVersion = _platformVersion;\n return _this;\n }\n Object.defineProperty(DataSourceServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"data-source-service\" /* DataSourceService */;\n },\n enumerable: true,\n configurable: true\n });\n DataSourceServiceImpl.prototype.refreshAsync = function (dataSourceId) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'refreshAsync',\n _a[api_internal_contract_js_1.ParameterId.DeltaTimeMs] = 0,\n _a[api_internal_contract_js_1.ParameterId.ShouldRefreshDS] = true,\n _a);\n // On server: Not passing the datasource id will refresh all datasources.\n if (dataSourceId) {\n parameters[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId;\n }\n return this.execute(api_internal_contract_js_1.VerbId.RefreshDataSource, parameters).then(function (response) {\n return;\n });\n };\n DataSourceServiceImpl.prototype.getActiveTablesAsync = function (dataSourceId) {\n var _a;\n var joinParameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getActiveTablesAsync',\n _a[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId,\n _a);\n // Get the description of the tables used by this connection\n return this.execute(api_internal_contract_js_1.VerbId.GetActiveTables, joinParameters).then(function (joinResponse) {\n var tableInfos = joinResponse.result;\n // getActiveTables is unsupported for cubes and GA. We do not have a connection type property\n // available from the platform (intentionally, to reduce code churn as new connections are added).\n // Instead,just check if any tables are returned. This array will be empty for any non-table based datasource.\n if (tableInfos.tables.length === 0) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.UnsupportedMethodForDataSourceType, \"getActiveTables is not supported for: \" + dataSourceId);\n }\n return tableInfos.tables;\n });\n };\n DataSourceServiceImpl.prototype.getDataSourcesAsync = function (visualId) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getDataSourcesAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetDataSources, parameters).then(function (response) {\n var dataSchema = response.result;\n return dataSchema;\n });\n };\n DataSourceServiceImpl.prototype.getAllDataSourcesAsync = function () {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getAllDataSourcesAsync',\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetAllDataSources, parameters).then(function (response) {\n var dataSchema = response.result;\n return dataSchema;\n });\n };\n DataSourceServiceImpl.prototype.getConnectionSummariesAsync = function (dataSourceId) {\n var _a;\n var params = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getConnectionSummariesAsync',\n _a[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId,\n _a);\n // Get the description of the tables used by this connection\n return this.execute(api_internal_contract_js_1.VerbId.GetConnectionDescriptionSummaries, params).then(function (response) {\n var descriptionSummaries = response.result;\n return descriptionSummaries;\n });\n };\n DataSourceServiceImpl.prototype.getFieldAsync = function (globalfieldName) {\n var _a;\n var _this = this;\n var verb = api_internal_contract_js_1.VerbId.GetFieldAndDataSource;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getFieldAsync',\n _a[api_internal_contract_js_1.ParameterId.FieldId] = globalfieldName,\n _a);\n return this.execute(verb, parameters).then(function (response) {\n var dataSource = response.result[api_internal_contract_js_1.ParameterId.DataSource];\n var field = response.result[api_internal_contract_js_1.ParameterId.Field];\n return _this.convertField(field, _this.convertDataSource(dataSource));\n });\n };\n DataSourceServiceImpl.prototype.getLogicalTablesAsync = function (dataSourceId) {\n var _a;\n if (!this.isObjectModelSupportedByPlatform()) {\n /**\n * This sentinel ID can be passed to datasource.getLogicalTableData.\n * Once the desktop is upgraded to a version that supports object model,\n * the sentinel ID will automatically fetch the upgraded table.\n * */\n return new Promise(function (resolve) { return resolve([exports.SENTINEL_LOGICAL_TABLE_INFO]); });\n }\n var params = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getLogicalTablesAsync',\n _a[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetLogicalTables, params).then(function (response) {\n return response.result;\n });\n };\n DataSourceServiceImpl.prototype.getUnderlyingTablesAsync = function (visualId) {\n var _a;\n if (!this.isObjectModelSupportedByPlatform()) {\n /**\n * This sentinel ID can be passed to worksheet.getUnderlyingTableData.\n * Once the desktop is upgraded to a version that supports object model,\n * the sentinel ID will automatically fetch the upgraded table.\n * */\n return new Promise(function (resolve) { return resolve([exports.SENTINEL_LOGICAL_TABLE_INFO]); });\n }\n var params = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getUnderlyingTablesAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetUnderlyingTables, params).then(function (response) {\n return response.result;\n });\n };\n DataSourceServiceImpl.prototype.convertField = function (field, dataSource) {\n return new Field_1.Field(new FieldImpl_1.FieldImpl(field, dataSource));\n };\n DataSourceServiceImpl.prototype.convertDataSource = function (dataSource) {\n return new DataSource_1.DataSource(new DataSourceImpl_1.DataSourceImpl(dataSource, this._registryId));\n };\n DataSourceServiceImpl.prototype.isObjectModelSupportedByPlatform = function () {\n var platformVersionNoObjectModelSupport = { major: 1, minor: 13, fix: 0 };\n return InternalContract.VersionLessThan(platformVersionNoObjectModelSupport, this._platformVersion);\n };\n return DataSourceServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.DataSourceServiceImpl = DataSourceServiceImpl;\n//# sourceMappingURL=DataSourceServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f) throw new TypeError(\"Generator is already executing.\");\n while (_) try {\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n if (y = 0, t) op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0: case 1: t = op; break;\n case 4: _.label++; return { value: op[1], done: false };\n case 5: _.label++; y = op[1]; op = [0]; continue;\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n if (t[2]) _.ops.pop();\n _.trys.pop(); continue;\n }\n op = body.call(thisArg, _);\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar ExternalToInternalEnumMappings_1 = require(\"../../EnumMappings/ExternalToInternalEnumMappings\");\nvar ExportHelpers_1 = require(\"../../Utils/ExportHelpers\");\nvar ErrorHelpers_1 = require(\"../../Utils/ErrorHelpers\");\nvar TableauError_1 = require(\"../../TableauError\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar ExportServiceImpl = /** @class */ (function (_super) {\n __extends(ExportServiceImpl, _super);\n function ExportServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(ExportServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"export-service\" /* Export */;\n },\n enumerable: true,\n configurable: true\n });\n ExportServiceImpl.prototype.getExportCrosstabSheetMapAsync = function (currentSheetType) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.GetExportCrosstabSheetMap;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getExportCrosstabSheetMapAsync',\n _a[api_internal_contract_js_1.ParameterId.CurrentSheetType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.sheetType.convert(currentSheetType),\n _a);\n return this.execute(verb, parameters).then(function (response) {\n var result = response.result;\n return result;\n });\n };\n ExportServiceImpl.prototype.exportCrosstabAsync = function (sheetName, format, exportableWorksheetNames, currentSheetType) {\n return __awaiter(this, void 0, void 0, function () {\n var sheetNameToIdMap, parameters, verb;\n var _a;\n return __generator(this, function (_b) {\n switch (_b.label) {\n case 0:\n ErrorHelpers_1.ErrorHelpers.verifySheetName(exportableWorksheetNames, sheetName);\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(format, api_external_contract_js_1.CrosstabFileFormat, 'CrosstabFileFormat');\n return [4 /*yield*/, this.getExportCrosstabSheetMapAsync(currentSheetType)];\n case 1:\n sheetNameToIdMap = _b.sent();\n if (!sheetNameToIdMap[sheetName]) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'missing sheet doc id from sheetMap');\n }\n parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'exportCrosstabAsync',\n _a[api_internal_contract_js_1.ParameterId.SheetIdentifier] = sheetNameToIdMap[sheetName],\n _a[api_internal_contract_js_1.ParameterId.SendNotifications] = true,\n _a);\n switch (format) {\n case api_external_contract_js_1.CrosstabFileFormat.CSV:\n verb = api_internal_contract_js_1.VerbId.ExportCrosstabCsvDownload;\n // CSV only parameter: see browser-clients/export-crosstab-options-dialog repo\n parameters[api_internal_contract_js_1.ParameterId.UseTabDelimiters] = true;\n break;\n case api_external_contract_js_1.CrosstabFileFormat.Excel:\n verb = api_internal_contract_js_1.VerbId.ExportCrosstabExcelDownload;\n break;\n default:\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'unsupported Crosstab file format.');\n }\n return [2 /*return*/, this.execute(verb, parameters)\n .then(function (response) {\n var result = response.result;\n return result;\n })\n .catch(function () {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.CrosstabCreationError, 'An unexpected error occurred while generating the document.');\n })];\n }\n });\n });\n };\n ExportServiceImpl.prototype.exportDataAsync = function (visualId, options) {\n var _a;\n var _b;\n ErrorHelpers_1.ErrorHelpers.verifyExportDataOptions(options);\n // Remove any duplicates from the input array\n var columnsAsSet = new Set(options.columnsToIncludeById);\n var columnsToIncludeById = Array.from(columnsAsSet);\n var verb = api_internal_contract_js_1.VerbId.ExportDataDownload;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'exportDataAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = (_b = options.ignoreAliases, (_b !== null && _b !== void 0 ? _b : false)),\n _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = columnsToIncludeById,\n _a);\n return this.execute(verb, parameters)\n .then(function () { })\n .catch(function () {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.DataCreationError, 'An unexpected error occurred while generating the document.');\n });\n };\n ExportServiceImpl.prototype.exportPowerPointAsync = function (sheetNames, exportScenarios) {\n var _a;\n ErrorHelpers_1.ErrorHelpers.verifySheetNamesForPDFAndPPT(sheetNames, exportScenarios);\n // Note: the ExportOriginUrl param is listed as optional for the pres layer command we are invoking; however,\n // recent changes were made that enforced the use of the empty string when invoking this command with no ExportOriginUrl.\n // see browser-clients/export-powerpoint-options-dialog repo.\n var verb = api_internal_contract_js_1.VerbId.ExportPowerpointDownload;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'exportPowerPointAsync',\n _a[api_internal_contract_js_1.ParameterId.ExportOriginUrl] = '',\n _a[api_internal_contract_js_1.ParameterId.SelectedSheetNames] = sheetNames,\n _a);\n return this.execute(verb, parameters)\n .then(function (response) {\n var result = response.result;\n return result;\n })\n .catch(function () {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.PowerPointCreationError, 'An error occured while attempting to generate the PowerPoint file.');\n });\n };\n ExportServiceImpl.prototype.exportPDFAsync = function (sheetNames, externalExportPdfOptions, exportScenarios) {\n return __awaiter(this, void 0, void 0, function () {\n var internalExportPdfOptions, verb, parameters;\n var _a;\n return __generator(this, function (_b) {\n switch (_b.label) {\n case 0:\n ErrorHelpers_1.ErrorHelpers.verifyExportPDFOptions(externalExportPdfOptions);\n ErrorHelpers_1.ErrorHelpers.verifySheetNamesForPDFAndPPT(sheetNames, exportScenarios);\n return [4 /*yield*/, this.getExportPDFOptionsAsync()];\n case 1:\n internalExportPdfOptions = _b.sent();\n ExportHelpers_1.ExportHelpers.updateInternalExportPDFOptions(internalExportPdfOptions, externalExportPdfOptions, sheetNames);\n verb = api_internal_contract_js_1.VerbId.ExportPdfDownload;\n parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'exportPDFAsync',\n _a[api_internal_contract_js_1.ParameterId.ExportPdfOptions] = internalExportPdfOptions,\n _a);\n return [2 /*return*/, this.execute(verb, parameters)\n .then(function (response) {\n var result = response.result;\n return result;\n })\n .catch(function () {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.PDFCreationError, 'Unable to create PDF because something went wrong. Try again.');\n })];\n }\n });\n });\n };\n ExportServiceImpl.prototype.getExportPDFOptionsAsync = function () {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.GetExportPdfOptions;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getExportPdfOptionsAsync',\n _a);\n return this.execute(verb, parameters).then(function (response) {\n var result = response.result;\n return result;\n });\n };\n return ExportServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.ExportServiceImpl = ExportServiceImpl;\n//# sourceMappingURL=ExportServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar ExternalContextMenuServiceImpl = /** @class */ (function (_super) {\n __extends(ExternalContextMenuServiceImpl, _super);\n function ExternalContextMenuServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(ExternalContextMenuServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"external-context-menu-service\" /* ExternalContextMenu */;\n },\n enumerable: true,\n configurable: true\n });\n ExternalContextMenuServiceImpl.prototype.appendContextMenuAsync = function (sheetName, targetMenu, config) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.AppendExternalMenuItem;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'appendContextMenuAsync',\n _a[api_internal_contract_js_1.ParameterId.WorksheetName] = sheetName,\n _a[api_internal_contract_js_1.ParameterId.ExternalMenuItemDisplayName] = config.displayName,\n _a);\n return this.execute(verb, parameters).then(function (response) {\n var newMenuItemId = response.result;\n return newMenuItemId;\n });\n };\n ExternalContextMenuServiceImpl.prototype.removeContextMenuAsync = function (sheetName, targetMenu, menuItemId) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.RemoveExternalMenuItem;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'removeContextMenuAsync',\n _a[api_internal_contract_js_1.ParameterId.WorksheetName] = sheetName,\n _a[api_internal_contract_js_1.ParameterId.ExternalMenuItemId] = menuItemId,\n _a);\n return this.execute(verb, parameters).then(function (response) {\n return;\n });\n };\n ExternalContextMenuServiceImpl.prototype.executeContextMenuAsync = function (sheetName, targetMenu, menuItemId) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.ExecuteExternalMenuItem;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'executeContextMenuAsync',\n _a[api_internal_contract_js_1.ParameterId.WorksheetName] = sheetName,\n _a[api_internal_contract_js_1.ParameterId.ExternalMenuItemId] = menuItemId,\n _a);\n return this.execute(verb, parameters).then(function (response) {\n return;\n });\n };\n ExternalContextMenuServiceImpl.prototype.renameContextMenuAsync = function (sheetName, targetMenu, menuHeader, menuDescription) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.RenameExternalMenu;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'renameContextMenuAsync',\n _a[api_internal_contract_js_1.ParameterId.WorksheetName] = sheetName,\n _a[api_internal_contract_js_1.ParameterId.ExternalMenuHeader] = menuHeader,\n _a[api_internal_contract_js_1.ParameterId.ExternalMenuDescription] = menuDescription,\n _a);\n return this.execute(verb, parameters).then(function (response) {\n return;\n });\n };\n return ExternalContextMenuServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.ExternalContextMenuServiceImpl = ExternalContextMenuServiceImpl;\n//# sourceMappingURL=ExternalContextMenuServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f) throw new TypeError(\"Generator is already executing.\");\n while (_) try {\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n if (y = 0, t) op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0: case 1: t = op; break;\n case 4: _.label++; return { value: op[1], done: false };\n case 5: _.label++; y = op[1]; op = [0]; continue;\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n if (t[2]) _.ops.pop();\n _.trys.pop(); continue;\n }\n op = body.call(thisArg, _);\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar InternalContract = require(\"@tableau/api-internal-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar ApiShared_1 = require(\"../../../ApiShared\");\nvar ExternalToInternalEnumMappings_1 = require(\"../../EnumMappings/ExternalToInternalEnumMappings\");\nvar InternalToExternalEnumMappings_1 = require(\"../../EnumMappings/InternalToExternalEnumMappings\");\nvar FilterModels_1 = require(\"../../Models/FilterModels\");\nvar DataValueFactory_1 = require(\"../../Utils/DataValueFactory\");\nvar Param_1 = require(\"../../Utils/Param\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar FilterServiceImpl = /** @class */ (function (_super) {\n __extends(FilterServiceImpl, _super);\n function FilterServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(FilterServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"filter-service\" /* Filter */;\n },\n enumerable: true,\n configurable: true\n });\n FilterServiceImpl.prototype.applyFilterAsync = function (visualId, fieldName, values, updateType, filterOptions) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.ApplyCategoricalFilter;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'applyFilterAsync',\n _a);\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId;\n parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName;\n if (!Array.isArray(values)) {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'values parameter for applyFilterAsync must be an array');\n }\n parameters[api_internal_contract_js_1.ParameterId.FilterValues] = values;\n parameters[api_internal_contract_js_1.ParameterId.FilterUpdateType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterUpdateType.convert(updateType);\n parameters[api_internal_contract_js_1.ParameterId.IsExcludeMode] =\n filterOptions === undefined || filterOptions.isExcludeMode === undefined ? false : filterOptions.isExcludeMode;\n return this.execute(verb, parameters).then(function (response) {\n return fieldName;\n });\n };\n FilterServiceImpl.prototype.applyRangeFilterAsync = function (visualId, fieldName, filterOptions) {\n var _a;\n var _this = this;\n var verb = api_internal_contract_js_1.VerbId.ApplyRangeFilter;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'applyRangeFilterAsync',\n _a);\n if (filterOptions.min !== undefined && filterOptions.min !== null) {\n var min = void 0;\n if (filterOptions.min instanceof Date) {\n min = Param_1.Param.serializeDateForPlatform(filterOptions.min);\n }\n else {\n min = filterOptions.min;\n }\n parameters[api_internal_contract_js_1.ParameterId.FilterRangeMin] = min;\n }\n if (filterOptions.max !== undefined && filterOptions.max !== null) {\n var max = void 0;\n if (filterOptions.max instanceof Date) {\n max = Param_1.Param.serializeDateForPlatform(filterOptions.max);\n }\n else {\n max = filterOptions.max;\n }\n parameters[api_internal_contract_js_1.ParameterId.FilterRangeMax] = max;\n }\n // The null option is used with min+max for 'include-range' or 'include-range-or-null'\n if (filterOptions.nullOption) {\n parameters[api_internal_contract_js_1.ParameterId.FilterRangeNullOption] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.nullOptions.convert(filterOptions.nullOption);\n }\n parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName;\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId;\n return this.execute(verb, parameters).then(function (response) {\n _this.apiFilterHandlerCheckForCommandError(response.result);\n return fieldName;\n });\n };\n FilterServiceImpl.prototype.applyHierarchicalFilterAsync = function (visualId, fieldName, values, updateType, filterOptions) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.HierarchicalFilter;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'applyHierarchicalFilterAsync',\n _a);\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId;\n parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName;\n var hierarchicalLevels = values.levels;\n if (Array.isArray(hierarchicalLevels) && hierarchicalLevels.length > 0) {\n parameters[api_internal_contract_js_1.ParameterId.FilterLevels] = hierarchicalLevels;\n }\n else if (values.length > 0) {\n parameters[api_internal_contract_js_1.ParameterId.FilterValues] = values;\n }\n else {\n // the server command expects empty list for clearing the filter\n // it also expects eithers FilterLevels or FilterValues to be set\n parameters[api_internal_contract_js_1.ParameterId.FilterLevels] = [];\n }\n parameters[api_internal_contract_js_1.ParameterId.FilterUpdateType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterUpdateType.convert(updateType);\n parameters[api_internal_contract_js_1.ParameterId.IsExcludeMode] = filterOptions && !!filterOptions.isExcludeMode;\n return this.execute(verb, parameters).then(function (response) {\n return fieldName;\n });\n };\n FilterServiceImpl.prototype.clearFilterAsync = function (visualId, fieldName) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.ClearFilter;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'clearFilterAsync',\n _a);\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId;\n parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName;\n return this.execute(verb, parameters).then(function (resposne) {\n return fieldName;\n });\n };\n FilterServiceImpl.prototype.applyRelativeDateFilterAsync = function (visualId, fieldName, options) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.ApplyRelativeDateFilter;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'applyRelativeDateFilterAsync',\n _a);\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId;\n parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName;\n parameters[api_internal_contract_js_1.ParameterId.PeriodType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.periodType.convert(options.periodType);\n parameters[api_internal_contract_js_1.ParameterId.DateRangeType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.dateRangeType.convert(options.rangeType);\n if (options.rangeType === api_external_contract_js_1.DateRangeType.LastN || options.rangeType === api_external_contract_js_1.DateRangeType.NextN) {\n if (options.rangeN === undefined || options.rangeN === null) {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.EmbeddingErrorCodes.MissingRangeNForRelativeDateFilters, 'Missing rangeN field for a relative date filter of LASTN or NEXTN.');\n }\n parameters[api_internal_contract_js_1.ParameterId.RangeN] = options.rangeN;\n }\n if (options.anchorDate !== undefined && options.anchorDate !== null) {\n parameters[api_internal_contract_js_1.ParameterId.AnchorDate] = this.convertAnchorDate(options.anchorDate);\n }\n return this.execute(verb, parameters).then(function (response) {\n return response.result;\n });\n };\n FilterServiceImpl.prototype.getFiltersAsync = function (visualId) {\n var _a;\n var _this = this;\n var verb = api_internal_contract_js_1.VerbId.GetFilters;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getFiltersAsync',\n _a);\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId;\n return this.execute(verb, parameters).then(function (response) {\n var filters = response.result;\n return _this.convertDomainFilters(filters);\n });\n };\n FilterServiceImpl.prototype.getCategoricalDomainAsync = function (worksheetName, fieldId, domainType) {\n var _a;\n var _this = this;\n var verb = api_internal_contract_js_1.VerbId.GetCategoricalDomain;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getCategoricalDomainAsync',\n _a);\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = {\n worksheet: worksheetName,\n };\n parameters[api_internal_contract_js_1.ParameterId.FieldId] = fieldId;\n parameters[api_internal_contract_js_1.ParameterId.DomainType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterDomainType.convert(domainType);\n return this.execute(verb, parameters).then(function (response) {\n var domain = response.result;\n return _this.convertCategoricalDomain(domain, domainType);\n });\n };\n FilterServiceImpl.prototype.getRangeDomainAsync = function (worksheetName, fieldId, domainType) {\n var _a;\n var _this = this;\n var verb = api_internal_contract_js_1.VerbId.GetRangeDomain;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getRangeDomainAsync',\n _a);\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = {\n worksheet: worksheetName,\n };\n parameters[api_internal_contract_js_1.ParameterId.FieldId] = fieldId;\n parameters[api_internal_contract_js_1.ParameterId.DomainType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterDomainType.convert(domainType);\n return this.execute(verb, parameters).then(function (response) {\n var domain = response.result;\n return _this.convertRangeDomain(domain, domainType);\n });\n };\n FilterServiceImpl.prototype.getDashboardFiltersAsync = function () {\n var _a;\n var _this = this;\n var verb = api_internal_contract_js_1.VerbId.GetDashboardFilters;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getDashboardFiltersAsync',\n _a);\n return this.execute(verb, parameters).then(function (response) {\n var filters = response.result;\n return _this.convertDomainFilters(filters);\n });\n };\n FilterServiceImpl.prototype.applyDashboardFilterAsync = function (fieldName, values, updateType, filterOptions) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.DashboardCategoricalFilter;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'applyDashboardFilterAsync',\n _a);\n parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName;\n parameters[api_internal_contract_js_1.ParameterId.FilterValues] = values;\n parameters[api_internal_contract_js_1.ParameterId.FilterUpdateType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterUpdateType.convert(updateType);\n parameters[api_internal_contract_js_1.ParameterId.IsExcludeMode] = filterOptions && !!filterOptions.isExcludeMode;\n return this.execute(verb, parameters).then(function (response) {\n return response.result;\n });\n };\n FilterServiceImpl.prototype.getAppliedWorksheetsAsync = function (worksheetName, fieldId) {\n var _a;\n return __awaiter(this, void 0, void 0, function () {\n var sharedFilterModel, worksheetNames;\n return __generator(this, function (_b) {\n switch (_b.label) {\n case 0: return [4 /*yield*/, this.executeGetAppliedWorksheets(worksheetName, fieldId, 'getAppliedWorksheetsAsync')];\n case 1:\n sharedFilterModel = _b.sent();\n worksheetNames = [];\n (_a = sharedFilterModel.worksheets) === null || _a === void 0 ? void 0 : _a.map(function (worksheetInfo) {\n if (worksheetInfo.isSelected) {\n worksheetNames.push(worksheetInfo.worksheetName);\n }\n });\n return [2 /*return*/, worksheetNames];\n }\n });\n });\n };\n FilterServiceImpl.prototype.setAppliedWorksheetsAsync = function (worksheetName, fieldName, fieldId, applyToWorksheets) {\n return __awaiter(this, void 0, void 0, function () {\n var sharedFilterModel, allowedWorksheets, activeWorksheet, verb, parameters;\n return __generator(this, function (_a) {\n switch (_a.label) {\n case 0: return [4 /*yield*/, this.executeGetAppliedWorksheets(worksheetName, fieldId, 'getAppliedWorksheetsAsyncInternal')];\n case 1:\n sharedFilterModel = _a.sent();\n if (!sharedFilterModel || !sharedFilterModel.worksheets) {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'This filter does not apply to multiple worksheets');\n }\n allowedWorksheets = [];\n activeWorksheet = '';\n sharedFilterModel.worksheets.forEach(function (worksheet) {\n // Get active worksheet\n if (worksheet.isActive) {\n activeWorksheet = worksheet.worksheetName;\n }\n // Populate allowed worksheets\n if (worksheet.isSelected || worksheet.isEnabled) {\n allowedWorksheets.push(worksheet.worksheetName);\n }\n });\n if (activeWorksheet === '') {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'No active worksheet');\n }\n if (!applyToWorksheets.includes(activeWorksheet)) {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, activeWorksheet + \" must be included in the applied worksheets\");\n }\n applyToWorksheets.forEach(function (sheet) {\n // check if it's present within compatible sheets\n if (!allowedWorksheets.includes(sheet)) {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, \"The field \" + fieldName + \" isn't applicable to the worksheet \" + sheet);\n }\n });\n verb = api_internal_contract_js_1.VerbId.ChangeSharedFilter;\n parameters = {};\n parameters[api_internal_contract_js_1.ParameterId.FunctionName] = 'setAppliedWorksheetsAsync';\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = {\n worksheet: worksheetName,\n };\n parameters[api_internal_contract_js_1.ParameterId.FieldId] = fieldId;\n parameters[api_internal_contract_js_1.ParameterId.SharedFilterSheets] = applyToWorksheets;\n return [2 /*return*/, this.execute(verb, parameters).then(function (response) {\n return applyToWorksheets;\n })];\n }\n });\n });\n };\n // Helper Methods\n FilterServiceImpl.prototype.executeGetAppliedWorksheets = function (worksheetName, fieldId, telemetryFunctionName) {\n var verb = api_internal_contract_js_1.VerbId.GetSharedFilter;\n var parameters = {};\n parameters[api_internal_contract_js_1.ParameterId.FunctionName] = telemetryFunctionName;\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = {\n worksheet: worksheetName,\n };\n parameters[api_internal_contract_js_1.ParameterId.FieldId] = fieldId;\n return this.execute(verb, parameters).then(function (response) {\n var sharedFilterModel = response.result;\n return sharedFilterModel;\n });\n };\n FilterServiceImpl.prototype.convertDomainFilters = function (domainFilters) {\n var _this = this;\n var filters = [];\n domainFilters.forEach(function (domainFilter) {\n switch (domainFilter.filterType) {\n case api_internal_contract_js_1.FilterType.Categorical: {\n var filter = domainFilter;\n if (filter) {\n filters.push(_this.convertCategoricalFilter(filter));\n }\n else {\n throw new Error('Invalid Categorical Filter');\n }\n break;\n }\n case api_internal_contract_js_1.FilterType.Hierarchical: {\n var filter = domainFilter;\n if (filter) {\n filters.push(_this.convertHierarchicalFilter(filter));\n }\n else {\n throw new Error('Invalid Hierarchical Filter');\n }\n break;\n }\n case api_internal_contract_js_1.FilterType.Range: {\n var filter = domainFilter;\n if (filter) {\n filters.push(_this.convertRangeFilter(filter));\n }\n else {\n throw new Error('Invalid Range Filter');\n }\n break;\n }\n case api_internal_contract_js_1.FilterType.RelativeDate: {\n var filter = domainFilter;\n if (filter) {\n filters.push(_this.convertRelativeDateFilter(filter));\n }\n else {\n throw new Error('Invalid Relative Date Filter');\n }\n break;\n }\n default: {\n break;\n }\n }\n });\n return filters;\n };\n FilterServiceImpl.prototype.convertCategoricalFilter = function (domainFilter) {\n var appliedValues = domainFilter.values.map(function (dv) {\n return DataValueFactory_1.DataValueFactory.MakeFilterDataValue(dv);\n });\n return new FilterModels_1.CategoricalFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, api_internal_contract_js_1.FilterType.Categorical, this._registryId, appliedValues, domainFilter.isExclude, domainFilter.isAllSelected);\n };\n FilterServiceImpl.prototype.convertHierarchicalFilter = function (domainFilter) {\n var appliedValues = domainFilter.values.map(function (hierarchicalDataValue) {\n return new FilterModels_1.HierarchicalDataValue(DataValueFactory_1.DataValueFactory.MakeFilterDataValue(hierarchicalDataValue.value), hierarchicalDataValue.hierarchicalPath, hierarchicalDataValue.level);\n });\n var levelDetails = domainFilter.levelInfo.map(function (aLevel) {\n return new FilterModels_1.HierarchicalLevelDetail(aLevel.name, InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.hierarchicalLevelSelectionState.convert(aLevel.levelSelectionState));\n });\n return new FilterModels_1.HierarchicalFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, api_internal_contract_js_1.FilterType.Hierarchical, this._registryId, domainFilter.dimensionName, domainFilter.hierarchyCaption, domainFilter.levels, levelDetails, appliedValues, domainFilter.isAllSelected);\n };\n FilterServiceImpl.prototype.convertRangeFilter = function (domainFilter) {\n var minValue = DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domainFilter.min);\n var maxValue = DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domainFilter.max);\n return new FilterModels_1.RangeFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, api_internal_contract_js_1.FilterType.Range, this._registryId, minValue, maxValue, domainFilter.includeNullValues);\n };\n FilterServiceImpl.prototype.convertRelativeDateFilter = function (domainFilter) {\n var anchorDateValue = DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domainFilter.anchorDate);\n return new FilterModels_1.RelativeDateFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, api_external_contract_js_1.FilterType.RelativeDate, this._registryId, anchorDateValue, InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dateStepPeriod.convert(domainFilter.periodType), InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dateRangeType.convert(domainFilter.rangeType), domainFilter.rangeN);\n };\n FilterServiceImpl.prototype.convertCategoricalDomain = function (domain, domainType) {\n var values = domain.values.map(function (domainDv) {\n return DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domainDv);\n });\n return new FilterModels_1.CategoricalDomain(values, domainType);\n };\n FilterServiceImpl.prototype.convertRangeDomain = function (domain, domainType) {\n var min = DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domain.min);\n var max = DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domain.max);\n return new FilterModels_1.RangeDomain(min, max, domainType);\n };\n FilterServiceImpl.prototype.convertAnchorDate = function (anchorDate) {\n // Converts a Date object into a string format that the server expects for date/time values.\n // If anchorDate doesn't represent a valid Date object, any of these would be NaN.\n var year = anchorDate.getUTCFullYear();\n var month = anchorDate.getUTCMonth() + 1;\n var day = anchorDate.getUTCDate();\n var hh = anchorDate.getUTCHours();\n var mm = anchorDate.getUTCMinutes();\n var sec = anchorDate.getUTCSeconds();\n if (isNaN(year) || isNaN(month) || isNaN(day) || isNaN(hh) || isNaN(mm) || isNaN(sec)) {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.EmbeddingErrorCodes.InvalidDateParameter, 'Invalid date parameter: anchorDate');\n }\n var result = year + \"-\" + month + \"-\" + day + \" \" + hh + \":\" + mm + \":\" + sec;\n return result;\n };\n FilterServiceImpl.prototype.apiFilterHandlerCheckForCommandError = function (serverPm) {\n if (!serverPm[InternalContract.ParameterId.ParameterError]) {\n return;\n }\n if (serverPm[InternalContract.ParameterId.InvalidFieldCaption]) {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidFilterFieldName, serverPm[InternalContract.ParameterId.InvalidFieldCaption]);\n }\n if (serverPm[InternalContract.ParameterId.InvalidValues]) {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidFilterFieldValue, serverPm[InternalContract.ParameterId.InvalidValues]);\n }\n if (serverPm[InternalContract.ParameterId.InvalidAggFieldName]) {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidAggregationFieldName, serverPm[InternalContract.ParameterId.InvalidAggFieldName]);\n }\n throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.ServerError, 'Server Error');\n };\n return FilterServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.FilterServiceImpl = FilterServiceImpl;\n//# sourceMappingURL=FilterServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar uuid_1 = require(\"uuid\");\nvar ApiShared_1 = require(\"../../../ApiShared\");\nvar ExternalToInternalEnumMappings_1 = require(\"../../EnumMappings/ExternalToInternalEnumMappings\");\nvar GetDataModels_1 = require(\"../../Models/GetDataModels\");\nvar GetDataTableReaderModels_1 = require(\"../../Models/GetDataTableReaderModels\");\nvar DataValueFactory_1 = require(\"../../Utils/DataValueFactory\");\nvar GetDataService_1 = require(\"../GetDataService\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar GetDataServiceImpl = /** @class */ (function (_super) {\n __extends(GetDataServiceImpl, _super);\n function GetDataServiceImpl() {\n var _this = _super !== null && _super.apply(this, arguments) || this;\n // The extension/embedding instance uses the same cache for all DataTableReaders.\n _this.viewDataTableCacheId = uuid_1.v4();\n return _this;\n }\n Object.defineProperty(GetDataServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"get-data-service\" /* GetData */;\n },\n enumerable: true,\n configurable: true\n });\n GetDataServiceImpl.prototype.getMaxRowLimit = function () {\n return 10000;\n };\n GetDataServiceImpl.prototype.getViewDataTableCacheId = function () {\n return this.viewDataTableCacheId;\n };\n GetDataServiceImpl.prototype.getLimitedMaxRows = function (requestedRows, rowCountLimit) {\n return requestedRows > 0 && requestedRows < rowCountLimit ? requestedRows : rowCountLimit;\n };\n GetDataServiceImpl.prototype.getUnderlyingDataAsync = function (visualId, getType, ignoreAliases, ignoreSelection, includeAllColumns, columnsToIncludeById, maxRows, includeDataValuesOption) {\n var _a;\n var _this = this;\n // Create all of our parameters\n var summaryData = getType === GetDataService_1.GetDataType.Summary;\n var functionName = summaryData ? 'getSummaryDataAsync' : 'getUnderlyingDataAsync';\n var verb = summaryData ? api_internal_contract_js_1.VerbId.GetDataSummaryData : api_internal_contract_js_1.VerbId.GetUnderlyingData;\n var requestMaxRows = verb === api_internal_contract_js_1.VerbId.GetUnderlyingData ? this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1) : maxRows;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = functionName,\n _a);\n parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId;\n parameters[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases;\n parameters[api_internal_contract_js_1.ParameterId.IgnoreSelection] = ignoreSelection;\n parameters[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = includeAllColumns;\n parameters[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById);\n parameters[api_internal_contract_js_1.ParameterId.MaxRows] = requestMaxRows;\n parameters[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption);\n return this.execute(verb, parameters).then(function (response) {\n var responseData = response.result;\n return _this.processResultsTable(responseData.data, responseData.isSummary);\n });\n };\n GetDataServiceImpl.prototype.getSummaryDataReaderAsync = function (visualId, pageRowCount, ignoreAliases, ignoreSelection, includeAllColumns, columnsToIncludeById, includeDataValuesOption) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getSummaryDataReaderAsync',\n _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(),\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a[api_internal_contract_js_1.ParameterId.PageRowCount] = pageRowCount,\n _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases,\n _a[api_internal_contract_js_1.ParameterId.IgnoreSelection] = ignoreSelection,\n _a[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = includeAllColumns,\n _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById),\n _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetDataSummaryDataReader, parameters).then(function (response) {\n var responseData = response.result;\n return new GetDataTableReaderModels_1.DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, _this._registryId);\n });\n };\n GetDataServiceImpl.prototype.getSummaryColumnsInfoAsync = function (visualId) {\n var _a;\n // Create all the parameters for GetDataType of Summary with 1 row, and only native values\n // Then return just the columns\n var verb = api_internal_contract_js_1.VerbId.GetDataSummaryData;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getSummaryColumnsInfoAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = true,\n _a[api_internal_contract_js_1.ParameterId.IgnoreSelection] = true,\n _a[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = true,\n _a[api_internal_contract_js_1.ParameterId.MaxRows] = 1,\n _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = api_internal_contract_js_1.ApiShowDataTableFormat.NativeValuesOnly,\n _a);\n return this.execute(verb, parameters).then(function (response) {\n var underlyingDataTable = response.result;\n var dataTable = underlyingDataTable.data;\n var columns = dataTable.headers.map(function (h) { return new GetDataModels_1.Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index); });\n return columns;\n });\n };\n GetDataServiceImpl.prototype.getSelectedMarksAsync = function (visualId) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getSelectedMarksAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetSelectedMarks, parameters).then(function (response) {\n var responseData = response.result;\n return {\n data: responseData.data.map(function (table) { return _this.processResultsTable(table, true); }),\n };\n });\n };\n GetDataServiceImpl.prototype.getHighlightedMarksAsync = function (visualId) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getHighlightedMarksAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetHighlightedMarks, parameters).then(function (response) {\n var responseData = response.result;\n return {\n data: responseData.data.map(function (table) { return _this.processResultsTable(table, true); }),\n };\n });\n };\n GetDataServiceImpl.prototype.getDataSourceDataAsync = function (dataSourceId, ignoreAliases, maxRows, columnsToInclude, columnsToIncludeById, includeDataValuesOption) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getDataSourceDataAsync',\n _a[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId,\n _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases,\n _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1),\n _a[api_internal_contract_js_1.ParameterId.ColumnsToInclude] = this.verifyIncludeColumnArray(columnsToInclude),\n _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById),\n _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetDataSourceData, parameters).then(function (response) {\n var responseData = response.result;\n return _this.processResultsTable(responseData.data, false);\n });\n };\n GetDataServiceImpl.prototype.getLogicalTableDataAsync = function (datasourceId, logicalTableId, ignoreAliases, maxRows, columnsToInclude, columnsToIncludeById, includeDataValuesOption) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getLogicalTableDataAsync',\n _a[api_internal_contract_js_1.ParameterId.ColumnsToInclude] = columnsToInclude,\n _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById),\n _a[api_internal_contract_js_1.ParameterId.DataSourceId] = datasourceId,\n _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases,\n _a[api_internal_contract_js_1.ParameterId.LogicalTableId] = logicalTableId,\n _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1),\n _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetLogicalTableData, parameters).then(function (response) {\n var responseData = response.result;\n return _this.processResultsTable(responseData.data, false);\n });\n };\n GetDataServiceImpl.prototype.getLogicalTableDataReaderAsync = function (datasourceId, logicalTableId, pageRowCount, ignoreAliases, columnsToIncludeById, includeDataValuesOption) {\n var _a;\n var _this = this;\n pageRowCount = this.getLimitedMaxRows(pageRowCount, this.getMaxRowLimit());\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getLogicalTableDataReaderAsync',\n _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(),\n _a[api_internal_contract_js_1.ParameterId.DataSourceId] = datasourceId,\n _a[api_internal_contract_js_1.ParameterId.LogicalTableId] = logicalTableId,\n _a[api_internal_contract_js_1.ParameterId.PageRowCount] = pageRowCount,\n _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases,\n _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById),\n _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetLogicalTableDataReader, parameters).then(function (response) {\n var responseData = response.result;\n return new GetDataTableReaderModels_1.DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, _this._registryId);\n });\n };\n GetDataServiceImpl.prototype.getUnderlyingTableDataAsync = function (visualId, logicalTableId, ignoreAliases, ignoreSelection, includeAllColumns, columnsToIncludeById, maxRows, includeDataValuesOption) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getUnderlyingTableDataAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a[api_internal_contract_js_1.ParameterId.LogicalTableId] = logicalTableId,\n _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases,\n _a[api_internal_contract_js_1.ParameterId.IgnoreSelection] = ignoreSelection,\n _a[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = includeAllColumns,\n _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById),\n _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1),\n _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetUnderlyingTableData, parameters).then(function (response) {\n var responseData = response.result;\n return _this.processResultsTable(responseData.data, false);\n });\n };\n GetDataServiceImpl.prototype.getUnderlyingTableDataReaderAsync = function (visualId, logicalTableId, pageRowCount, ignoreAliases, ignoreSelection, includeAllColumns, columnsToIncludeById, includeDataValuesOption) {\n var _a;\n var _this = this;\n pageRowCount = this.getLimitedMaxRows(pageRowCount, this.getMaxRowLimit());\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getUnderlyingTableDataReaderAsync',\n _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(),\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a[api_internal_contract_js_1.ParameterId.LogicalTableId] = logicalTableId,\n _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases,\n _a[api_internal_contract_js_1.ParameterId.IgnoreSelection] = ignoreSelection,\n _a[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = includeAllColumns,\n _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById),\n _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n _a[api_internal_contract_js_1.ParameterId.PageRowCount] = pageRowCount,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetUnderlyingTableDataReader, parameters).then(function (response) {\n var responseData = response.result;\n return new GetDataTableReaderModels_1.DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, _this._registryId);\n });\n };\n GetDataServiceImpl.prototype.getPageAsync = function (tableId, pageNumber, pageSize) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getPageAsync',\n _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(),\n _a[api_internal_contract_js_1.ParameterId.ViewDataTableId] = tableId,\n _a[api_internal_contract_js_1.ParameterId.DataRowIndex] = pageNumber * pageSize,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetDataTableReaderPage, parameters).then(function (response) {\n var responseData = response.result;\n return _this.processResultsPage(responseData, tableId === GetDataServiceImpl.summaryTableId ? true : false);\n });\n };\n GetDataServiceImpl.prototype.releaseAsync = function (tableId) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'release',\n _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(),\n _a[api_internal_contract_js_1.ParameterId.ViewDataTableId] = tableId,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.ReleaseDataTableReader, parameters).then(function (response) {\n return;\n });\n };\n GetDataServiceImpl.prototype.verifyIncludeColumnArray = function (columns) {\n // columns must be a valid array\n if (!Array.isArray(columns)) {\n throw new ApiShared_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'columnsToInclude and columnsToIncludeById must be valid arrays');\n }\n // Remove any duplicates from the input array\n var columnsAsSet = new Set(columns);\n return Array.from(columnsAsSet);\n };\n GetDataServiceImpl.prototype.processResultsTable = function (responseData, isSummary) {\n var headers = responseData.headers.map(function (h) { return new GetDataModels_1.Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index); });\n // TODO This should be controlled by a flag indicating whether this api will respond marks info or not\n var marks;\n if (responseData.marks) {\n marks = responseData.marks.map(function (h) { return new GetDataModels_1.MarkInfo(h.type, h.color, h.tupleId); });\n }\n // Limit+1 is our sentinal that underlying data contains more rows than user is allowed to fetch.\n // Remove the last element so we always return MaxRowLimit\n var isTotalRowCountLimited = isSummary === false && responseData.dataTable.length === this.getMaxRowLimit() + 1;\n if (isTotalRowCountLimited) {\n responseData.dataTable.length -= 1;\n }\n var table = responseData.dataTable.map(function (row) {\n return row.map(function (cell, index) {\n return DataValueFactory_1.DataValueFactory.MakeTableDataValue(cell, headers[index].dataType);\n });\n });\n if (marks) {\n return new GetDataModels_1.DataTable(table, headers, table.length, isTotalRowCountLimited, isSummary, marks);\n }\n return new GetDataModels_1.DataTable(table, headers, table.length, isTotalRowCountLimited, isSummary);\n };\n GetDataServiceImpl.prototype.processResultsPage = function (responseData, isSummary) {\n var headers = responseData.headers.map(function (h) { return new GetDataModels_1.Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index); });\n var marks;\n if (responseData.marks) {\n marks = responseData.marks.map(function (h) { return new GetDataModels_1.MarkInfo(h.type, h.color, h.tupleId); });\n }\n var table = responseData.dataTable.map(function (row) {\n return row.map(function (cell, index) {\n return DataValueFactory_1.DataValueFactory.MakeTableDataValue(cell, headers[index].dataType);\n });\n });\n if (marks) {\n return new GetDataModels_1.DataTable(table, headers, table.length, false, isSummary, marks);\n }\n return new GetDataModels_1.DataTable(table, headers, table.length, false, isSummary);\n };\n GetDataServiceImpl.summaryTableId = '';\n return GetDataServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.GetDataServiceImpl = GetDataServiceImpl;\n//# sourceMappingURL=GetDataServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar NotificationServiceImplBase_1 = require(\"./NotificationServiceImplBase\");\nvar NotificationServiceImpl = /** @class */ (function (_super) {\n __extends(NotificationServiceImpl, _super);\n function NotificationServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(NotificationServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"notification-service\" /* Notification */;\n },\n enumerable: true,\n configurable: true\n });\n return NotificationServiceImpl;\n}(NotificationServiceImplBase_1.NotificationServiceImplBase));\nexports.NotificationServiceImpl = NotificationServiceImpl;\n//# sourceMappingURL=NotificationServiceImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Registration = /** @class */ (function () {\n function Registration(_filterFn, _callbackFn) {\n this._filterFn = _filterFn;\n this._callbackFn = _callbackFn;\n // Nothing Here\n }\n Registration.prototype.onNotification = function (notificationModel) {\n if (this._filterFn(notificationModel)) {\n this._callbackFn(notificationModel);\n }\n };\n return Registration;\n}());\nexports.Registration = Registration;\nvar NotificationServiceImplBase = /** @class */ (function () {\n function NotificationServiceImplBase(dispatcher) {\n this.dispatcher = dispatcher;\n this._handlers = {};\n this.dispatcher.registerNotificationHandler(this.onNotification.bind(this));\n }\n NotificationServiceImplBase.prototype.registerHandler = function (id, filterFn, handler) {\n var _this = this;\n var handlers = this._handlers[id] || new Array();\n var registration = new Registration(filterFn, handler);\n handlers.push(registration);\n this._handlers[id] = handlers;\n return function () { return _this.removeRegistration(id, registration); };\n };\n NotificationServiceImplBase.prototype.hasHandlersForNotificationType = function (id) {\n // eslint-disable-next-line no-prototype-builtins\n return this._handlers.hasOwnProperty(id);\n };\n NotificationServiceImplBase.prototype.onNotification = function (notification) {\n if (!this.hasHandlersForNotificationType(notification.notificationId)) {\n return;\n }\n // Go through and check for all the handlers of this particular notification\n this._handlers[notification.notificationId].forEach(function (h) { return h.onNotification(notification.data); });\n };\n NotificationServiceImplBase.prototype.removeRegistration = function (id, registration) {\n if (!this.hasHandlersForNotificationType(id)) {\n return;\n }\n this._handlers[id] = this._handlers[id].filter(function (reg) { return reg !== registration; });\n };\n return NotificationServiceImplBase;\n}());\nexports.NotificationServiceImplBase = NotificationServiceImplBase;\n//# sourceMappingURL=NotificationServiceImplBase.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar ParameterImpl_1 = require(\"../../Impl/ParameterImpl\");\nvar TableauError_1 = require(\"../../TableauError\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar ParametersServiceImpl = /** @class */ (function (_super) {\n __extends(ParametersServiceImpl, _super);\n function ParametersServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(ParametersServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"parameters-service\" /* Parameters */;\n },\n enumerable: true,\n configurable: true\n });\n ParametersServiceImpl.prototype.getParametersForSheetAsync = function (sheetPath) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getParametersForSheetAsync',\n _a[api_internal_contract_js_1.ParameterId.SheetPath] = sheetPath,\n _a);\n return this.getParametersAsync(parameters);\n };\n ParametersServiceImpl.prototype.getAllParametersAsync = function () {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getParametersForSheetAsync',\n _a);\n return this.getParametersAsync(parameters);\n };\n ParametersServiceImpl.prototype.getParametersAsync = function (inputParameters) {\n var _this = this;\n return this.execute(api_internal_contract_js_1.VerbId.GetParametersForSheet, inputParameters).then(function (response) {\n var result = response.result;\n return result.map(function (parameterInfo) {\n return new ParameterImpl_1.ParameterImpl(parameterInfo, _this._registryId);\n });\n });\n };\n ParametersServiceImpl.prototype.changeParameterValueAsync = function (fieldName, newValue) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'changeParameterValueAsync',\n _a[api_internal_contract_js_1.ParameterId.ParameterFieldName] = fieldName,\n _a[api_internal_contract_js_1.ParameterId.ParameterValue] = newValue,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.ChangeParameterValue, parameters).then(function (response) {\n var result = response.result;\n return result;\n });\n };\n ParametersServiceImpl.prototype.findParameterByNameAsync = function (name) {\n return this.findParameterAsync(name, undefined);\n };\n ParametersServiceImpl.prototype.findParameterByGlobalFieldNameAsync = function (fieldName) {\n return this.findParameterAsync(undefined, fieldName);\n };\n ParametersServiceImpl.prototype.findParameterAsync = function (name, fieldName) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'findParameterAsync',\n _a);\n if (name !== undefined) {\n parameters[api_internal_contract_js_1.ParameterId.ParameterCaption] = name;\n }\n else if (fieldName !== undefined) {\n parameters[api_internal_contract_js_1.ParameterId.ParameterFieldName] = fieldName;\n }\n else {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'name or fieldName must be provided to find parameter');\n }\n return this.execute(api_internal_contract_js_1.VerbId.FindParameter, parameters).then(function (response) {\n var instanceOfParameterInfo = function (object) {\n return 'fieldName' in object;\n };\n // We need to check to see if we got a valid response back again\n if (instanceOfParameterInfo(response.result)) {\n var result = response.result;\n return new ParameterImpl_1.ParameterImpl(result, _this._registryId);\n }\n else {\n return undefined;\n }\n });\n };\n return ParametersServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.ParametersServiceImpl = ParametersServiceImpl;\n//# sourceMappingURL=ParametersServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar SelectionModels_1 = require(\"../../Models/SelectionModels\");\nvar TableauError_1 = require(\"../../TableauError\");\nvar Param_1 = require(\"../../Utils/Param\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar SelectionServiceImpl = /** @class */ (function (_super) {\n __extends(SelectionServiceImpl, _super);\n function SelectionServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(SelectionServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"selection-service\" /* Selection */;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Method to clear all the selected marks for the given worksheet.\n *\n * @param visualId\n */\n SelectionServiceImpl.prototype.clearSelectedMarksAsync = function (visualId) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'clearSelectedMarksAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.ClearSelectedMarks, parameters).then(function (response) {\n return; // Expecting an empty model and hence the void response.\n });\n };\n /**\n * Method to select marks for the given worksheet.\n *\n * @param visualId\n * @param selectionCriteria\n * @param selectionUpdateType\n */\n SelectionServiceImpl.prototype.selectMarksByValueAsync = function (visualId, selectionCriterias, selectionUpdateType) {\n var _a;\n var _this = this;\n if (selectionCriterias.length === 0) {\n throw new TableauError_1.TableauError(Contract.ErrorCodes.InvalidParameter, 'Selection criteria missing for selecting marks by value');\n }\n var selectionType = this.validateSelectionUpdateType(selectionUpdateType);\n var selectionModelContainer = this.parseSelectionMarks(selectionCriterias);\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'selectMarksByValueAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a[api_internal_contract_js_1.ParameterId.SelectionUpdateType] = selectionType,\n _a);\n if (selectionModelContainer.hierModelArr && selectionModelContainer.hierModelArr.length) {\n parameters[api_internal_contract_js_1.ParameterId.HierValSelectionModels] = selectionModelContainer.hierModelArr;\n }\n if (selectionModelContainer.quantModelArr && selectionModelContainer.quantModelArr.length) {\n parameters[api_internal_contract_js_1.ParameterId.QuantRangeSelectionModels] = selectionModelContainer.quantModelArr;\n }\n if (selectionModelContainer.dimModelArr && selectionModelContainer.dimModelArr.length) {\n parameters[api_internal_contract_js_1.ParameterId.DimValSelectionModels] = selectionModelContainer.dimModelArr;\n }\n return this.execute(api_internal_contract_js_1.VerbId.SelectByValue, parameters).then(function (response) {\n _this.apiFilterHandlerCheckForCommandError(response.result);\n return;\n });\n };\n /**\n * Method to execute hover actions and render tooltip for a given tuple representing a mark in the visualization.\n * If the tooltip parameter is included it will show the tooltip on hover. If not, no tooltip is shown.\n *\n * @param visualId\n * @param hoveredTuple\n * @param tooltip\n * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error\n */\n SelectionServiceImpl.prototype.hoverTupleAsync = function (visualId, hoveredTuple, tooltip, allowHoverActions) {\n var _a;\n var interactionModel = new SelectionModels_1.HoverTupleInteractionModel(visualId, this.ensureTupleIDIsNonNegative(hoveredTuple), tooltip, allowHoverActions);\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'hoverTupleAsync',\n _a[api_internal_contract_js_1.ParameterId.HoverTupleInteraction] = interactionModel,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.RaiseHoverTupleNotification, parameters).then(function (response) {\n return;\n });\n };\n /**\n * Method to modify selection, execute select actions and render tooltip for a given list of tuples representing a mark or marks in the visualization.\n * If the tooltip parameter is included it will show the tooltip on select. If not, no tooltip is shown.\n *\n * @param visualId\n * @param selectedTuples\n * @param selectOption\n * @param tooltip\n * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error\n */\n SelectionServiceImpl.prototype.selectTuplesAsync = function (visualId, selectedTuples, selectOption, tooltip) {\n var _a;\n var interactionModel = new SelectionModels_1.SelectTuplesInteractionModel(visualId, selectedTuples, selectOption, tooltip);\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'selectTuplesAsync',\n _a[api_internal_contract_js_1.ParameterId.SelectTuplesInteraction] = interactionModel,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.RaiseSelectTuplesNotification, parameters).then(function (response) {\n return;\n });\n };\n SelectionServiceImpl.prototype.apiFilterHandlerCheckForCommandError = function (serverPm) {\n if (!serverPm[api_internal_contract_js_1.ParameterId.ParameterError]) {\n return;\n }\n if (serverPm[api_internal_contract_js_1.ParameterId.InvalidFields]) {\n throw new TableauError_1.TableauError(Contract.SharedErrorCodes.InvalidSelectionFieldName, serverPm[api_internal_contract_js_1.ParameterId.InvalidFields]);\n }\n if (serverPm[api_internal_contract_js_1.ParameterId.InvalidValues]) {\n throw new TableauError_1.TableauError(Contract.SharedErrorCodes.InvalidSelectionValue, serverPm[api_internal_contract_js_1.ParameterId.InvalidValues]);\n }\n if (serverPm[api_internal_contract_js_1.ParameterId.InvalidDates]) {\n throw new TableauError_1.TableauError(Contract.SharedErrorCodes.InvalidSelectionDate, serverPm[api_internal_contract_js_1.ParameterId.InvalidDates]);\n }\n };\n /**\n * Method to select marks for the given worksheet.\n *\n * @param visualId\n * @param MarkInfo\n * @param selectionUpdateType\n */\n SelectionServiceImpl.prototype.selectMarksByIdAsync = function (visualId, marks, selectionUpdateType) {\n var _a;\n if (marks.length === 0) {\n throw new TableauError_1.TableauError(Contract.ErrorCodes.InvalidParameter, 'Marks info missing for selecting marks by Id');\n }\n var selectionType = this.validateSelectionUpdateType(selectionUpdateType);\n var selectionModelContainer = this.parseSelectionIds(marks);\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'selectMarksByIdAsync',\n _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId,\n _a[api_internal_contract_js_1.ParameterId.SelectionUpdateType] = selectionType,\n _a[api_internal_contract_js_1.ParameterId.Selection] = selectionModelContainer.selection,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.SelectByValue, parameters).then(function (response) {\n // Expecting an empty model and hence the void response.\n return;\n // TODO Investigate the error response with multiple output params and throw error accordingly.\n });\n };\n /**\n * Method to prepare the pres models for selection by MarksInfo\n * @param marks\n */\n SelectionServiceImpl.prototype.parseSelectionIds = function (marks) {\n var ids = [];\n var selectionModelContainer = new SelectionModels_1.SelectionModelsContainer();\n for (var i = 0; i < marks.length; i++) {\n var tupleId = marks[i].tupleId;\n if (tupleId !== undefined && tupleId !== null) {\n // If tuple id is provided use that instead of pair\n ids.push(tupleId.toString()); // collect the tuple ids\n }\n else {\n throw new TableauError_1.TableauError(Contract.ErrorCodes.InternalError, 'tupleId parsing error');\n }\n }\n if (ids.length !== 0) {\n // tuple ids based selection\n var tupleSelectionModel = new SelectionModels_1.TupleSelectionModel();\n tupleSelectionModel.selectionType = 'tuples';\n tupleSelectionModel.objectIds = ids;\n selectionModelContainer.selection = tupleSelectionModel;\n }\n return selectionModelContainer;\n };\n /**\n * Method to prepare the pres models for selection by values.\n *\n * Supports 3 types for selection:\n * 1) Hierarchical value based selection\n * 2) Range value based selection\n * 3) Dimension value based selection\n *\n * @param marks\n */\n SelectionServiceImpl.prototype.parseSelectionMarks = function (selectionCriterias) {\n var selectionModelContainer = new SelectionModels_1.SelectionModelsContainer();\n for (var i = 0; i < selectionCriterias.length; i++) {\n var st = selectionCriterias[i];\n if (!(st.fieldName && st.value !== undefined && st.value !== null)) {\n throw new TableauError_1.TableauError(Contract.ErrorCodes.InternalError, 'Selection Criteria parsing error');\n }\n var catRegex = new RegExp('([[A-Za-z0-9]+]).*', 'g');\n var rangeOption = st.value;\n if (catRegex.test(st.fieldName)) {\n // Hierarchical value selection\n var hierModel = this.addToParamsList(st.fieldName, st.value);\n selectionModelContainer.hierModelArr.push(hierModel);\n }\n else if (rangeOption.min !== undefined && rangeOption.max !== undefined) {\n // Range value selection\n var quantModel = this.addToRangeParamsList(st.fieldName, rangeOption);\n selectionModelContainer.quantModelArr.push(quantModel);\n }\n else {\n // Dimension value selection\n var dimModel = this.addToParamsList(st.fieldName, st.value);\n selectionModelContainer.dimModelArr.push(dimModel);\n }\n }\n return selectionModelContainer;\n };\n /**\n * Method to transform the key value pair into value based pres model object.\n *\n * @param valueSelectionModel\n * @param fieldName\n * @param value\n */\n SelectionServiceImpl.prototype.addToParamsList = function (fieldName, value) {\n var valueSelectionModel = new SelectionModels_1.ValueSelectionModel();\n var markValues = [];\n if (value instanceof Array) {\n var valueArr = value;\n for (var i = 0; i < valueArr.length; i++) {\n markValues.push(Param_1.Param.serializeParameterValue(valueArr[i]));\n }\n }\n else {\n markValues.push(Param_1.Param.serializeParameterValue(value));\n }\n valueSelectionModel.qualifiedFieldCaption = fieldName;\n valueSelectionModel.selectValues = markValues;\n return valueSelectionModel;\n };\n /**\n * Method to transform the key value pair into range based selection pres model.\n *\n * TODO: Need to handle the parsing of date type values.\n *\n * @param valueSelectionModel\n * @param fieldName\n * @param value\n */\n SelectionServiceImpl.prototype.addToRangeParamsList = function (fieldName, value) {\n var rangeSelectionModel = new SelectionModels_1.RangeSelectionModel();\n rangeSelectionModel.qualifiedFieldCaption = fieldName;\n if (value.max !== undefined && value.max !== null) {\n rangeSelectionModel.maxValue = Param_1.Param.serializeParameterValue(value.max);\n }\n if (value.min !== undefined && value.min !== null) {\n rangeSelectionModel.minValue = Param_1.Param.serializeParameterValue(value.min);\n }\n rangeSelectionModel.included = this.validateNullOptionType(value.nullOption);\n return rangeSelectionModel;\n };\n /**\n * Method to validate the selection update type.\n *\n * @param selectionUpdateType\n */\n SelectionServiceImpl.prototype.validateSelectionUpdateType = function (selectionUpdateType) {\n if (selectionUpdateType === Contract.SelectionUpdateType.Replace) {\n return api_internal_contract_js_1.SelectionUpdateType.Replace;\n }\n else if (selectionUpdateType === Contract.SelectionUpdateType.Add) {\n return api_internal_contract_js_1.SelectionUpdateType.Add;\n }\n else if (selectionUpdateType === Contract.SelectionUpdateType.Remove) {\n return api_internal_contract_js_1.SelectionUpdateType.Remove;\n }\n return api_internal_contract_js_1.SelectionUpdateType.Replace;\n };\n /**\n * Method to validate the include type for range selection.\n *\n * @param nullOption\n */\n SelectionServiceImpl.prototype.validateNullOptionType = function (nullOption) {\n if (nullOption) {\n if (nullOption === Contract.FilterNullOption.NullValues) {\n return api_internal_contract_js_1.QuantitativeIncludedValues.IncludeNull;\n }\n else if (nullOption === Contract.FilterNullOption.NonNullValues) {\n return api_internal_contract_js_1.QuantitativeIncludedValues.IncludeNonNull;\n }\n else if (nullOption === Contract.FilterNullOption.AllValues) {\n return api_internal_contract_js_1.QuantitativeIncludedValues.IncludeAll;\n }\n }\n return api_internal_contract_js_1.QuantitativeIncludedValues.IncludeAll;\n };\n SelectionServiceImpl.prototype.ensureTupleIDIsNonNegative = function (tupleId) {\n if (tupleId && tupleId > 0) {\n return tupleId;\n }\n // 0 will not refer to a valid tuple (since tuple ids are 1-based),\n // but can be used for clearing the current hover or selection\n return 0;\n };\n return SelectionServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.SelectionServiceImpl = SelectionServiceImpl;\n//# sourceMappingURL=SelectionServiceImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar InternalToExternalEnumMappings_1 = require(\"../../EnumMappings/InternalToExternalEnumMappings\");\nvar TableauError_1 = require(\"../../TableauError\");\nvar EnumConverter_1 = require(\"../../Utils/EnumConverter\");\n/**\n * Each ServceImpl should extend this base class for the sake of\n * proper error handling. This base handles the conversion\n * from internal errors to external errors that we throw to developers\n */\nvar ServiceImplBase = /** @class */ (function () {\n function ServiceImplBase(_dispatcher, _registryId) {\n this._dispatcher = _dispatcher;\n this._registryId = _registryId;\n }\n ServiceImplBase.prototype.execute = function (verb, params) {\n return this._dispatcher.execute(verb, params).catch(function (error) {\n // Any internal error that comes from the dispatcher should be converted\n // to an external error using the enum mapper for error codes.\n var internalError = error;\n var externalErrorCode = InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.errorCode.convert(internalError.errorCode, EnumConverter_1.ShouldThrow.No);\n throw new TableauError_1.TableauError(externalErrorCode, internalError.message);\n });\n };\n return ServiceImplBase;\n}());\nexports.ServiceImplBase = ServiceImplBase;\n//# sourceMappingURL=ServiceImplBase.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar SizeServiceImpl = /** @class */ (function (_super) {\n __extends(SizeServiceImpl, _super);\n function SizeServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(SizeServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"size-service\" /* Size */;\n },\n enumerable: true,\n configurable: true\n });\n SizeServiceImpl.prototype.changeSizeAsync = function (name, newSize) {\n var _a;\n var _b, _c, _d, _e;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'changeSizeAsync',\n _a[api_internal_contract_js_1.ParameterId.SheetName] = name,\n _a[api_internal_contract_js_1.ParameterId.MinHeight] = ((_b = newSize.minSize) === null || _b === void 0 ? void 0 : _b.height) || 0,\n _a[api_internal_contract_js_1.ParameterId.MinWidth] = ((_c = newSize.minSize) === null || _c === void 0 ? void 0 : _c.width) || 0,\n _a[api_internal_contract_js_1.ParameterId.MaxHeight] = ((_d = newSize.maxSize) === null || _d === void 0 ? void 0 : _d.height) || 0,\n _a[api_internal_contract_js_1.ParameterId.MaxWidth] = ((_e = newSize.maxSize) === null || _e === void 0 ? void 0 : _e.width) || 0,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.SetSheetSize, parameters).then(function (_response) {\n return;\n });\n };\n return SizeServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.SizeServiceImpl = SizeServiceImpl;\n//# sourceMappingURL=SizeServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar StoryActivationServiceImpl = /** @class */ (function (_super) {\n __extends(StoryActivationServiceImpl, _super);\n function StoryActivationServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(StoryActivationServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"story-activation-service\" /* StoryActivation */;\n },\n enumerable: true,\n configurable: true\n });\n StoryActivationServiceImpl.prototype.activateNextStoryPointAsync = function () {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.ActivateNextStoryPoint;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'activateNextStoryPointAsync',\n _a);\n return this.execute(verb, parameters).then(function (response) {\n return;\n });\n };\n StoryActivationServiceImpl.prototype.activatePreviousStoryPointAsync = function () {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.ActivatePreviousStoryPoint;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'activatePreviousStoryPointAsync',\n _a);\n return this.execute(verb, parameters).then(function (response) {\n return;\n });\n };\n StoryActivationServiceImpl.prototype.activateStoryPointAsync = function (index) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.ActivateStoryPoint;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'activateStoryPointAsync',\n _a);\n parameters[api_internal_contract_js_1.ParameterId.StoryPointIndex] = index;\n return this.execute(verb, parameters).then(function (response) {\n return;\n });\n };\n StoryActivationServiceImpl.prototype.revertStoryPointAsync = function (index) {\n var _a;\n var verb = api_internal_contract_js_1.VerbId.RevertStoryPoint;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'revertStoryPointAsync',\n _a);\n parameters[api_internal_contract_js_1.ParameterId.StoryPointIndex] = index;\n return this.execute(verb, parameters).then(function (response) {\n return response.result;\n });\n };\n return StoryActivationServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.StoryActivationServiceImpl = StoryActivationServiceImpl;\n//# sourceMappingURL=StoryActivationServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar VisualModelServiceImpl = /** @class */ (function (_super) {\n __extends(VisualModelServiceImpl, _super);\n function VisualModelServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(VisualModelServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"visual-model-service\" /* VisualModel */;\n },\n enumerable: true,\n configurable: true\n });\n VisualModelServiceImpl.prototype.getVisualSpecificationAsync = function (visualId) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getVisualSpecificationAsync',\n _a[api_internal_contract_js_1.ParameterId.WorksheetName] = visualId.worksheet,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetVisualSpecification, parameters).then(function (response) {\n var result = response.result;\n return result;\n });\n };\n return VisualModelServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.VisualModelServiceImpl = VisualModelServiceImpl;\n//# sourceMappingURL=VisualModelServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar CustomViewImpl_1 = require(\"../../Impl/CustomViewImpl\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar VizServiceImpl = /** @class */ (function (_super) {\n __extends(VizServiceImpl, _super);\n function VizServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(VizServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"viz-service\" /* Viz */;\n },\n enumerable: true,\n configurable: true\n });\n VizServiceImpl.prototype.createVizImageAsync = function (inputSpec) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'createVizImageAsync',\n _a[api_internal_contract_js_1.ParameterId.VizAPIInputJson] = JSON.stringify(inputSpec),\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.VizAPI, parameters).then(function (response) {\n var result = response.result;\n return result;\n });\n };\n VizServiceImpl.prototype.activateSheetAsync = function (name) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'activateSheetAsync',\n _a[api_internal_contract_js_1.ParameterId.SwitchToSheetName] = name,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.ActivateSheet, parameters).then(function () {\n return;\n });\n };\n VizServiceImpl.prototype.getCustomViewsAsync = function () {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getCustomViewsAsync',\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetCustomViews, parameters).then(function (response) {\n var customViews = response.result;\n return customViews.map(function (customView) {\n return new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId);\n });\n });\n };\n VizServiceImpl.prototype.showCustomViewAsync = function (customViewName) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'showCustomViewAsync',\n _a[api_internal_contract_js_1.ParameterId.CustomViewName] = customViewName || '',\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.ShowCustomView, parameters).then(function (response) {\n var _a;\n var customView = response.result;\n return ((_a = customView) === null || _a === void 0 ? void 0 : _a.luid) ? new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId) : undefined;\n });\n };\n VizServiceImpl.prototype.removeCustomViewAsync = function (customViewName) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'removeCustomViewAsync',\n _a[api_internal_contract_js_1.ParameterId.CustomViewName] = customViewName,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.RemoveCustomView, parameters).then(function (response) {\n var customView = response.result;\n return new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId);\n });\n };\n VizServiceImpl.prototype.saveCustomViewAsync = function (customViewName) {\n var _a;\n var _this = this;\n // CustomViewIsDefault is a required parameter, but our API has not been updated to allow it to be specified yet.\n // We should add a 'default' parameter to the interface.\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'saveCustomViewAsync',\n _a[api_internal_contract_js_1.ParameterId.CustomViewName] = customViewName,\n _a[api_internal_contract_js_1.ParameterId.CustomViewIsDefault] = false,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.SaveWorkbookAsCustomView, parameters).then(function (response) {\n var customView = response.result;\n return new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId);\n });\n };\n VizServiceImpl.prototype.setActiveCustomViewAsDefaultAsync = function () {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'setActiveCustomViewAsDefaultAsync',\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.SetActiveCustomViewAsDefault, parameters).then(function () {\n return;\n });\n };\n VizServiceImpl.prototype.saveAsync = function (customView) {\n var _a;\n var _this = this;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'saveAsync',\n _a[api_internal_contract_js_1.ParameterId.CustomViewLuid] = customView.luid,\n _a[api_internal_contract_js_1.ParameterId.CustomViewName] = customView.name,\n _a[api_internal_contract_js_1.ParameterId.CustomViewIsDefault] = customView.isDefault,\n _a[api_internal_contract_js_1.ParameterId.CustomViewIsPublic] = customView.shared,\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.UpdateCustomView, parameters).then(function (response) {\n var customView = response.result;\n return new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId);\n });\n };\n VizServiceImpl.prototype.getCurrentSrcAsync = function () {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getCurrentSrcAsync',\n _a);\n return this.execute(api_internal_contract_js_1.VerbId.GetCurrentSrc, parameters).then(function (response) { return response.result; });\n };\n return VizServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.VizServiceImpl = VizServiceImpl;\n//# sourceMappingURL=VizServiceImpl.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar ExternalToInternalEnumMappings_1 = require(\"../../EnumMappings/ExternalToInternalEnumMappings\");\nvar ErrorHelpers_1 = require(\"../../Utils/ErrorHelpers\");\nvar Param_1 = require(\"../../Utils/Param\");\nvar ServiceImplBase_1 = require(\"./ServiceImplBase\");\nvar ZoneServiceImpl = /** @class */ (function (_super) {\n __extends(ZoneServiceImpl, _super);\n function ZoneServiceImpl() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n Object.defineProperty(ZoneServiceImpl.prototype, \"serviceName\", {\n get: function () {\n return \"zone-service\" /* Zone */;\n },\n enumerable: true,\n configurable: true\n });\n ZoneServiceImpl.prototype.setVisibilityAsync = function (dashboard, dashboardZoneMap, zoneVisibilityMap) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'setVisibilityAsync',\n _a[api_internal_contract_js_1.ParameterId.Dashboard] = dashboard,\n _a[api_internal_contract_js_1.ParameterId.ZoneIdsVisibilityMap] = {},\n _a);\n // zoneVisibilityMap can be either an object or a Map - convert it to a Map\n var parameterAsMap = Param_1.Param.convertParameterToMap(zoneVisibilityMap, 'zoneVisibilityMap');\n parameterAsMap.forEach(function (value, key) {\n ErrorHelpers_1.ErrorHelpers.verifyZoneIsValid(dashboardZoneMap, Number.parseInt(key, 10));\n ErrorHelpers_1.ErrorHelpers.verifyEnumValue(value, api_external_contract_js_1.DashboardObjectVisibilityType, 'DashboardObjectVisibilityType');\n parameters[api_internal_contract_js_1.ParameterId.ZoneIdsVisibilityMap][key] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.setVisibilityType.convert(value);\n });\n return this.execute(api_internal_contract_js_1.VerbId.SetZoneVisibility, parameters).then(function (response) {\n return;\n });\n };\n ZoneServiceImpl.prototype.moveAndResizeAsync = function (dashboard, dashboardZoneMap, dashboardObjectPositionAndSizeUpdateArray) {\n var _a;\n var parameters = (_a = {},\n _a[api_internal_contract_js_1.ParameterId.Dashboard] = dashboard,\n _a[api_internal_contract_js_1.ParameterId.DashboardObjectPositionAndSizeUpdateList] = dashboardObjectPositionAndSizeUpdateArray,\n _a);\n dashboardObjectPositionAndSizeUpdateArray.forEach(function (dashboardObject) {\n ErrorHelpers_1.ErrorHelpers.verifyZoneIsValidAndFloating(dashboardZoneMap, dashboardObject.dashboardObjectID);\n ErrorHelpers_1.ErrorHelpers.verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate(dashboardObject);\n });\n return this.execute(api_internal_contract_js_1.VerbId.MoveAndResizeZones, parameters).then(function (response) {\n return;\n });\n };\n return ZoneServiceImpl;\n}(ServiceImplBase_1.ServiceImplBase));\nexports.ZoneServiceImpl = ZoneServiceImpl;\n//# sourceMappingURL=ZoneServiceImpl.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Implementation of a table summary.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nvar TableSummary = /** @class */ (function () {\n function TableSummary(_tableInfo) {\n this._tableInfo = _tableInfo;\n }\n Object.defineProperty(TableSummary.prototype, \"name\", {\n get: function () {\n return this._tableInfo.name;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(TableSummary.prototype, \"id\", {\n get: function () {\n return this._tableInfo.id;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(TableSummary.prototype, \"connectionId\", {\n get: function () {\n return this._tableInfo.connectionId;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(TableSummary.prototype, \"customSQL\", {\n get: function () {\n return this._tableInfo.customSQL;\n },\n enumerable: true,\n configurable: true\n });\n return TableSummary;\n}());\nexports.TableSummary = TableSummary;\n//# sourceMappingURL=TableSummary.js.map","\"use strict\";\nvar __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n return function (d, b) {\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * Custom error class that extends the default JavaScript Error object.\n * This allows us to provide a field with a specific error code\n * so that developers can more easily programmatically respond\n * to error scenarios.\n */\nvar TableauError = /** @class */ (function (_super) {\n __extends(TableauError, _super);\n function TableauError(_errorCode, message) {\n var _this = _super.call(this, _errorCode + \": \" + message) || this;\n _this._errorCode = _errorCode;\n /*tslint:disable-next-line */\n // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n // Error inheritance does not work propertly when compiling to ES5, this is a workaround to force\n // the proto chain to be built correctly. See the github link above for details.\n Object.setPrototypeOf(_this, TableauError.prototype);\n return _this;\n }\n Object.defineProperty(TableauError.prototype, \"errorCode\", {\n get: function () {\n return this._errorCode;\n },\n enumerable: true,\n configurable: true\n });\n return TableauError;\n}(Error));\nexports.TableauError = TableauError;\n//# sourceMappingURL=TableauError.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar InternalContract = require(\"@tableau/api-internal-contract-js\");\nvar GetDataModels_1 = require(\"../Models/GetDataModels\");\n/**\n * In version 2 of the interface, we should collapse value into nativeValue, and do all this work over\n * in the platform.\n */\nvar DataValueFactory = /** @class */ (function () {\n function DataValueFactory() {\n }\n DataValueFactory.MakeParameterDataValue = function (internalDataValue, dataType) {\n // Parameter values are all strings, convert from string to value\n return new GetDataModels_1.DataValue(internalDataValue.value, InternalContract.DataTypeConverter.convertStringValueToNativeValue(internalDataValue.value, dataType), internalDataValue.formattedValue);\n };\n DataValueFactory.MakeFilterDataValue = function (internalDataValue) {\n // Filters already have native type in value, just use that for nativeValue also\n return new GetDataModels_1.DataValue(internalDataValue.value, internalDataValue.value, internalDataValue.formattedValue);\n };\n DataValueFactory.MakeTableDataValue = function (internalDataValue, dataType) {\n // DataTables contain boolean | number | string | date as string | '%null%\n // convertValueToNativeValue converts dates as string to dates, and any special to null\n // (boolean, numbers, strings are passed through)\n // Because of IncludeDataValuesOption - we can have undefined values, which are different than any special\n return new GetDataModels_1.DataValue(internalDataValue.value, internalDataValue.value !== undefined\n ? InternalContract.DataTypeConverter.convertValueToNativeValue(internalDataValue.value, dataType)\n : undefined, internalDataValue.formattedValue);\n };\n return DataValueFactory;\n}());\nexports.DataValueFactory = DataValueFactory;\n//# sourceMappingURL=DataValueFactory.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n/**\n * A Promise wrapper class allowing for resolving/rejecting the Promise outside the context of its constructor.\n *\n * @export\n * @class Deferred\n * @template TResolve The type used to resolve the promise.\n * @template TReject The type used to reject the promise. Defaults to any.\n * @link https://stackoverflow.com/a/34637436\n */\nvar Deferred = /** @class */ (function () {\n /**\n * Creates an instance of Deferred.\n */\n function Deferred() {\n var _this = this;\n this._promise = new Promise(function (resolve, reject) {\n _this._resolve = resolve;\n _this._reject = reject;\n });\n }\n Object.defineProperty(Deferred.prototype, \"promise\", {\n /**\n * Gets the Promise.\n *\n * @readonly\n * @type {Promise}\n */\n get: function () {\n return this._promise;\n },\n enumerable: true,\n configurable: true\n });\n /**\n * Resolves the wrapped Promise.\n *\n * @param {(TResolve | PromiseLike)} response The argument to be resolved by the Promise.\n * @returns {*} {void}\n */\n Deferred.prototype.resolve = function (response) {\n if (!this._resolve) {\n return;\n }\n this._resolve(response);\n };\n /**\n *\n *\n * @param {TReject} [reason] The reason why the Promise rejected.\n * @returns {*} {void}\n */\n Deferred.prototype.reject = function (reason) {\n if (!this._reject) {\n return;\n }\n this._reject(reason);\n };\n return Deferred;\n}());\nexports.Deferred = Deferred;\nexports.UnregisterTimeoutInMilliseconds = 30000;\n//# sourceMappingURL=Deferred.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar TableauError_1 = require(\"../TableauError\");\n/**\n * This class converts from a source enum value to destination enum\n * value given a mapping from source to destination when constructed.\n *\n * Note: This exact same class is defined in api-core. Given its small\n * nature, it is not worth having in a separate project to share this between\n * api-core and api-shared. If more utility functionality is added that is used by api-core\n * and api-shared but has no other dependecies, a utiltity project might be merited,\n * and this class could be moved.\n */\nvar EnumConverter = /** @class */ (function () {\n function EnumConverter(_mappings, _defaultVal) {\n this._mappings = _mappings;\n this._defaultVal = _defaultVal;\n }\n EnumConverter.prototype.convert = function (enumVal, throwIfMissing) {\n if (throwIfMissing === void 0) { throwIfMissing = ShouldThrow.Yes; }\n if (this._mappings.hasOwnProperty(enumVal)) {\n return this._mappings[enumVal];\n }\n if (this._defaultVal !== undefined && throwIfMissing !== ShouldThrow.Yes) {\n return this._defaultVal;\n }\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, \"Enum Mapping not found for: \" + enumVal);\n };\n return EnumConverter;\n}());\nexports.EnumConverter = EnumConverter;\nvar ShouldThrow;\n(function (ShouldThrow) {\n ShouldThrow[\"Yes\"] = \"yes\";\n ShouldThrow[\"No\"] = \"no\";\n})(ShouldThrow = exports.ShouldThrow || (exports.ShouldThrow = {}));\n//# sourceMappingURL=EnumConverter.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar TableauError_1 = require(\"../TableauError\");\nvar Param_1 = require(\"./Param\");\n/**\n * This class is used to construct common errors throughout the external\n * projects (api-shared, extensions-api, etc.). It has some duplication with\n * the ErrorHelpers class in api-core, but is separate due to the need to throw\n * an external TableauError vs. an InternalTableauError.\n */\nvar ErrorHelpers = /** @class */ (function () {\n function ErrorHelpers() {\n }\n /**\n * Throws with code InternalError.\n *\n * @param apiName name of api that was called.\n */\n ErrorHelpers.apiNotImplemented = function (apiName) {\n return new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, apiName + \" API not yet implemented.\");\n };\n /**\n * Throws an internal error if argument is null or undefined.\n *\n * @param argumentValue value to verify\n * @param argumentName name of argument to verify\n */\n /*tslint:disable-next-line */\n ErrorHelpers.verifyInternalValue = function (argumentValue, argumentName) {\n if (argumentValue === null || argumentValue === undefined) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, argumentValue + \" is invalid value for: \" + argumentName);\n }\n };\n /**\n * Throws an InvalidParameter error if argument is null or undefined.\n *\n * @param argumentValue value to verify\n * @param argumentName name of argument to verify\n */\n /*tslint:disable-next-line */\n ErrorHelpers.verifyParameter = function (argumentValue, argumentName) {\n if (argumentValue === null || argumentValue === undefined) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, argumentValue + \" is invalid value for parameter: \" + argumentName);\n }\n };\n /**\n * Throws an InvalidParameter error if argument is not the specified type.\n * For objects, it just tests that it is an object\n *\n * @param argumentValue value to verify\n * @param expectedType expected result of typeof\n * @param argumentName name of argument to verify\n */\n /*tslint:disable-next-line */\n ErrorHelpers.verifyParameterType = function (argumentValue, expectedType, argumentName) {\n if (typeof argumentValue !== expectedType) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, argumentValue + \" has invalid type for parameter: \" + argumentName + \".\");\n }\n };\n /**\n * Throws an InvalidParameter error if argument is empty string, null or undefined.\n *\n * @param argumentValue value to verify\n * @param argumentName name of argument to verify\n */\n /*tslint:disable-next-line */\n ErrorHelpers.verifyStringParameter = function (argumentValue, argumentName) {\n if (argumentValue === null || argumentValue === undefined || argumentValue === '') {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, argumentValue + \" is invalid value for paramter: \" + argumentName);\n }\n };\n /**\n * Verifies passed value is a valid value for that enum.\n * Throws an InvalidParameter error if the enum value is not valid.\n *\n * String enums are {string : string} dictionaries which are not reverse mappable\n * This is an ugly workaround\n *\n * @param enumValue value to verify\n * @param enumType enum to verify against\n * @param enumName enum name for clear error message\n */\n /*tslint:disable-next-line */\n ErrorHelpers.verifyEnumValue = function (enumValue, enumType, enumName) {\n var isValid = false;\n Object.keys(enumType).forEach(function (enumKey) {\n if (enumType[enumKey] === enumValue.toString()) {\n isValid = true;\n }\n });\n if (!isValid) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, enumValue + \" is invalid value for enum: \" + enumName + \".\");\n }\n };\n /**\n * Verifies passed value is between [min, max) ... min <= value < max\n * Throws an InvalidParameter error if the value is not valid.\n *\n *\n * @param value value to verify\n * @param min value must be >= min\n * @param max value must be < max\n */\n /*tslint:disable-next-line */\n ErrorHelpers.verifyRange = function (value, min, max) {\n var isValid = min <= value && value < max;\n if (!isValid) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, value + \" is invalid value for range: [\" + min + \"..\" + max + \")\");\n }\n };\n /**\n * Verifies the params min and max for applying range filter.\n * Throws with error code InvalidParameter if range is invalid.\n *\n * @param min range min\n * @param max range max\n */\n /*tslint:disable-next-line */\n ErrorHelpers.verifyRangeParamType = function (min, max) {\n if (!min && !max) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, at least one of min or max is required.');\n }\n if (min && !Param_1.Param.isTypeNumber(min) && !Param_1.Param.isTypeDate(min)) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, only Date and number are allowed for parameter min.');\n }\n if (max && !Param_1.Param.isTypeNumber(max) && !Param_1.Param.isTypeDate(max)) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, only Date and number are allowed for parameter max.');\n }\n if (min && max && typeof min !== typeof max) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, parameters min and max should be of the same type.');\n }\n };\n /**\n * Verifies that the zoneId is present in the current dashboard.\n * Throws with error code InvalidParameter if either condition is false.\n *\n * @param dashboardZoneMap A map of zoneId's to the corresponding dashboard object.\n * @param zoneID ZoneId to be validated\n */\n ErrorHelpers.verifyZoneIsValid = function (dashboardZoneMap, zoneID) {\n if (dashboardZoneMap.has(zoneID)) {\n return;\n }\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, \"Unexpected invalid param value, Dashboard Object Id: \" + zoneID + \" is not present in dashboard.\");\n };\n /**\n * Verifies that the zone is present and floating in the current dashboard.\n * Throws with error code InvalidParameter if either condition is false.\n *\n * @param dashboardZoneMap A map of zoneId's to the corresponding dashboard object.\n * @param zoneID ZoneId to be validated\n */\n ErrorHelpers.verifyZoneIsValidAndFloating = function (dashboardZoneMap, zoneID) {\n if (dashboardZoneMap.has(zoneID) && dashboardZoneMap.get(zoneID).isFloating) {\n return;\n }\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, \"Unexpected invalid param value, Dashboard Object Id: \" + zoneID + \" is not present or is a fixed zone in the dashboard.\");\n };\n /**\n * Verifies that width and height are > 0 for each DashboardObjectPositionAndSizeUpdate object.\n * Throws with error code InvalidParameter if either condition is false.\n *\n * @param dashboardObjectPositionAndSizeUpdate DashboardObjectPositionAndSizeUpdate object for which width and height will be validated\n */\n ErrorHelpers.verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate = function (dashboardObjectPositionAndSizeUpdate) {\n if (dashboardObjectPositionAndSizeUpdate.width < 0 || dashboardObjectPositionAndSizeUpdate.height < 0) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, \"Unexpected invalid param value for dashboard object ID \" + dashboardObjectPositionAndSizeUpdate.dashboardObjectID + \":\" +\n \" negative widths and heights are not allowed.\");\n }\n };\n /**\n * Verifies is the given sheet name is in the list of sheets names allowed for exporting.\n * Throws with error code InvalidParameter if the condition above is false.\n *\n * @param exportableSheetNames A list of sheet names allowed for exporting\n * @param sheetName the name of the sheet selected for export\n */\n ErrorHelpers.verifySheetName = function (exportableSheetNames, sheetName) {\n if (!exportableSheetNames.includes(sheetName)) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidSelectionSheet, 'sheetName parameter must belong to a worksheet within the current view');\n }\n };\n /**\n * Verifies the ExportDataOptions object\n * Throws with error code InvalidParameter if the parameter is not of ExportDataOptions type.\n *\n * @param options The ExportDataOptions object used to configure the output CSV file for exportDataAsync.\n */\n ErrorHelpers.verifyExportDataOptions = function (options) {\n if ((!Param_1.Param.isNullOrUndefined(options.ignoreAliases) && !Param_1.Param.isTypeBool(options.ignoreAliases)) ||\n (!Param_1.Param.isNullOrUndefined(options.columnsToIncludeById) && !Array.isArray(options.columnsToIncludeById)))\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'options paramater must be of type ExportDataOptions');\n };\n /**\n * Verifies if the sheet names are included in any of the export scenarios.\n * Throws with error code InvalidParameter if the parameter is not an array.\n * Throws with error code InvalidSelectionSheet if there are array entries that dont exist or if there is mixing between sheets from the dashboard and sheet from the workbook.\n *\n * @param sheetNames List of sheet names selected for exporting.\n * @param exportScenarios an object containing the current sheet name, exportable sheets from the dashboard, and exportable sheets from the workbook.\n */\n ErrorHelpers.verifySheetNamesForPDFAndPPT = function (sheetNames, exportScenarios) {\n if (!Array.isArray(sheetNames))\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'sheetNames parameter must be an array');\n if (sheetNames.length === 0)\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'sheetNames should not be empty');\n var isIncludedInDashboard = sheetNames.every(function (sheetName) {\n return exportScenarios.exportableSheetNamesFromDashboard.includes(sheetName);\n });\n if (isIncludedInDashboard) {\n return;\n }\n var isIncludedInWorkbook = sheetNames.every(function (sheetName) {\n return exportScenarios.exportableSheetNamesFromWorkbook.includes(sheetName);\n });\n if (isIncludedInWorkbook) {\n return;\n }\n var isCurrentSheet = sheetNames.length === 1 && sheetNames[0] === exportScenarios.currentSheetName;\n if (isCurrentSheet) {\n return;\n }\n // Export requirement: all sheet names must be included in the list of exportable sheets in the dashboard or\n // all sheet names must be included in the list of exportable sheets in the workbook, or the sheet name is the current sheet\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidSelectionSheet, 'sheetNames parameter must have all its entries be exportable sheet names from the dashboard or all its entries be exportable sheet names from the workbook');\n };\n /**\n * Verifies the external ExportPDFOptions object's properties.\n * Throws with error code InvalidParameter if the parameter is not of external ExportPDFOptions type.\n *\n * @param options The external user-facing ExportPDFOptions object used to configure the output PDF file for exportPDFAsync.\n */\n ErrorHelpers.verifyExportPDFOptions = function (options) {\n try {\n this.verifyEnumValue(options.orientation, api_external_contract_js_1.PrintOrientation, 'PrintOrientation');\n this.verifyEnumValue(options.pageSize, api_external_contract_js_1.PrintPageSize, 'PrintPageSize');\n this.verifyEnumValue(options.scaling, api_external_contract_js_1.PrintScaling, 'PrintScaling');\n }\n catch (_a) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'options parameter must be of type ExportPDFOptions');\n }\n };\n return ErrorHelpers;\n}());\nexports.ErrorHelpers = ErrorHelpers;\n//# sourceMappingURL=ErrorHelpers.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar TableauError_1 = require(\"../TableauError\");\n/**\n * Helper methods for Export APIs.\n *\n * @class ExportHelpers\n */\nvar ExportHelpers = /** @class */ (function () {\n function ExportHelpers() {\n }\n /**\n * Modifies the internal ExportPDFOptions' properties based on the given PDF export configuration.\n * This method will construct the internal ExportPDFOptions identically to how the 'Export PDF' dialog constructs the ExportPdfOptionsPresModel.\n * See the handleExportClick method in @browser-clients/export-pdf-options-dialog for reference.\n *\n * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n * @param externalExportPdfOptions The external ExportPDFOptions user-facing object passed to exportPDFAsync.\n * @param sheetNames The list of sheets selected for export.\n */\n ExportHelpers.updateInternalExportPDFOptions = function (internalExportPdfOptions, externalExportPdfOptions, sheetNames) {\n internalExportPdfOptions.currentSheet = sheetNames[0];\n this.updateExportLayoutOptions(internalExportPdfOptions, externalExportPdfOptions);\n this.updateSheetOptions(internalExportPdfOptions, sheetNames);\n };\n /**\n * Helper method for updateInternalExportPDFOptions.\n * Modifies the exportLayoutOptions property of the internal ExportPDFOptions based on the external ExportPDFOptions.\n * See the getExportLayoutOptions method in @browser-clients/export-pdf-options-dialog for reference.\n *\n * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n * @param externalExportPdfOptions The external ExportPDFOptions user-facing object passed to exportPDFAsync.\n */\n ExportHelpers.updateExportLayoutOptions = function (internalExportPdfOptions, externalExportPdfOptions) {\n var exportLayoutOptions = internalExportPdfOptions.exportLayoutOptions;\n // setting the image height and width properties to their default values\n exportLayoutOptions.imageHeight = this.DefaultLayoutOptions.imageHeight;\n exportLayoutOptions.imageWidth = this.DefaultLayoutOptions.imageWidth;\n // setting the orientation value for the exportLayoutOptions\n switch (externalExportPdfOptions.orientation) {\n case api_external_contract_js_1.PrintOrientation.Landscape:\n exportLayoutOptions.pageOrientationOption = api_internal_contract_js_1.PageOrientation.Landscape;\n break;\n case api_external_contract_js_1.PrintOrientation.Portrait:\n exportLayoutOptions.pageOrientationOption = api_internal_contract_js_1.PageOrientation.Portrait;\n break;\n default:\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'invalid orientation for ExportPDFOption');\n }\n // setting the page size value for the exportLayoutOptions\n switch (externalExportPdfOptions.pageSize) {\n case api_external_contract_js_1.PrintPageSize.A3:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.A3;\n break;\n case api_external_contract_js_1.PrintPageSize.A4:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.A4;\n break;\n case api_external_contract_js_1.PrintPageSize.A5:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.A5;\n break;\n case api_external_contract_js_1.PrintPageSize.B4:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.B4;\n break;\n case api_external_contract_js_1.PrintPageSize.B5:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.B5;\n break;\n case api_external_contract_js_1.PrintPageSize.Executive:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Executive;\n break;\n case api_external_contract_js_1.PrintPageSize.Folio:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Folio;\n break;\n case api_external_contract_js_1.PrintPageSize.Ledger:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Ledger;\n break;\n case api_external_contract_js_1.PrintPageSize.Legal:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Legal;\n break;\n case api_external_contract_js_1.PrintPageSize.Letter:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Letter;\n break;\n case api_external_contract_js_1.PrintPageSize.Note:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Note;\n break;\n case api_external_contract_js_1.PrintPageSize.Quarto:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Quarto;\n break;\n case api_external_contract_js_1.PrintPageSize.Statement:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Statement;\n break;\n case api_external_contract_js_1.PrintPageSize.Tabloid:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Tabloid;\n break;\n case api_external_contract_js_1.PrintPageSize.Unspecified:\n exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Unspecified;\n break;\n default:\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'invalid pageSize for ExportPDFOption');\n }\n // setting the scaling values for the exportLayoutOptions\n switch (externalExportPdfOptions.scaling) {\n case api_external_contract_js_1.PrintScaling.AtMost1PageHigh:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.FitPages.FitOneHigh);\n break;\n case api_external_contract_js_1.PrintScaling.AtMost1PageWide:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.FitPages.FitOneWide);\n break;\n case api_external_contract_js_1.PrintScaling.AtMost2PagesHigh:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.FitPages.FitTwoHigh);\n break;\n case api_external_contract_js_1.PrintScaling.AtMost2PagesWide:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.FitPages.FitTwoWide);\n break;\n case api_external_contract_js_1.PrintScaling.Automatic:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePctAuto);\n break;\n case api_external_contract_js_1.PrintScaling.Perc100:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct100);\n break;\n case api_external_contract_js_1.PrintScaling.Perc200:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct200);\n break;\n case api_external_contract_js_1.PrintScaling.Perc25:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct25);\n break;\n case api_external_contract_js_1.PrintScaling.Perc400:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct400);\n break;\n case api_external_contract_js_1.PrintScaling.Perc50:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct50);\n break;\n case api_external_contract_js_1.PrintScaling.Perc60:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct60);\n break;\n case api_external_contract_js_1.PrintScaling.Perc75:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct75);\n break;\n case api_external_contract_js_1.PrintScaling.Perc80:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct80);\n break;\n case api_external_contract_js_1.PrintScaling.Perc90:\n this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct90);\n break;\n default:\n throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'invalid scaling for ExportPDFOption');\n }\n };\n /**\n * Helper method for updateInternalExportPDFOptions.\n * Modifies the sheetOptions property of the internal ExportPDFOptions based on the sheets selected for export.\n * See the handleExportClick method in @browser-clients/export-pdf-options-dialog for reference.\n *\n * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n * @param sheetNames The list of sheets selected for export.\n */\n ExportHelpers.updateSheetOptions = function (internalExportPdfOptions, sheetNames) {\n var exportLayoutOptions = internalExportPdfOptions.exportLayoutOptions, sheetOptions = internalExportPdfOptions.sheetOptions;\n // updating the export layouts options for each sheet and selecting sheet for export if included in list\n for (var _i = 0, sheetOptions_1 = sheetOptions; _i < sheetOptions_1.length; _i++) {\n var sheetOption = sheetOptions_1[_i];\n sheetOption.exportLayoutOptions = exportLayoutOptions;\n sheetOption.isSelected = sheetNames.includes(sheetOption.sheet);\n }\n };\n /**\n * Helper method for updateExportLayoutOptons.\n * This method is a spoof of the getFitAndScaleValues method used in @browser-clients/export-pdf-options to set the exportLayoutOptions' scaling properties.\n * In the future, this file should be refactored to import the method directly from @browser-clients/export-pdf-options.\n *\n * @param scalingSelection string used for setting the exportLayoutOptions based on the PrintScaling property from the ExternalExportPDFOptions.\n * @param exportLayoutOptions the ExportLayoutOptions used by the internal ExportPDFOptions pres model.\n */\n ExportHelpers.setFitAndScaleValues = function (exportLayoutOptions, scalingSelection) {\n var _a;\n var _b = this.DefaultLayoutOptions, pageFitHorizontal = _b.pageFitHorizontal, pageFitVertical = _b.pageFitVertical, pageScaleMode = _b.pageScaleMode, pageScalePercent = _b.pageScalePercent;\n var fitMatch = this.fitRegex.exec(scalingSelection);\n var percentMatch = this.pctRegex.exec(scalingSelection);\n if (fitMatch) {\n _a = fitMatch.slice(1).map(function (value) { return Number(value); }), pageFitHorizontal = _a[0], pageFitVertical = _a[1];\n pageScaleMode = api_internal_contract_js_1.ScaleMode.ScaleFitPages;\n }\n else if (percentMatch) {\n pageScalePercent = percentMatch.slice(1).map(function (value) { return Number(value); })[0];\n pageScaleMode = api_internal_contract_js_1.ScaleMode.ScalePercentage;\n }\n // getFitAndScaleValues returns the properties below, but instead this method will set them.\n exportLayoutOptions.pageFitHorizontal = pageFitHorizontal;\n exportLayoutOptions.pageFitVertical = pageFitVertical;\n exportLayoutOptions.pageScaleMode = pageScaleMode;\n exportLayoutOptions.pageScalePercent = pageScalePercent;\n };\n ExportHelpers.DefaultDataOptions = {\n ignoreAliases: false,\n columnsToIncludeById: [],\n };\n ExportHelpers.DefaultPDFOptions = {\n scaling: api_external_contract_js_1.PrintScaling.Automatic,\n pageSize: api_external_contract_js_1.PrintPageSize.Letter,\n orientation: api_external_contract_js_1.PrintOrientation.Portrait,\n };\n ExportHelpers.DefaultLayoutOptions = {\n imageHeight: 0,\n imageWidth: 0,\n pageFitHorizontal: 1,\n pageFitVertical: 1,\n pageOrientationOption: api_internal_contract_js_1.PageOrientation.Portrait,\n pageScaleMode: api_internal_contract_js_1.ScaleMode.ScaleAuto,\n pageScalePercent: 100,\n pageSizeOption: api_internal_contract_js_1.PageSizeOption.Letter,\n };\n ExportHelpers.fitRegex = new RegExp('fit([0-9]+)x([0-9]+)');\n ExportHelpers.pctRegex = new RegExp('pct([0-9]+)');\n return ExportHelpers;\n}());\nexports.ExportHelpers = ExportHelpers;\n//# sourceMappingURL=ExportHelpers.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar TableauError_1 = require(\"../TableauError\");\nvar ErrorHelpers_1 = require(\"./ErrorHelpers\");\nvar Param = /** @class */ (function () {\n function Param() {\n }\n /**\n * serializes the date into the format that the server expects.\n * @param date the date to serialize\n */\n Param.serializeDateForPlatform = function (date) {\n var year = date.getUTCFullYear();\n var month = date.getUTCMonth() + 1;\n var day = date.getUTCDate();\n var hh = date.getUTCHours();\n var mm = date.getUTCMinutes();\n var sec = date.getUTCSeconds();\n return year + \"-\" + month + \"-\" + day + \" \" + hh + \":\" + mm + \":\" + sec;\n };\n Param.serializeBooleanForPlatform = function (bool) {\n return bool ? 'true' : 'false';\n };\n Param.serializeNumberForPlatform = function (num) {\n return num.toString(10);\n };\n /**\n * Verifies the input is a number\n */\n /* tslint:disable-next-line:no-any */\n Param.isTypeNumber = function (input) {\n return typeof input === 'number' || input instanceof Number;\n };\n /**\n * Verifies the input is a Date\n */\n /* tslint:disable-next-line:no-any */\n Param.isTypeDate = function (input) {\n return input instanceof Date;\n };\n /* tslint:disable-next-line:no-any */\n Param.isTypeString = function (input) {\n return typeof input === 'string' || input instanceof String;\n };\n /* tslint:disable-next-line:no-any */\n Param.isTypeBool = function (input) {\n return typeof input === 'boolean' || input instanceof Boolean;\n };\n /**\n * Determines if the input is null or undefined\n */\n /* tslint:disable-next-line:no-any */\n Param.isNullOrUndefined = function (input) {\n return input === null || input === undefined;\n };\n /* tslint:disable-next-line:no-any */\n Param.serializeParameterValue = function (value) {\n if (Param.isTypeNumber(value)) {\n return Param.serializeNumberForPlatform(value);\n }\n else if (Param.isTypeDate(value)) {\n return Param.serializeDateForPlatform(value);\n }\n else if (Param.isTypeBool(value)) {\n return Param.serializeBooleanForPlatform(value);\n }\n else if (Param.isTypeString(value)) {\n return value;\n }\n else {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, \"Unexpected invalid value for: \" + value);\n }\n };\n /**\n * Verifies that the parameter is already a Map, or converts an object to a Map.\n * If the parameter is an object, we convert it to a Map using Object.entries.\n * @throws if the parameter is not an object or Map\n */\n // tslint:disable-next-line:no-any\n Param.convertParameterToMap = function (param, paramName) {\n ErrorHelpers_1.ErrorHelpers.verifyParameterType(param, 'object', paramName);\n if (Array.isArray(param)) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, \"Expecting object or Map for: \" + paramName + \".\");\n }\n return param instanceof Map ? param : new Map(Object.entries(param));\n };\n /* tslint:disable-next-line:no-any */\n Param.tryParseNumber = function (value) {\n if (Param.isNullOrUndefined(value)) {\n return { success: false };\n }\n if (Param.isTypeNumber(value)) {\n return { parsed: value, success: true };\n }\n var valueString = value.toString();\n if (valueString === 'NaN') {\n // 'NaN' parses as NaN which is indistinguishable from a failed parse.\n return { parsed: NaN, success: true };\n }\n var parsed = parseFloat(valueString);\n if (isNaN(parsed)) {\n return { success: false };\n }\n return { parsed: parsed, success: true };\n };\n return Param;\n}());\nexports.Param = Param;\n//# sourceMappingURL=Param.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\nvar TableauError_1 = require(\"../TableauError\");\nvar SheetUtils = /** @class */ (function () {\n function SheetUtils() {\n }\n // This is a direct port from SheetSize.cs - SheetSizeFactory\n SheetUtils.getSheetSizeFromSizeConstraints = function (sizeConstraint) {\n var minWidth = sizeConstraint.minWidth, minHeight = sizeConstraint.minHeight, maxWidth = sizeConstraint.maxWidth, maxHeight = sizeConstraint.maxHeight;\n if (minHeight === 0 && minWidth === 0) {\n if (maxHeight === 0 && maxWidth === 0) {\n return {\n behavior: Contract.SheetSizeBehavior.Automatic,\n };\n }\n return {\n behavior: Contract.SheetSizeBehavior.AtMost,\n maxSize: { width: maxWidth, height: maxHeight },\n };\n }\n if (maxHeight === 0 && maxWidth === 0) {\n return {\n behavior: Contract.SheetSizeBehavior.AtLeast,\n minSize: { width: minWidth, height: minHeight },\n };\n }\n if (maxHeight === minHeight && maxWidth === minWidth && minWidth > 0) {\n return {\n behavior: Contract.SheetSizeBehavior.Exactly,\n minSize: { width: minWidth, height: minHeight },\n maxSize: { width: minWidth, height: minHeight },\n };\n }\n // 'Fit Width' for a DSD layout\n var isDsdLayout = minWidth === 0 && maxWidth === 0;\n return {\n behavior: Contract.SheetSizeBehavior.Range,\n minSize: { width: minWidth, height: minHeight },\n maxSize: { width: isDsdLayout ? 2147483647 : maxWidth, height: maxHeight },\n };\n };\n SheetUtils.createAutomaticSize = function () {\n var behavior = Contract.SheetSizeBehavior.Automatic;\n var minSize = { width: 0, height: 0 };\n var maxSize = { width: 0, height: 0 };\n return { behavior: behavior, minSize: minSize, maxSize: maxSize };\n };\n SheetUtils.getPublishedSheetInfoByName = function (name, sheetInfos) {\n var sheetInfo = sheetInfos.find(function (sheet) { return sheet.name === name; });\n return sheetInfo;\n };\n SheetUtils.getSheetTypeEnum = function (internalSheetType) {\n var sheetType;\n switch (internalSheetType) {\n case api_internal_contract_js_1.SheetType.Worksheet: {\n sheetType = Contract.SheetType.Worksheet;\n break;\n }\n case api_internal_contract_js_1.SheetType.Dashboard: {\n sheetType = Contract.SheetType.Dashboard;\n break;\n }\n case api_internal_contract_js_1.SheetType.Story: {\n sheetType = Contract.SheetType.Story;\n break;\n }\n default: {\n throw new TableauError_1.TableauError(Contract.SharedErrorCodes.ServerError, 'Invalid SheetType');\n }\n }\n return sheetType;\n };\n SheetUtils.isValidSheetSize = function (sizeObject) {\n return sizeObject.behavior !== undefined;\n };\n return SheetUtils;\n}());\nexports.SheetUtils = SheetUtils;\n//# sourceMappingURL=SheetUtils.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar Contract = require(\"@tableau/api-external-contract-js\");\nvar TableauError_1 = require(\"../TableauError\");\nvar Deferred_1 = require(\"./Deferred\");\n/**\n * A Deferred wrapper class adding functionality to reject unresponsive promises after timeout\n *\n * this class handles two things:\n\n * 1. Adds timeout logic for deferred\n * 2. It blocks multiple calls from executing at the same time.\n *\n * @export\n * @class ShortLivedDeferred\n * @template TResolve The type used to resolve the promise.\n * @template TReject The type used to reject the promise. Defaults to any.\n *\n */\nvar ShortLivedDeferred = /** @class */ (function () {\n function ShortLivedDeferred(_timeoutInMilliseconds) {\n if (_timeoutInMilliseconds === void 0) { _timeoutInMilliseconds = Deferred_1.UnregisterTimeoutInMilliseconds; }\n this._timeoutInMilliseconds = _timeoutInMilliseconds;\n }\n ShortLivedDeferred.prototype.getNewPromiseOrThrowIfBusy = function () {\n var _this = this;\n if (this._deferred) {\n throw new TableauError_1.TableauError(Contract.SharedErrorCodes.ApiExecutionError, 'This api cannot be executed till previous call is resolved.');\n }\n this._deferred = new Deferred_1.Deferred();\n this._timeoutId = setTimeout(function () {\n var error = new TableauError_1.TableauError(Contract.SharedErrorCodes.Timeout, \"Api failed to complete in \" + _this._timeoutInMilliseconds / 1000 + \" seconds\");\n _this.reject(error);\n }, this._timeoutInMilliseconds);\n return this._deferred.promise;\n };\n ShortLivedDeferred.prototype.resolve = function (response) {\n if (this._deferred) {\n clearTimeout(this._timeoutId);\n this._deferred.resolve(response);\n this._deferred = undefined;\n }\n };\n ShortLivedDeferred.prototype.reject = function (error) {\n if (this._deferred) {\n clearTimeout(this._timeoutId);\n this._deferred.reject(error);\n this._deferred = undefined;\n }\n };\n return ShortLivedDeferred;\n}());\nexports.ShortLivedDeferred = ShortLivedDeferred;\n//# sourceMappingURL=ShortLivedDeferred.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nvar TableauError_1 = require(\"./TableauError\");\n/**\n * Represents the current version of the extensions, embedding\n * and extensions-api-types library\n */\nvar VersionNumber = /** @class */ (function () {\n // private constructor so everyone uses the singleton instance\n // build numbers have this form: M.m.f-pre.N\n function VersionNumber(versionString, isAlpha) {\n var partStr = versionString.split('-');\n this.build = this.getBuildNumber(partStr[1]);\n versionString = partStr[0];\n var parts = versionString.split('.').map(function (p) { return parseInt(p, 10); });\n if (parts.length !== 3) {\n throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, \"Invalid version number: \" + versionString);\n }\n this.major = parts[0];\n this.minor = parts[1];\n this.fix = parts[2];\n this.isAlpha = isAlpha;\n }\n VersionNumber.prototype.getBuildNumber = function (preReleaseString) {\n var noBuildNumber = -1;\n if (!preReleaseString) {\n return noBuildNumber;\n }\n // The preRelease string has this form: pre.N, but we don't depend on the actual string being 'pre'\n var partStr = preReleaseString.split('.');\n return partStr[1] ? parseInt(partStr[1], 10) : noBuildNumber;\n };\n Object.defineProperty(VersionNumber.prototype, \"formattedValue\", {\n get: function () {\n return this.major + \".\" + this.minor + \".\" + this.fix;\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(VersionNumber.prototype, \"fullFormattedValue\", {\n get: function () {\n return this.major + \".\" + this.minor + \".\" + this.fix + \"-pre.\" + this.build;\n },\n enumerable: true,\n configurable: true\n });\n return VersionNumber;\n}());\nexports.VersionNumber = VersionNumber;\n//# sourceMappingURL=VersionNumber.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar api_internal_contract_js_1 = require(\"@tableau/api-internal-contract-js\");\n/**\n * Implementation of the InternalApiDispatcher which supports upgrading and downgrading the input\n * internal contract to the version that this module is built against\n *\n * @class VersionedExternalApiDispatcher\n * @implements {InternalApiDispatcher}\n */\nvar VersionedExternalApiDispatcher = /** @class */ (function () {\n /**\n * Creates a new instance of the VersionedExternalApiDispatcher\n * We have multiple version converting dispatchers that work together.\n * If needed, the VersionedExternalApiDispatcher wraps either the InternalApiDispatcher (desktop)\n * or the CrossFrameDispatcher (server).\n * The Internal/CrossFrame dispatchers handle an updated platform with an older external library.\n * (The CrossFrameDispatcher sends messages across the frame, and it is handled by the PresLayerHandler.)\n * Meanwhile, the VersionedExternalApiDispatcher handles an updated external library with an older platform.\n \n * @param _apiDelegateDispatcher The delegate that does the actual work.\n * @param platformVersionNumber The version of the internal contract which the platform module is using.\n * This number will be used to figure out how to downgrade incoming commands and upgrade the results\n */\n function VersionedExternalApiDispatcher(_apiDelegateDispatcher, platformVersionNumber) {\n var _this = this;\n this._apiDelegateDispatcher = _apiDelegateDispatcher;\n this._versionConverter = api_internal_contract_js_1.CreateExternalCompatibleVersionConverter(api_internal_contract_js_1.INTERNAL_CONTRACT_VERSION, platformVersionNumber);\n this._notificationHandlers = [];\n _apiDelegateDispatcher.registerNotificationHandler(function (notification) {\n if (_this._notificationHandlers.length === 0) {\n return;\n }\n var upgradedNotification = _this._versionConverter.upgradeNotification(notification);\n _this._notificationHandlers.forEach(function (handler) {\n handler(upgradedNotification);\n });\n });\n }\n VersionedExternalApiDispatcher.needsVersionConverter = function (platformVersion) {\n // If our platform is less than external library version, then we need a converter\n return api_internal_contract_js_1.VersionLessThan(platformVersion, api_internal_contract_js_1.INTERNAL_CONTRACT_VERSION);\n };\n VersionedExternalApiDispatcher.prototype.execute = function (verb, parameters) {\n var _this = this;\n try {\n var downgradeParameters = this._versionConverter.downgradeExecuteCall(verb, parameters);\n return this._apiDelegateDispatcher.execute(downgradeParameters.verb, downgradeParameters.parameters).then(function (response) {\n var upgradeResponse = _this._versionConverter.upgradeExecuteReturn(response, verb, parameters);\n return upgradeResponse;\n });\n }\n catch (e) {\n return Promise.reject(e);\n }\n };\n VersionedExternalApiDispatcher.prototype.registerNotificationHandler = function (handler) {\n this._notificationHandlers.push(handler);\n };\n VersionedExternalApiDispatcher.prototype.unregisterNotificationHandler = function (handler) {\n this._notificationHandlers = this._notificationHandlers.filter(function (h) { return h !== handler; });\n };\n return VersionedExternalApiDispatcher;\n}());\nexports.VersionedExternalApiDispatcher = VersionedExternalApiDispatcher;\n//# sourceMappingURL=VersionedExternalApiDispatcher.js.map","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nvar getRandomValues;\nvar rnds8 = new Uint8Array(16);\nexport default function rng() {\n // lazy load so that environments that need to polyfill have a chance to do so\n if (!getRandomValues) {\n // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation. Also,\n // find the complete implementation of crypto (msCrypto) on IE11.\n getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\n\n if (!getRandomValues) {\n throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n }\n }\n\n return getRandomValues(rnds8);\n}","export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;","import REGEX from './regex.js';\n\nfunction validate(uuid) {\n return typeof uuid === 'string' && REGEX.test(uuid);\n}\n\nexport default validate;","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nvar byteToHex = [];\n\nfor (var i = 0; i < 256; ++i) {\n byteToHex.push((i + 0x100).toString(16).substr(1));\n}\n\nfunction stringify(arr) {\n var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n // Note: Be careful editing this code! It's been tuned for performance\n // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one\n // of the following:\n // - One or more input array values don't map to a hex octet (leading to\n // \"undefined\" in the uuid)\n // - Invalid input values for the RFC `version` or `variant` fields\n\n if (!validate(uuid)) {\n throw TypeError('Stringified UUID is invalid');\n }\n\n return uuid;\n}\n\nexport default stringify;","import rng from './rng.js';\nimport stringify from './stringify.js'; // **`v1()` - Generate time-based UUID**\n//\n// Inspired by https://github.com/LiosK/UUID.js\n// and http://docs.python.org/library/uuid.html\n\nvar _nodeId;\n\nvar _clockseq; // Previous uuid creation time\n\n\nvar _lastMSecs = 0;\nvar _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details\n\nfunction v1(options, buf, offset) {\n var i = buf && offset || 0;\n var b = buf || new Array(16);\n options = options || {};\n var node = options.node || _nodeId;\n var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not\n // specified. We do this lazily to minimize issues related to insufficient\n // system entropy. See #189\n\n if (node == null || clockseq == null) {\n var seedBytes = options.random || (options.rng || rng)();\n\n if (node == null) {\n // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\n node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];\n }\n\n if (clockseq == null) {\n // Per 4.2.2, randomize (14 bit) clockseq\n clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;\n }\n } // UUID timestamps are 100 nano-second units since the Gregorian epoch,\n // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so\n // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\n // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\n\n\n var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock\n // cycle to simulate higher resolution clock\n\n var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)\n\n var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression\n\n if (dt < 0 && options.clockseq === undefined) {\n clockseq = clockseq + 1 & 0x3fff;\n } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\n // time interval\n\n\n if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\n nsecs = 0;\n } // Per 4.2.1.2 Throw error if too many uuids are requested\n\n\n if (nsecs >= 10000) {\n throw new Error(\"uuid.v1(): Can't create more than 10M uuids/sec\");\n }\n\n _lastMSecs = msecs;\n _lastNSecs = nsecs;\n _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\n\n msecs += 12219292800000; // `time_low`\n\n var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\n b[i++] = tl >>> 24 & 0xff;\n b[i++] = tl >>> 16 & 0xff;\n b[i++] = tl >>> 8 & 0xff;\n b[i++] = tl & 0xff; // `time_mid`\n\n var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;\n b[i++] = tmh >>> 8 & 0xff;\n b[i++] = tmh & 0xff; // `time_high_and_version`\n\n b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\n\n b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\n\n b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`\n\n b[i++] = clockseq & 0xff; // `node`\n\n for (var n = 0; n < 6; ++n) {\n b[i + n] = node[n];\n }\n\n return buf || stringify(b);\n}\n\nexport default v1;","import validate from './validate.js';\n\nfunction parse(uuid) {\n if (!validate(uuid)) {\n throw TypeError('Invalid UUID');\n }\n\n var v;\n var arr = new Uint8Array(16); // Parse ########-....-....-....-............\n\n arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;\n arr[1] = v >>> 16 & 0xff;\n arr[2] = v >>> 8 & 0xff;\n arr[3] = v & 0xff; // Parse ........-####-....-....-............\n\n arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;\n arr[5] = v & 0xff; // Parse ........-....-####-....-............\n\n arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;\n arr[7] = v & 0xff; // Parse ........-....-....-####-............\n\n arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;\n arr[9] = v & 0xff; // Parse ........-....-....-....-############\n // (Use \"/\" to avoid 32-bit truncation when bit-shifting high-order bytes)\n\n arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;\n arr[11] = v / 0x100000000 & 0xff;\n arr[12] = v >>> 24 & 0xff;\n arr[13] = v >>> 16 & 0xff;\n arr[14] = v >>> 8 & 0xff;\n arr[15] = v & 0xff;\n return arr;\n}\n\nexport default parse;","import stringify from './stringify.js';\nimport parse from './parse.js';\n\nfunction stringToBytes(str) {\n str = unescape(encodeURIComponent(str)); // UTF8 escape\n\n var bytes = [];\n\n for (var i = 0; i < str.length; ++i) {\n bytes.push(str.charCodeAt(i));\n }\n\n return bytes;\n}\n\nexport var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';\nexport var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';\nexport default function (name, version, hashfunc) {\n function generateUUID(value, namespace, buf, offset) {\n if (typeof value === 'string') {\n value = stringToBytes(value);\n }\n\n if (typeof namespace === 'string') {\n namespace = parse(namespace);\n }\n\n if (namespace.length !== 16) {\n throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');\n } // Compute hash of namespace and value, Per 4.3\n // Future: Use spread syntax when supported on all platforms, e.g. `bytes =\n // hashfunc([...namespace, ... value])`\n\n\n var bytes = new Uint8Array(16 + value.length);\n bytes.set(namespace);\n bytes.set(value, namespace.length);\n bytes = hashfunc(bytes);\n bytes[6] = bytes[6] & 0x0f | version;\n bytes[8] = bytes[8] & 0x3f | 0x80;\n\n if (buf) {\n offset = offset || 0;\n\n for (var i = 0; i < 16; ++i) {\n buf[offset + i] = bytes[i];\n }\n\n return buf;\n }\n\n return stringify(bytes);\n } // Function#name is not settable on some platforms (#270)\n\n\n try {\n generateUUID.name = name; // eslint-disable-next-line no-empty\n } catch (err) {} // For CommonJS default export support\n\n\n generateUUID.DNS = DNS;\n generateUUID.URL = URL;\n return generateUUID;\n}","/*\n * Browser-compatible JavaScript MD5\n *\n * Modification of JavaScript MD5\n * https://github.com/blueimp/JavaScript-MD5\n *\n * Copyright 2011, Sebastian Tschan\n * https://blueimp.net\n *\n * Licensed under the MIT license:\n * https://opensource.org/licenses/MIT\n *\n * Based on\n * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message\n * Digest Algorithm, as defined in RFC 1321.\n * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for more info.\n */\nfunction md5(bytes) {\n if (typeof bytes === 'string') {\n var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\n\n bytes = new Uint8Array(msg.length);\n\n for (var i = 0; i < msg.length; ++i) {\n bytes[i] = msg.charCodeAt(i);\n }\n }\n\n return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));\n}\n/*\n * Convert an array of little-endian words to an array of bytes\n */\n\n\nfunction md5ToHexEncodedArray(input) {\n var output = [];\n var length32 = input.length * 32;\n var hexTab = '0123456789abcdef';\n\n for (var i = 0; i < length32; i += 8) {\n var x = input[i >> 5] >>> i % 32 & 0xff;\n var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);\n output.push(hex);\n }\n\n return output;\n}\n/**\n * Calculate output length with padding and bit length\n */\n\n\nfunction getOutputLength(inputLength8) {\n return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;\n}\n/*\n * Calculate the MD5 of an array of little-endian words, and a bit length.\n */\n\n\nfunction wordsToMd5(x, len) {\n /* append padding */\n x[len >> 5] |= 0x80 << len % 32;\n x[getOutputLength(len) - 1] = len;\n var a = 1732584193;\n var b = -271733879;\n var c = -1732584194;\n var d = 271733878;\n\n for (var i = 0; i < x.length; i += 16) {\n var olda = a;\n var oldb = b;\n var oldc = c;\n var oldd = d;\n a = md5ff(a, b, c, d, x[i], 7, -680876936);\n d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);\n c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);\n b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);\n a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);\n d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);\n c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);\n b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);\n a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);\n d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);\n c = md5ff(c, d, a, b, x[i + 10], 17, -42063);\n b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);\n a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);\n d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);\n c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);\n b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);\n a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);\n d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);\n c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);\n b = md5gg(b, c, d, a, x[i], 20, -373897302);\n a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);\n d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);\n c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);\n b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);\n a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);\n d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);\n c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);\n b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);\n a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);\n d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);\n c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);\n b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);\n a = md5hh(a, b, c, d, x[i + 5], 4, -378558);\n d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);\n c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);\n b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);\n a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);\n d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);\n c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);\n b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);\n a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);\n d = md5hh(d, a, b, c, x[i], 11, -358537222);\n c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);\n b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);\n a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);\n d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);\n c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);\n b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);\n a = md5ii(a, b, c, d, x[i], 6, -198630844);\n d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);\n c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);\n b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);\n a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);\n d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);\n c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);\n b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);\n a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);\n d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);\n c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);\n b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);\n a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);\n d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);\n c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);\n b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);\n a = safeAdd(a, olda);\n b = safeAdd(b, oldb);\n c = safeAdd(c, oldc);\n d = safeAdd(d, oldd);\n }\n\n return [a, b, c, d];\n}\n/*\n * Convert an array bytes to an array of little-endian words\n * Characters >255 have their high-byte silently ignored.\n */\n\n\nfunction bytesToWords(input) {\n if (input.length === 0) {\n return [];\n }\n\n var length8 = input.length * 8;\n var output = new Uint32Array(getOutputLength(length8));\n\n for (var i = 0; i < length8; i += 8) {\n output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;\n }\n\n return output;\n}\n/*\n * Add integers, wrapping at 2^32. This uses 16-bit operations internally\n * to work around bugs in some JS interpreters.\n */\n\n\nfunction safeAdd(x, y) {\n var lsw = (x & 0xffff) + (y & 0xffff);\n var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n return msw << 16 | lsw & 0xffff;\n}\n/*\n * Bitwise rotate a 32-bit number to the left.\n */\n\n\nfunction bitRotateLeft(num, cnt) {\n return num << cnt | num >>> 32 - cnt;\n}\n/*\n * These functions implement the four basic operations the algorithm uses.\n */\n\n\nfunction md5cmn(q, a, b, x, s, t) {\n return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);\n}\n\nfunction md5ff(a, b, c, d, x, s, t) {\n return md5cmn(b & c | ~b & d, a, b, x, s, t);\n}\n\nfunction md5gg(a, b, c, d, x, s, t) {\n return md5cmn(b & d | c & ~d, a, b, x, s, t);\n}\n\nfunction md5hh(a, b, c, d, x, s, t) {\n return md5cmn(b ^ c ^ d, a, b, x, s, t);\n}\n\nfunction md5ii(a, b, c, d, x, s, t) {\n return md5cmn(c ^ (b | ~d), a, b, x, s, t);\n}\n\nexport default md5;","import v35 from './v35.js';\nimport md5 from './md5.js';\nvar v3 = v35('v3', 0x30, md5);\nexport default v3;","import rng from './rng.js';\nimport stringify from './stringify.js';\n\nfunction v4(options, buf, offset) {\n options = options || {};\n var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n rnds[6] = rnds[6] & 0x0f | 0x40;\n rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n if (buf) {\n offset = offset || 0;\n\n for (var i = 0; i < 16; ++i) {\n buf[offset + i] = rnds[i];\n }\n\n return buf;\n }\n\n return stringify(rnds);\n}\n\nexport default v4;","// Adapted from Chris Veness' SHA1 code at\n// http://www.movable-type.co.uk/scripts/sha1.html\nfunction f(s, x, y, z) {\n switch (s) {\n case 0:\n return x & y ^ ~x & z;\n\n case 1:\n return x ^ y ^ z;\n\n case 2:\n return x & y ^ x & z ^ y & z;\n\n case 3:\n return x ^ y ^ z;\n }\n}\n\nfunction ROTL(x, n) {\n return x << n | x >>> 32 - n;\n}\n\nfunction sha1(bytes) {\n var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];\n var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];\n\n if (typeof bytes === 'string') {\n var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\n\n bytes = [];\n\n for (var i = 0; i < msg.length; ++i) {\n bytes.push(msg.charCodeAt(i));\n }\n } else if (!Array.isArray(bytes)) {\n // Convert Array-like to Array\n bytes = Array.prototype.slice.call(bytes);\n }\n\n bytes.push(0x80);\n var l = bytes.length / 4 + 2;\n var N = Math.ceil(l / 16);\n var M = new Array(N);\n\n for (var _i = 0; _i < N; ++_i) {\n var arr = new Uint32Array(16);\n\n for (var j = 0; j < 16; ++j) {\n arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];\n }\n\n M[_i] = arr;\n }\n\n M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);\n M[N - 1][14] = Math.floor(M[N - 1][14]);\n M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;\n\n for (var _i2 = 0; _i2 < N; ++_i2) {\n var W = new Uint32Array(80);\n\n for (var t = 0; t < 16; ++t) {\n W[t] = M[_i2][t];\n }\n\n for (var _t = 16; _t < 80; ++_t) {\n W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);\n }\n\n var a = H[0];\n var b = H[1];\n var c = H[2];\n var d = H[3];\n var e = H[4];\n\n for (var _t2 = 0; _t2 < 80; ++_t2) {\n var s = Math.floor(_t2 / 20);\n var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;\n e = d;\n d = c;\n c = ROTL(b, 30) >>> 0;\n b = a;\n a = T;\n }\n\n H[0] = H[0] + a >>> 0;\n H[1] = H[1] + b >>> 0;\n H[2] = H[2] + c >>> 0;\n H[3] = H[3] + d >>> 0;\n H[4] = H[4] + e >>> 0;\n }\n\n return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];\n}\n\nexport default sha1;","import v35 from './v35.js';\nimport sha1 from './sha1.js';\nvar v5 = v35('v5', 0x50, sha1);\nexport default v5;","export default '00000000-0000-0000-0000-000000000000';","import validate from './validate.js';\n\nfunction version(uuid) {\n if (!validate(uuid)) {\n throw TypeError('Invalid UUID');\n }\n\n return parseInt(uuid.substr(14, 1), 16);\n}\n\nexport default version;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","\"use strict\";\n/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// The following polyfills are needed for IE11\nvar api_shared_js_1 = require(\"@tableau/api-shared-js\");\nrequire(\"core-js/es/array/find\");\nrequire(\"core-js/es/array/from\");\nrequire(\"core-js/es/map\");\nrequire(\"core-js/es/number/is-integer\");\nrequire(\"core-js/es/number/is-nan\");\nrequire(\"core-js/es/number/parse-float\");\nrequire(\"core-js/es/number/parse-int\");\nrequire(\"core-js/es/object/assign\");\nrequire(\"core-js/es/object/entries\");\nrequire(\"core-js/es/object/set-prototype-of\");\nrequire(\"core-js/es/promise\");\n// Due to the way we configured webpack, we should be exporting things which will be under\n// a global variable called \"tableau\". Export everything we want to be visible under tableau\n// from this file.\nvar ExtensionsImpl_1 = require(\"./ExtensionsApi/Impl/ExtensionsImpl\");\nvar Extensions_1 = require(\"./ExtensionsApi/Namespaces/Extensions\");\nvar isAlpha = typeof VERSION_IS_ALPHA !== 'undefined' ? VERSION_IS_ALPHA : false;\napi_shared_js_1.ApiVersion.SetVersionNumber(typeof API_VERSION_NUMBER !== 'undefined' ? API_VERSION_NUMBER : '0.0.0', isAlpha);\nvar extensionImpl = new ExtensionsImpl_1.ExtensionsImpl();\nexports.extensions = new Extensions_1.Extensions(extensionImpl);\n// Export Enums\n// These show up under the tableau object. I.e. tableau.ExtensionContext.Server\nvar api_external_contract_js_1 = require(\"@tableau/api-external-contract-js\");\nexports.AnalyticsObjectType = api_external_contract_js_1.AnalyticsObjectType;\nexports.AnnotationType = api_external_contract_js_1.AnnotationType;\nexports.ClassNameKey = api_external_contract_js_1.ClassNameKey;\nexports.ColumnType = api_external_contract_js_1.ColumnType;\nexports.DashboardLayoutChange = api_external_contract_js_1.DashboardLayoutChange;\nexports.DashboardObjectType = api_external_contract_js_1.DashboardObjectType;\nexports.DashboardObjectVisibilityType = api_external_contract_js_1.DashboardObjectVisibilityType;\nexports.DataType = api_external_contract_js_1.DataType;\nexports.DateRangeType = api_external_contract_js_1.DateRangeType;\nexports.DialogStyle = api_external_contract_js_1.DialogStyle;\nexports.EncodingType = api_external_contract_js_1.EncodingType;\nexports.ErrorCodes = api_external_contract_js_1.ErrorCodes;\nexports.ExtensionContext = api_external_contract_js_1.ExtensionContext;\nexports.ExtensionMode = api_external_contract_js_1.ExtensionMode;\nexports.FieldAggregationType = api_external_contract_js_1.FieldAggregationType;\nexports.FieldRoleType = api_external_contract_js_1.FieldRoleType;\nexports.FilterDomainType = api_external_contract_js_1.FilterDomainType;\nexports.FilterNullOption = api_external_contract_js_1.FilterNullOption;\nexports.FilterType = api_external_contract_js_1.FilterType;\nexports.FilterUpdateType = api_external_contract_js_1.FilterUpdateType;\nexports.HierarchicalLevelSelectionState = api_external_contract_js_1.HierarchicalLevelSelectionState;\nexports.IncludeDataValuesOption = api_external_contract_js_1.IncludeDataValuesOption;\nexports.MarkType = api_external_contract_js_1.MarkType;\nexports.ParameterValueType = api_external_contract_js_1.ParameterValueType;\nexports.PeriodType = api_external_contract_js_1.PeriodType;\nexports.QuickTableCalcType = api_external_contract_js_1.QuickTableCalcType;\nexports.ReplaySpeedType = api_external_contract_js_1.ReplaySpeedType;\nexports.SelectOptions = api_external_contract_js_1.SelectOptions;\nexports.SelectionUpdateType = api_external_contract_js_1.SelectionUpdateType;\nexports.SheetType = api_external_contract_js_1.SheetType;\nexports.SortDirection = api_external_contract_js_1.SortDirection;\nexports.TableauEventType = api_external_contract_js_1.TableauEventType;\nexports.TrendLineModelType = api_external_contract_js_1.TrendLineModelType;\nexports.VizImageEncodingType = api_external_contract_js_1.VizImageEncodingType;\nexports.VizImagePaletteType = api_external_contract_js_1.VizImagePaletteType;\nexports.VizImageSizeSettingAlignmentType = api_external_contract_js_1.VizImageSizeSettingAlignmentType;\nexports.VizImageSizeSettingType = api_external_contract_js_1.VizImageSizeSettingType;\nexports.VizImageSortDirectionType = api_external_contract_js_1.VizImageSortDirectionType;\nexports.ZoneVisibilityType = api_external_contract_js_1.ZoneVisibilityType;\n//# sourceMappingURL=ExtensionsApi.js.map"],"names":["entryUnbind","module","exports","path","Array","from","Map","Number","isInteger","isNaN","parseFloat","parseInt","Object","assign","entries","setPrototypeOf","Promise","global","isCallable","tryToString","TypeError","argument","isConstructor","String","wellKnownSymbol","create","definePropertyModule","UNSCOPABLES","ArrayPrototype","prototype","undefined","f","configurable","value","key","isPrototypeOf","it","Prototype","isObject","bind","call","toObject","callWithSafeIterationClosing","isArrayIteratorMethod","lengthOfArrayLike","createProperty","getIterator","getIteratorMethod","arrayLike","O","IS_CONSTRUCTOR","this","argumentsLength","arguments","length","mapfn","mapping","result","step","iterator","next","iteratorMethod","index","done","toIndexedObject","toAbsoluteIndex","createMethod","IS_INCLUDES","$this","el","fromIndex","includes","indexOf","uncurryThis","IndexedObject","arraySpeciesCreate","push","TYPE","IS_MAP","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_REJECT","NO_HOLES","callbackfn","that","specificCreate","self","boundFunction","target","forEach","map","filter","some","every","find","findIndex","filterReject","slice","isArray","SPECIES","originalArray","C","constructor","arraySpeciesConstructor","anObject","iteratorClose","fn","ENTRIES","error","ITERATOR","SAFE_CLOSING","called","iteratorWithReturn","exec","SKIP_CLOSING","ITERATION_SUPPORT","object","toString","stringSlice","TO_STRING_TAG_SUPPORT","classofRaw","TO_STRING_TAG","CORRECT_ARGUMENTS","tag","tryGet","callee","arraySlice","replace","split","join","TEST","Error","stack","V8_OR_CHAKRA_STACK_ENTRY","IS_V8_OR_CHAKRA_STACK","test","IS_FIREFOX_OR_SAFARI_STACK","dropEntries","defineProperty","redefineAll","anInstance","iterate","defineIterator","setSpecies","DESCRIPTORS","fastKey","InternalStateModule","setInternalState","set","internalStateGetterFor","getterFor","getConstructor","wrapper","CONSTRUCTOR_NAME","ADDER","Constructor","iterable","type","first","last","size","AS_ENTRIES","getInternalState","define","previous","state","entry","getEntry","removed","clear","data","prev","has","get","add","setStrong","ITERATOR_NAME","getInternalCollectionState","getInternalIteratorState","iterated","kind","$","isForced","redefine","InternalMetadataModule","fails","checkCorrectnessOfIteration","setToStringTag","inheritIfRequired","common","IS_WEAK","NativeConstructor","NativePrototype","exported","fixMethod","KEY","uncurriedNativeMethod","enable","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","dummy","forced","hasOwn","ownKeys","getOwnPropertyDescriptorModule","source","keys","getOwnPropertyDescriptor","i","F","getPrototypeOf","IteratorPrototype","createPropertyDescriptor","Iterators","returnThis","IteratorConstructor","NAME","bitmap","enumerable","writable","toPropertyKey","propertyKey","IS_PURE","FunctionName","createIteratorConstructor","createNonEnumerableProperty","IteratorsCore","PROPER_FUNCTION_NAME","PROPER","CONFIGURABLE_FUNCTION_NAME","CONFIGURABLE","BUGGY_SAFARI_ITERATORS","KEYS","VALUES","Iterable","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","name","values","proto","document","EXISTS","createElement","window","userAgent","Pebble","classof","process","getBuiltIn","match","version","Deno","versions","v8","CONSTRUCTOR","METHOD","setGlobal","copyConstructorProperties","options","targetProperty","sourceProperty","descriptor","TARGET","GLOBAL","STATIC","stat","noTargetGet","sham","isExtensible","preventExtensions","FunctionPrototype","Function","apply","Reflect","aCallable","getDescriptor","callBind","namespace","method","getMethod","usingIterator","V","P","func","check","Math","globalThis","g","hasOwnProperty","a","b","console","propertyIsEnumerable","Wrapper","NewTarget","NewTargetPrototype","store","functionToString","inspectSource","cause","hiddenKeys","getOwnPropertyNamesModule","getOwnPropertyNamesExternalModule","uid","FREEZING","REQUIRED","METADATA","id","setMetadata","objectID","weakData","meta","getOwnPropertyNames","splice","getWeakData","onFreeze","NATIVE_WEAK_MAP","shared","sharedKey","OBJECT_ALREADY_INITIALIZED","WeakMap","wmget","wmhas","wmset","metadata","facade","STATE","enforce","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","replacement","feature","detection","normalize","POLYFILL","NATIVE","string","toLowerCase","floor","isFinite","USE_SYMBOL_AS_UID","$Symbol","Result","stopped","ResultPrototype","unboundFunction","iterFn","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","innerResult","innerError","PrototypeOfArrayIteratorPrototype","arrayIterator","toLength","obj","flush","head","notify","toggle","node","promise","then","macrotask","IS_IOS","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","IS_NODE","MutationObserver","WebKitMutationObserver","queueMicrotaskDescriptor","queueMicrotask","parent","domain","exit","enter","resolve","nextTick","createTextNode","observe","characterData","task","V8_VERSION","getOwnPropertySymbols","symbol","Symbol","PromiseCapability","reject","$$resolve","$$reject","$default","trim","whitespaces","charAt","n$ParseFloat","trimmedString","$parseInt","hex","radix","S","objectKeys","getOwnPropertySymbolsModule","propertyIsEnumerableModule","$assign","concat","A","B","alphabet","chr","T","j","activeXDocument","defineProperties","enumBugKeys","html","documentCreateElement","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","style","display","appendChild","src","contentWindow","open","Properties","props","IE8_DOM_DEFINE","$defineProperty","Attributes","$getOwnPropertyDescriptor","$getOwnPropertyNames","windowNames","getWindowNames","internalObjectKeys","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","names","$propertyIsEnumerable","NASHORN_BUG","aPossiblePrototype","setter","CORRECT_SETTER","__proto__","TO_ENTRIES","input","pref","val","valueOf","newPromiseCapability","x","promiseCapability","enforceInternalState","TEMPLATE","unsafe","simple","TAG","SHARED","mode","copyright","aConstructor","defaultConstructor","toIntegerOrInfinity","requireObjectCoercible","charCodeAt","CONVERT_TO_STRING","pos","second","position","codeAt","whitespace","ltrim","RegExp","rtrim","start","end","location","defer","channel","port","setImmediate","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","run","runner","listener","event","post","postMessage","protocol","host","args","now","port2","port1","onmessage","addEventListener","importScripts","removeChild","setTimeout","max","min","integer","ceil","number","isSymbol","ordinaryToPrimitive","TO_PRIMITIVE","exoticToPrim","toPrimitive","postfix","random","NATIVE_SYMBOL","WellKnownSymbolsStore","symbolFor","createWellKnownSymbol","withoutSetter","description","clearErrorStack","installErrorCause","normalizeStringArgument","ERROR_STACK_INSTALLABLE","$AggregateError","errors","message","AggregateErrorPrototype","errorsArray","AggregateError","$find","addToUnscopables","FIND","SKIPS_HOLES","ARRAY_ITERATOR","Arguments","collection","init","$entries","newPromiseCapabilityModule","perform","allSettled","capability","promiseResolve","remaining","alreadyCalled","status","reason","PROMISE_ANY_ERROR","any","alreadyResolved","alreadyRejected","NativePromise","speciesConstructor","real","onFinally","isFunction","e","Internal","OwnPromiseCapability","PromiseWrapper","nativeThen","microtask","hostReportErrors","IS_BROWSER","PROMISE","getInternalPromiseState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","NATIVE_REJECTION_EVENT","PromiseRejectionEvent","UNHANDLED_REJECTION","SUBCLASSING","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","INCORRECT_ITERATION","all","isThenable","isReject","notified","chain","reactions","ok","exited","reaction","handler","fail","rejection","onHandleUnhandled","onUnhandled","initEvent","isUnhandled","emit","unwrap","internalReject","internalResolve","executor","onFulfilled","onRejected","wrap","r","$promiseResolve","race","STRING_ITERATOR","point","validator","gen","count","out","substring","Guid","guid","EMPTY","isGuid","equals","other","isEmpty","toJSON","raw","extendStatics","__extends","d","p","__","Contract","DashboardLayoutChangedEvent","_super","_dashboardLayoutChangeDetails","_this","TableauEventType","DashboardLayoutChanged","TableauEvent","api_external_contract_js_1","api_shared_js_1","FilterChangedEvent","worksheet","_fieldName","_fieldId","FilterChanged","getFilterAsync","_worksheet","getFiltersAsync","filters","eventedFilter","fieldId","fieldName","TableauError","ErrorCodes","MissingFilter","TableauWorksheetEvent","MarksSelectedEvent","MarkSelectionChanged","getMarksAsync","getSelectedMarksAsync","Parameter_1","ServiceRegistryUtil_1","ParameterChangedEvent","_globalFieldName","sheet","ParameterChanged","getParameterAsync","ApiServiceRegistry","ExtensionsRegistryId","getService","findParameterByGlobalFieldNameAsync","parameterImpl","MissingParameter","Parameter","TableauSheetEvent","SummaryDataChangedEvent","SummaryDataChanged","_type","_sheet","WorkbookFormattingChangedEvent","_formatting","WorkbookFormattingChanged","BentonSansFontFamilyName","BentonSansLowDPIFontFamilyName","BentonSansBookFontFaceName","BentonSansBookItalicFontFaceName","BentonSansSemiDemiFontFaceName","BentonSansSemiDemiItalicFontFaceName","BentonSansLightFontFaceName","BentonSansMediumFontFaceName","SupportedBentonSansFontFaces","ConnectedServer","_userId","_siteId","_siteNamespace","_workbookId","ExtensionWorkbookImpl","getAllDataSourcesAsync","dataSchema","dataSources","ds","createDataSourceFromInfo","dataSourceInfo","dataSourceImpl","DataSourceImpl","dataSource","DataSource","initializeWithPublicInterfaces","WorkbookImpl","__spreadArrays","s","il","k","jl","api_internal_contract_js_1","Dashboard_1","Workbook_1","Worksheet_1","DashboardContent_1","Environment_1","Settings_1","UI_1","WorksheetContent_1","RegisterAllExtensionsServices_1","BentonSansFontNameConstants_1","ExtensionWorkbookImpl_1","LegacyInternalApiDispatcherHolder_1","SettingsImpl_1","TableauBookFontNameConstants_1","UIImpl_1","ExtensionsImpl","initializeAsync","isExtensionDialog","contextMenuCallbacks","_initializationPromise","_a","initOptions","isAlpha","ApiVersion","Instance","LegacyInternalApiDispatcherHolder","hasDesktopApiDispatcherPromise","getDesktopDispatcherPromise","dispatcherFactory","onDispatcherReceived","openPayload","catch","onDispatcherReceivedCallback_1","doCrossFrameBootstrap","INTERNAL_CONTRACT_VERSION","factory","createVizImageAsync","inputSpec","setClickThroughAsync","clickThroughEnabled","extensionZoneId","isDashboardExtensionLocator","locator","dashboardPath","InternalError","contextMenuFunctions","dispatcher","registerInitializationExtensionsServices","initializationService","callbackMapKeys","initializeDashboardExtensionsAsync","platformVersion","extensionEnvironment","major","minor","fix","VersionedExternalApiDispatcher","needsVersionConverter","registerAllSharedServices","registerAllExtensionsServices","extensionDashboardInfo","extensionInstance","dashboardContent","initializeDashboardContent","extensionWorksheetInfo","worksheetContent","initializeWorksheetContent","environment","Environment","settings","initializeSettings","extensionSettingsInfo","ui","UI","UIImpl","workbook","Workbook","workbookFormatting","initializeTableauFonts","applyAllFormatting","initializeContextMenuCallbacks","initializeWorkbookFormattingChangedEventCallback","extensionDialogPayload","formattingModel","_styleElement","stylesheet","cssRules","deleteRule","formattingSheets","currentFormattingSheet","applyFormattingSheetToStyleSheet","styleInfo","cssProperties","fontFamily","fontSize","fontWeight","fontStyle","textDecoration","color","rule","classNameKey","insertRule","registerHandler","NotificationId","eventFormatting","fontNames","SupportedTableauFontFaces","formattingSheet","parameters","ParameterId","FontNameListItems","execute","VerbId","GetFonts","response","loadFonts","fonts","fontNameAndInfo","fontName","loadTableauFonts","loadBentonSansFonts","FontFace","fontBinaryInfo","info","sheetPath","sheetInfoImpl","SheetInfoImpl","SheetType","Dashboard","width","w","height","h","dashboardImpl","DashboardImpl","zones","activeDashboardObjectId","dashboard","DashboardContent","visualId","Worksheet","worksheetImpl","WorksheetImpl","WorksheetContent","settingsInfo","settingsImpl","SettingsImpl","Settings","ContextMenuClick","TableauBookFontFaceName","TableauBookFontFamilyName","weight","TableauLightFontFaceName","TableauLightFontFamilyName","TableauRegularFontFaceName","TableauRegularFontFamilyName","TableauSemiBoldFontFaceName","TableauSemiboldFontFamilyName","TableauBoldFontFaceName","TableauBoldFontFamilyName","TableauMediumFontFamilyName","TableauMediumFontFaceName","__warningIssued","__platformIsOfficialRelease","__tableauDesktopDispatcher","BlockExtension","warn","TableauEvent_1","SettingsChangedEvent","_newSettings","SettingsChanged","_saveInProgress","erase","ErrorHelpers","verifyParameter","_currentSettings","verifySettingsAreUnlocked","_isModified","getAll","saveAsync","saveSettingsAsync","newSettings","verifyStringParameter","initializeEvents","notificationService","results","settingsChangedEvent","SingleEventManagerImpl","triggerEvent","settingsValues","SettingSaveInProgress","ASYNC_SAVE_IN_PROGRESS","displayDialogAsync","url","payload","uiService","unregisterFn","ExtensionDialogUpdate","isCloseEvent","closePayload","DialogClosedByUser","closeDialog","DashboardLayoutChangedEvent_1","WorkbookFormattingChangedEvent_1","DashboardObject_1","Sheet_1","_dashboardImpl","addNewEventType","worksheetsImpl","objects","dashboardObjectImpl","DashboardObject","activeDashboardName","setZoneVisibilityAsync","zoneVisibilityMap","setDashboardObjectVisibilityAsync","dashboardObjectVisibilityMap","getDashboardObjectById","dashboardObjectId","zone","dashboardLayoutChangedEvent","dashboardObjectChanges","updateZones","activeZoneId","workbookFormattingChangedEvent","moveAndResizeDashboardObjectsAsync","dashboardObjectPositionAndSizeUpdateArray","replayAnimationAsync","replaySpeed","applyFilterAsync","updateType","Sheet","_dashboardObjectImpl","isFloating","isVisible","ParameterChangedEvent_1","currentValue","dataType","allowableValues","changeValueAsync","newValue","verifyInternalValue","parameterEvent","model","EventListenerManager","_sheetImpl","sheetType","isValidSize","EmbeddingErrorCodes","ImplementationError","testSize","findParameterAsync","parameterName","getParametersAsync","parametersImpl","_workbookImpl","FilterChangedEvent_1","MarksSelectedEvent_1","SummaryDataChangedEvent_1","_worksheetImpl","parentDashboard","SharedErrorCodes","marksEvent","SelectedMarksChanged","visualIdsAreEqual","filterEvent","filterEventResponse","summaryDataEvent","summaryDataEventResponse","applyRangeFilterAsync","filterOptions","applyHierarchicalFilterAsync","applyRelativeDateFilterAsync","clearFilterAsync","getDataSourcesAsync","getHighlightedMarksAsync","getSummaryDataAsync","getSummaryDataReaderAsync","pageRowCount","getSummaryColumnsInfoAsync","getUnderlyingDataAsync","getUnderlyingTablesAsync","getUnderlyingTableDataAsync","logicalTableId","getUnderlyingTableDataReaderAsync","getVisualSpecificationAsync","clearSelectedMarksAsync","selectMarksByIDAsync","marksInfo","selectMarksByIdAsync","selectMarksByValueAsync","selections","selectionUpdateType","annotateMarkAsync","mark","annotationText","getAnnotationsAsync","removeAnnotationAsync","annotation","hoverTupleAsync","hoveredTuple","tooltip","allowHoverActions","selectTuplesAsync","selectedTuples","selectOption","getTooltipTextAsync","tupleId","leaveMarkNavigationAsync","storyboard","storyPointID","_dashboard","ConnectedServer_1","WorkbookFormattingEnvUtil_1","_apiVersion","formattedValue","_context","InternalToExternalEnumMappings","extensionContext","convert","WorkbookFormattingEnvUtil","convertToWorkbookFormatting","_language","extensionLanguage","_country","extensionCountry","_locale","extensionLocale","_mode","extensionMode","_operatingSystem","operatingSystem","_tableauVersion","tableauVersion","_uniqueUserId","uniqueUserId","userId","connectedServer","siteId","siteNamespace","workbookId","featureFlags","Extensions","extensionImpl","initializeDialogAsync","_settingsImpl","isModified","_impl","workbookFormattingModel","InitializationServiceImpl","contextMenuIds","params","ExtensionContextMenuIds","IsExtensionDialog","InitializeExtension","ServiceImplBase","SettingsServiceImpl","SettingsValues","SaveExtensionSettings","DEFAULT_DIALOG_STYLE","DialogStyle","Window","UIServiceImpl","ExtensionDialogUrl","ExtensionDialogPayload","dialogStyle","InvalidParameter","ExtensionDialogH","ExtensionDialogW","verifyEnumValue","ExtensionDialogStyle","ExternalToInternalEnumMappings","dialogStyles","DisplayDialog","ExtensionDialogResult","DialogAlreadyOpen","InvalidDomain","InvalidDomainDialog","CloseDialog","verifyParameterType","ExtensionZoneId","ClickThroughEnabled","SetClickThrough","InitializationServiceImpl_1","SettingsServiceImpl_1","UIServiceImpl_1","registerService","__export","m","Enums_1","ApiMenuType","CrosstabFileFormat","DeviceType","EmbeddingTableauEventType","FileFormats","PrintOrientation","PrintPageSize","PrintScaling","PulseLayout","SheetSizeBehavior","TableauDialogType","Toolbar","Tableau_1","ExtensionContext","ExtensionMode","VizImageEncodingType","VizImagePaletteType","VizImageSizeSettingAlignmentType","VizImageSizeSettingType","VizImageSortDirectionType","AskDataAttributes","ToolbarButtons","RevertVizSelection","PulseAttributes","VizChildElementAttributes","VizChildElements","VizAuthoringAttributes","VizAttributes","VizSharedAttributes","WebComponentChildElementAttributes","WebComponentAttributes","WebComponentChildElements","Tableau","__assign","t","n","DashboardObjectVisibilityType","HierarchicalLevelSelectionState","ReplaySpeedType","TrendLineModelType","SortDirection","SelectOptions","SelectionUpdateType","QuickTableCalcType","PeriodType","ParameterValueType","MarkType","IncludeDataValuesOption","FilterNullOption","FilterDomainType","FilterUpdateType","FilterType","FieldRoleType","FieldAggregationType","EncodingType","DateRangeType","DashboardLayoutChange","DataType","DashboardObjectType","ClassNameKey","ColumnType","AnnotationType","AnalyticsObjectType","ZoneVisibilityType","internalContractVersion","MESSAGING_VERSION","DataTypeConverter","isSpecial","valueAsString","parseBoolean","booleanString","normalizedBoolean","specialValueIndicator","parseNumber","parseDate","dateAsString","Date","getTime","parseDateTime","formattedDateString","convertValueAsStringToValue","Bool","Int","Float","DateTime","Spatial","convertValueToNativeValue","convertStringValueToNativeValue","FitPages","PageScalingOption","ScaleMode","PageOrientation","PageSizeOption","ApiShowDataTableFormat","ApiShowDataTableSentinel","QuantitativeIncludedValues","DateStepPeriod","DomainRestrictionType","EncodedDataType","AnnotateEnum","AskDataOptionNames","PulseOptionNames","VqlParameterNames","PublicParameterNames","VizOptionNames","JsApiInternalContract_1","CrossFramePreparedMessage_1","MessageTypeChecks_1","MessageTypes_1","CrossFrameMessenger","thisWindow","otherWindow","otherWindowOrigin","startListening","unregisterFunction","boundHandler_1","onMessageReceived","removeEventListener","stopListening","setInitializeMessageHandler","initializeMessageHandler","setCommandResponseMessageHandler","commandResponseMessageHandler","setCommandMessageHandler","commandMessageHandler","setNotificationMessageHandler","notificationMessageHandler","setHandshakeMessageHandler","handshakeMessageHandler","prepareInitializationMessage","apiVersion","crossFrameVersion","msgGuid","msgType","MessageType","Initialize","prepareMessage","prepareCommandMessage","verbId","Command","prepareCommandResponseMessage","commandGuid","CommandResponse","JSON","parse","stringify","prepareNotificationMessage","notificationId","Notification","prepareAckMessage","Ack","msg","CrossFramePreparedMessage","isMessage","isInitMessage","isCommandResponseMessage","isCommandMessage","isNotificationMessage","Handshake","isHandshakeMessage","setOtherWindow","setOtherWindowOrigin","origin","_message","_target","_origin","send","Notifications_1","expectedEmptyNotifications","Set","EditButtonClicked","EditInDesktopButtonClicked","WorkbookPublished","WorkbookReadyToClose","ReadyToReceiveAuthToken","isVersion","versionNumber","v","initMessage","crMessage","commandMessage","notificationMessage","IdentityVersionConverter","upgradeExecuteCall","verb","downgradeExecuteReturn","executeResponse","downgradeNotification","notification","StackingVersionConverter","_externalMajorVersion","_platformMajorVersion","_upgradeExecuteTranslations","_downgradeExecuteTranslations","_downgradeNotificationTranslations","fromData","externalVersion","upgradeExecuteTranslations","downgradeExecuteTranslations","downgradeNotificationTranslations","upgraded","_i","upgradeTranslation","downgraded","downgradeTranslation","IdentityVersionConverter_1","StackingVersionConverter_1","VersionTranslations_1","VersionEqualTo","lhs","rhs","CreateVersionConverterWithTranslators","upgrades","downgrades","notificationDowngrades","externalMajorVersion","externalMinorVersion","platformMajorVersion","neededExecuteUpgrades","GetNeededTranslations","neededExecuteDowngrades","neededNotificationDowngrades","reverse","majorMinorTranslators","neededTranslations","maximumMinorVersion","GetMaximumMinorIndex","minorVersions","reduce","VersionLessThan","ExecuteMinorUpgrades","ExecuteMinorDowngrades","DowngradeWorksheetNames","NotificationMinorDowngrades","DowngradeFlipboardZoneID","CreateVersionConverter","bootstrapInfo","sheetInfo","visualModel","flipboardZoneID","ExternalIdentityVersionConverter","downgradeExecuteCall","upgradeExecuteReturn","upgradeNotification","ExternalStackingVersionConverter","_externalVersion","_platformVersion","_downgradeExecuteCallTranslations","_upgradeExecuteReturnTranslations","_upgradeNotificationTranslations","VersionConverterFactory_1","ExternalIdentityVersionConverter_1","ExternalStackingVersionConverter_1","ExternalVersionTranslations_1","CreateExternalCompatibleVersionConverterWithTranslators","upgradeNotifications","platformMinorVersion","neededExecuteCallDowngrade","GetNeededExternalTranslations","neededExecuteReturnUpgrades","neededNotificationUpgrades","ExecuteMinorDowngradeCallExternal","DowngradeUnderlyingTableDataAsync","DowngradeLogicalTableDataAsync","ExecuteMinorUpgradeReturnExternal","UpgradeDataTableTypes","UpgradeDataTableRowsAndColumns","ExecuteMinorUpgradeNotification","CreateExternalCompatibleVersionConverter","convertDataValues","table","dataTable","row","dataValue","columnIndex","headers","validateParametersForObjectModel","LogicalTableId","SingleTableId","oldUnderlyingDataTable","isSummary","oldSelectedMarksTable","marksTable","GetUnderlyingTableData","GetUnderlyingData","GetLogicalTableData","GetDataSourceData","GetDataSummaryData","isGetSummaryDataVerb","MaxRows","maxRows","underlyingDataTable","adjustDataRowLength","isGetTableDataVerb","ColumnsToIncludeById","columnsToInclude","newHeaders","header","valueIndex","newIndex","adjustDataColumns","ApiVersion_1","CrossFrameDispatcher_1","CrossFrameDispatcher","DataSource_1","ExternalToInternalEnumMappings_1","InternalToExternalEnumMappings_1","EventListenerManager_1","Field_1","Field","CustomViewImpl_1","CustomViewImpl","DashboardImpl_1","DashboardObjectImpl_1","DashboardObjectImpl","DataSourceImpl_1","ParameterImpl_1","ParameterImpl","SheetImpl_1","SheetImpl","SheetInfoImpl_1","SingleEventManagerImpl_1","StoryImpl_1","StoryImpl","StoryPointImpl_1","StoryPointImpl","StoryPointInfoImpl_1","StoryPointInfoImpl","WorkbookImpl_1","WorksheetImpl_1","Point_1","Point","ClientInfoServiceImpl_1","ClientInfoServiceImpl","NotificationServiceImpl_1","NotificationServiceImpl","NotificationServiceImplBase_1","NotificationServiceImplBase","Registration","ServiceImplBase_1","SizeServiceImpl_1","SizeServiceImpl","StoryActivationServiceImpl_1","StoryActivationServiceImpl","TableauError_1","Deferred_1","Deferred","ErrorHelpers_1","ExportHelpers_1","ExportHelpers","SheetUtils_1","SheetUtils","VersionNumber_1","VersionNumber","VersionedExternalApiDispatcher_1","_instance","SetVersionNumber","numString","ConnectionSummary","_connectionInfo","serverURI","inIframe","opener","messenger","initializationMessage","messageGuid","_messenger","_pendingPromises","_notificationHandlers","onCommandResponse","onNotification","preparedMessage","registerNotificationHandler","unregisterNotificationHandler","pendingPromise","errorCode","IncompatibleVersionError","_dataSourceImpl","fields","extractUpdateTime","isExtract","isPublished","publishedUrl","refreshAsync","getActiveTablesAsync","getConnectionSummariesAsync","getLogicalTablesAsync","getLogicalTableDataAsync","getLogicalTableDataReaderAsync","_b","_c","_d","_e","_f","_g","_h","_j","_k","EnumConverter_1","filterDomainType","EnumConverter","Relevant","Database","nullOptions","AllValues","NonNullValues","NullValues","filterUpdateType","Add","All","Remove","Replace","setVisibilityType","Show","Hide","setReplaySpeedType","Slow","Normal","Fast","Story","showDataTableFormatType","NativeAndFormattedValues","OnlyNativeValues","NativeValuesOnly","OnlyFormattedValues","FormattedValuesOnly","periodType","Years","Quarters","Months","Weeks","Days","Hours","Minutes","Seconds","dateRangeType","Last","LastN","Next","NextN","Current","ToDate","Modal","Modeless","_l","_m","_o","_p","_q","_r","_s","_t","Desktop","Server","Authoring","Viewing","columnType","Continuous","Discrete","Unknown","fieldAggregationType","Attr","Avg","Collect","Count","Countd","Day","End","Hour","InOut","Kurtosis","Max","Mdy","Median","Min","Minute","MonthYear","None","Qtr","Quart1","Quart3","Second","Skewness","Stdev","Stdevp","Sum","TruncDay","TruncHour","TruncMinute","TruncMonth","TruncQtr","TruncSecond","TruncWeek","TruncYear","User","Var","Varp","Week","Weekday","Year","fieldRoleType","Dimension","Measure","dashboardObjectType","Extension","Blank","Image","Legend","PageFilter","ParameterControl","QuickFilter","Text","Title","WebPage","List","Range","dateStepPeriod","INITIALIZATION_ERROR","INTERNAL_ERROR","MISSING_ENUM_MAPPING","MISSING_PARAMETER","PERMISSION_DENIED","PRES_MODEL_PARSING_ERROR","UNKNOWN_VERB_ID","VERSION_NOT_CONFIGURED","APINotInitialized","VISIBILITY_ERROR","VisibilityError","filterType","Categorical","RelativeDate","Hierarchical","DashboardTitle","StoryTitle","Tooltip","WorksheetTitle","hierarchicalLevelSelectionState","AllSelected","NoneSelected","SomeSelected","UnknownSelected","annotationType","Area","Mark","markType","Bar","Circle","GanttBar","Heatmap","Line","Pie","Polygon","Shape","Square","VizExtension","_eventListenerManagers","eventType","UnsupportedEventName","eventManager","_fieldImpl","aggregation","role","isCalculatedField","isCombinedField","isGenerated","isGeospatial","isHidden","isPresentOnPublishedDatasource","ApiShared_1","customViewModel","_registryId","_luid","luid","_name","_shared","_isDefault","isDefault","_ownerName","owner","userFriendlyName","_url","ServiceRegistry_1","_sheetInfo","_zones","_sheetPath","_parentStoryPointImpl","_activeDashboardObjectId","_worksheetsImpl","_objects","sheetName","zoneMap","zoneSize","zoneType","worksheetName","worksheetUrl","vizId","_sheetInfoImpl","zonePoint","y","zoneId","setVisibilityAsync","newZones","newActiveZoneId","newActiveDashboardName","oldDashboardObjects","oldZoneMap","oldActiveZoneId","oldActiveDashboardName","newDashboardObjects","newZoneMap","zoneChanges","oldObject","oldId","newObject","addChange","IsFloatingChanged","IsVisibleChanged","NameChanged","PositionChanged","SizeChanged","Removed","Added","Selected","Deselected","DashboardChanged","change","moveAndResizeAsync","replayAsync","verifyActiveSheetOrEmbeddedInActiveStoryPoint","getDashboardFiltersAsync","applyDashboardFilterAsync","getWorksheetNamesFromZones","worksheetNames","isRootAndActiveDashboard","active","isWithinActiveStoryPoint","parentStoryPoint","NotActiveSheet","_position","_size","_isFloating","_isVisible","_id","ConnectionSummary_1","LogicalTable_1","TableSummary_1","FieldImpl_1","_dataSourceInfo","_fields","fieldModel","fieldImpl","FieldImpl","getMaxPageRowLimit","summaries","summary","tableInfos","tableInfo","TableSummary","getDataSourceDataAsync","ignoreAliases","columnsToIncludeById","includeDataValuesOption","logicalTableInfos","logicalTableInfo","LogicalTable","InternalContract","_fieldInfo","_parentDataSource","definedValue","DataValueFactory_1","Param_1","parameterInfo","setParameterInfo","_parameterInfo","DataValueFactory","MakeParameterDataValue","_allowableValues","coercedValue","Param","serializeParameterValue","changeParameterValueAsync","listValues","minValue","maxValue","stepSize","allowableValuesType","sheetSize","isActive","getSheetSize","isValidSheetSize","findParameterByNameAsync","getParametersForSheetAsync","changeSizeAsync","newSize","invalidSizeError","InvalidSize","behavior","partialSheetSize","normalizeSheetSize","isAutomatic","Automatic","minSize","maxSize","InvalidSizeBehaviorOnWorksheet","processedNewSize","processNewSize","getClientInfoAsync","publishedSheets","getSheetSizeFromSizeConstraints","sizeConstraint","parseDimensions","minSizeMaybe","maxSizeMaybe","hasMinWidth","isNullOrUndefined","hasMinHeight","hasMaxWidth","hasMaxHeight","hasValidMinSize","hasValidMaxSize","AtMost","MissingMaxSize","AtLeast","MissingMinSize","MissingMinMaxSize","Exactly","tryParseNumber","widthParsed","success","parsedWidth","parsed","heightParsed","parsedHeight","_sheetType","_sheetSize","_index","_isActive","_isHidden","isDashboard","_eventType","_handlers","beforeCount","eventGenerator","ShortLivedDeferred_1","storyModel","_publishedSheetInfos","_storyPointInfoImpls","_deferred","ShortLivedDeferred","initializeStory","storyPoints","storyPointModel","activeStoryPointIndex","storyPointInfoImpl","caption","storyPointId","updated","_activeStoryPointImpl","containedSheetInfo","updateStoryInfo","storyInfoImpl","StoryPointIdMismatch","updateStory","activeStoryPoint","activateNextStoryPointAsync","getNewPromiseOrThrowIfBusy","activatePreviousStoryPointAsync","activateStoryPointAsync","IndexOutOfRange","revertStoryPointAsync","clearPendingPromises","_storyPointInfoImpl","sheetInfos","registryId","_containedSheetImpl","createContainedSheet","parentStory","sheetImpl","publishedSheetInfo","getPublishedSheetInfoByName","containedSheetSize","createAutomaticSize","isContainedSheetHidden","containedSheetUrl","containedSheetInfoImpl","getSheetTypeEnum","dashboardZones","ServerError","_caption","_storyPointId","_active","_updated","_parentStoryImpl","isUpdated","GetDataService_1","_visualId","_parentDashboardImpl","verifyActiveSheet","nullOption","verifyRangeParamType","levels","rangeType","worksheetDataSourceInfo","worksheetDataSchemaMap","primaryId","primaryDataSource","referencedDataSourceList","secondaryId","GetDataType","Summary","ignoreSelection","Underlying","includeAllColumns","appendContextMenuAsync","targetMenu","config","removeContextMenuAsync","menuItemId","executeContextMenuAsync","renameContextMenuAsync","menuHeader","menuDescription","isInsideDashboardExtension","isRootAndActiveWorksheet","isInsideActiveDashboard","isInsideActiveStoryPoint","_logicalTable","TooltipTextRequestModel","visualIdPresModel","Filter","_worksheetName","_filterType","getFieldAsync","getAppliedWorksheetsAsync","setAppliedWorksheetsAsync","applyToWorksheets","uniqueWorksheets","CategoricalFilter","_appliedValues","_isExcludeMode","_isAllSelected","getDomainAsync","domainType","getCategoricalDomainAsync","HierarchicalDataValue","_value","_hierarchicalPath","_level","HierarchicalLevelDetail","_levelSelectionState","HierarchicalFilter","_dimensionName","_hierarchyCaption","_numberOfLevels","_levelDetails","RangeFilter","_min","_max","_includeNullValues","service","getRangeDomainAsync","RelativeDateFilter","_anchorDate","_periodType","_rangeType","_rangeN","CategoricalDomain","_values","_domainType","RangeDomain","DataTable","_data","_columns","_totalRowCount","_isTotalRowCountLimited","_isSummaryData","_marksInfo","MarkInfo","_color","_tupleId","Column","_dataType","_isReferenced","DataValue","_nativeValue","_formattedValue","__awaiter","thisArg","_arguments","generator","fulfilled","rejected","__generator","body","_","label","sent","trys","ops","op","pop","DataTableReader","_pageRowCount","_pageCount","getPageAsync","pageNumber","verifyRange","getAllPagesAsync","firstPage","rowsRequested","pagesRequested","pagesToFetch","isDataLimited","remainingData","page","fullData","totalRowCount","columns","isTotalRowCountLimited","isSummaryData","releaseAsync","SelectionModel","ValueSelectionModel","selectValues","HierarchicalSelectionModel","RangeSelectionModel","DimensionSelectionModel","TupleSelectionModel","objectIds","SelectionModelsContainer","hierModelArr","dimModelArr","quantModelArr","SelectTuplesInteractionModel","tupleIds","selectOptions","tooltipContext","HoverTupleInteractionModel","_x","_y","AccessibilityServiceImpl_1","AnimationServiceImpl_1","AnnotationServiceImpl_1","DataSourceServiceImpl_1","ExportServiceImpl_1","ExternalContextMenuServiceImpl_1","FilterServiceImpl_1","GetDataServiceImpl_1","ParametersServiceImpl_1","SelectionServiceImpl_1","VisualModelServiceImpl_1","VizServiceImpl_1","ZoneServiceImpl_1","AnimationServiceImpl","DataSourceServiceImpl","ExportServiceImpl","GetDataServiceImpl","FilterServiceImpl","ParametersServiceImpl","SelectionServiceImpl","AnnotationServiceImpl","ZoneServiceImpl","VisualModelServiceImpl","VizServiceImpl","ExternalContextMenuServiceImpl","AccessibilityServiceImpl","__tableauApiServiceRegistry","ServiceRegistryImpl","_services","serviceName","setInstance","serviceRegistry","clearRegistry","AccessibilityModels_1","tooltipTextRequest","TooltipTextRequest","GetTooltipText","VisualId","RaiseLeaveMarkNavNotification","ReplaySpeed","ReplayAnimation","SelectionModels_1","selectionModelContainer","parseMarkSelectionIds","formattedText","TargetPoint","SelectionList","selection","FormattedText","CreateAnnotation","GetAnnotations","annotationsList","annotationFilterMap","parseAnnotationSelectionIds","RemoveAnnotation","marks","ids","tupleSelectionModel","selectionType","annotations","annotationId","mapAnnotation","annotationHTML","annotationPlainText","annotateEnum","GetEmbeddingClientInfo","SENTINEL_LOGICAL_TABLE_INFO","SingleTableCaption","platformVersionObjectModelSupport","dataSourceId","DeltaTimeMs","ShouldRefreshDS","DataSourceId","RefreshDataSource","joinParameters","GetActiveTables","joinResponse","tables","UnsupportedMethodForDataSourceType","GetDataSources","GetAllDataSources","GetConnectionDescriptionSummaries","globalfieldName","GetFieldAndDataSource","FieldId","field","convertField","convertDataSource","isObjectModelSupportedByPlatform","GetLogicalTables","GetUnderlyingTables","getExportCrosstabSheetMapAsync","currentSheetType","GetExportCrosstabSheetMap","CurrentSheetType","exportCrosstabAsync","format","exportableWorksheetNames","sheetNameToIdMap","verifySheetName","SheetIdentifier","SendNotifications","CSV","ExportCrosstabCsvDownload","UseTabDelimiters","Excel","ExportCrosstabExcelDownload","CrosstabCreationError","exportDataAsync","verifyExportDataOptions","columnsAsSet","ExportDataDownload","IgnoreAliases","DataCreationError","exportPowerPointAsync","sheetNames","exportScenarios","verifySheetNamesForPDFAndPPT","ExportPowerpointDownload","ExportOriginUrl","SelectedSheetNames","PowerPointCreationError","exportPDFAsync","externalExportPdfOptions","internalExportPdfOptions","verifyExportPDFOptions","getExportPDFOptionsAsync","updateInternalExportPDFOptions","ExportPdfDownload","ExportPdfOptions","PDFCreationError","GetExportPdfOptions","AppendExternalMenuItem","WorksheetName","ExternalMenuItemDisplayName","displayName","RemoveExternalMenuItem","ExternalMenuItemId","ExecuteExternalMenuItem","RenameExternalMenu","ExternalMenuHeader","ExternalMenuDescription","FilterModels_1","ApplyCategoricalFilter","FieldName","FilterValues","IsExcludeMode","isExcludeMode","ApplyRangeFilter","serializeDateForPlatform","FilterRangeMin","FilterRangeMax","FilterRangeNullOption","apiFilterHandlerCheckForCommandError","hierarchicalLevels","FilterLevels","ClearFilter","resposne","ApplyRelativeDateFilter","rangeN","MissingRangeNForRelativeDateFilters","RangeN","anchorDate","AnchorDate","convertAnchorDate","GetFilters","convertDomainFilters","GetCategoricalDomain","DomainType","convertCategoricalDomain","GetRangeDomain","convertRangeDomain","GetDashboardFilters","DashboardCategoricalFilter","sharedFilterModel","executeGetAppliedWorksheets","worksheets","worksheetInfo","isSelected","allowedWorksheets","activeWorksheet","isEnabled","ChangeSharedFilter","SharedFilterSheets","telemetryFunctionName","GetSharedFilter","domainFilters","domainFilter","convertCategoricalFilter","convertHierarchicalFilter","convertRangeFilter","convertRelativeDateFilter","appliedValues","dv","MakeFilterDataValue","fieldCaption","isExclude","isAllSelected","hierarchicalDataValue","hierarchicalPath","level","levelDetails","levelInfo","aLevel","levelSelectionState","dimensionName","hierarchyCaption","includeNullValues","anchorDateValue","domainDv","year","getUTCFullYear","month","getUTCMonth","day","getUTCDate","hh","getUTCHours","mm","getUTCMinutes","sec","getUTCSeconds","InvalidDateParameter","serverPm","ParameterError","InvalidFieldCaption","InvalidFilterFieldName","InvalidValues","InvalidFilterFieldValue","InvalidAggFieldName","InvalidAggregationFieldName","uuid_1","GetDataModels_1","GetDataTableReaderModels_1","viewDataTableCacheId","v4","getMaxRowLimit","getViewDataTableCacheId","getLimitedMaxRows","requestedRows","rowCountLimit","getType","summaryData","functionName","requestMaxRows","IgnoreSelection","IncludeAllColumns","verifyIncludeColumnArray","ShowDataTableFormat","responseData","processResultsTable","ViewDataTableCacheId","PageRowCount","GetDataSummaryDataReader","isReferenced","GetSelectedMarks","GetHighlightedMarks","ColumnsToInclude","datasourceId","GetLogicalTableDataReader","GetUnderlyingTableDataReader","tableId","pageSize","ViewDataTableId","DataRowIndex","GetDataTableReaderPage","processResultsPage","summaryTableId","ReleaseDataTableReader","cell","MakeTableDataValue","_filterFn","_callbackFn","notificationModel","filterFn","handlers","registration","removeRegistration","hasHandlersForNotificationType","reg","SheetPath","getAllParametersAsync","inputParameters","GetParametersForSheet","ParameterFieldName","ParameterValue","ChangeParameterValue","ParameterCaption","FindParameter","ClearSelectedMarks","selectionCriterias","validateSelectionUpdateType","parseSelectionMarks","HierValSelectionModels","QuantRangeSelectionModels","DimValSelectionModels","SelectByValue","interactionModel","ensureTupleIDIsNonNegative","HoverTupleInteraction","RaiseHoverTupleNotification","SelectTuplesInteraction","RaiseSelectTuplesNotification","InvalidFields","InvalidSelectionFieldName","InvalidSelectionValue","InvalidDates","InvalidSelectionDate","parseSelectionIds","Selection","st","catRegex","rangeOption","hierModel","addToParamsList","quantModel","addToRangeParamsList","dimModel","valueSelectionModel","markValues","valueArr","qualifiedFieldCaption","rangeSelectionModel","included","validateNullOptionType","IncludeNull","IncludeNonNull","IncludeAll","_dispatcher","internalError","externalErrorCode","ShouldThrow","No","SheetName","MinHeight","MinWidth","MaxHeight","MaxWidth","SetSheetSize","_response","ActivateNextStoryPoint","ActivatePreviousStoryPoint","ActivateStoryPoint","StoryPointIndex","RevertStoryPoint","GetVisualSpecification","VizAPIInputJson","VizAPI","activateSheetAsync","SwitchToSheetName","ActivateSheet","getCustomViewsAsync","GetCustomViews","customView","showCustomViewAsync","customViewName","CustomViewName","ShowCustomView","removeCustomViewAsync","RemoveCustomView","saveCustomViewAsync","CustomViewIsDefault","SaveWorkbookAsCustomView","setActiveCustomViewAsDefaultAsync","SetActiveCustomViewAsDefault","CustomViewLuid","CustomViewIsPublic","UpdateCustomView","getCurrentSrcAsync","GetCurrentSrc","dashboardZoneMap","ZoneIdsVisibilityMap","convertParameterToMap","verifyZoneIsValid","SetZoneVisibility","DashboardObjectPositionAndSizeUpdateList","dashboardObject","verifyZoneIsValidAndFloating","dashboardObjectID","verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate","MoveAndResizeZones","_tableInfo","connectionId","customSQL","_errorCode","internalDataValue","_promise","_resolve","_reject","UnregisterTimeoutInMilliseconds","_mappings","_defaultVal","enumVal","throwIfMissing","Yes","apiNotImplemented","apiName","argumentValue","argumentName","expectedType","enumValue","enumType","enumName","isValid","enumKey","isTypeNumber","isTypeDate","zoneID","dashboardObjectPositionAndSizeUpdate","exportableSheetNames","InvalidSelectionSheet","isTypeBool","exportableSheetNamesFromDashboard","exportableSheetNamesFromWorkbook","currentSheetName","orientation","scaling","currentSheet","updateExportLayoutOptions","updateSheetOptions","exportLayoutOptions","imageHeight","DefaultLayoutOptions","imageWidth","Landscape","pageOrientationOption","Portrait","A3","pageSizeOption","A4","A5","B4","B5","Executive","Folio","Ledger","Legal","Letter","Note","Quarto","Statement","Tabloid","Unspecified","AtMost1PageHigh","setFitAndScaleValues","FitOneHigh","AtMost1PageWide","FitOneWide","AtMost2PagesHigh","FitTwoHigh","AtMost2PagesWide","FitTwoWide","ScalePctAuto","Perc100","ScalePct100","Perc200","ScalePct200","Perc25","ScalePct25","Perc400","ScalePct400","Perc50","ScalePct50","Perc60","ScalePct60","Perc75","ScalePct75","Perc80","ScalePct80","Perc90","ScalePct90","sheetOptions_1","sheetOptions","sheetOption","scalingSelection","pageFitHorizontal","pageFitVertical","pageScaleMode","pageScalePercent","fitMatch","fitRegex","percentMatch","pctRegex","ScaleFitPages","ScalePercentage","DefaultDataOptions","DefaultPDFOptions","ScaleAuto","date","serializeBooleanForPlatform","bool","serializeNumberForPlatform","num","isTypeString","Boolean","param","paramName","valueString","NaN","minWidth","minHeight","maxWidth","maxHeight","isDsdLayout","internalSheetType","sizeObject","_timeoutInMilliseconds","ApiExecutionError","_timeoutId","Timeout","clearTimeout","versionString","partStr","build","getBuildNumber","parts","preReleaseString","_apiDelegateDispatcher","platformVersionNumber","_versionConverter","upgradedNotification","downgradeParameters","getRandomValues","rnds8","Uint8Array","rng","crypto","msCrypto","uuid","byteToHex","substr","arr","offset","_nodeId","_clockseq","_lastMSecs","_lastNSecs","buf","clockseq","seedBytes","msecs","nsecs","dt","tl","tmh","hashfunc","generateUUID","str","unescape","encodeURIComponent","bytes","stringToBytes","err","DNS","URL","getOutputLength","inputLength8","safeAdd","lsw","md5cmn","q","cnt","md5ff","c","md5gg","md5hh","md5ii","v35","output","length32","hexTab","md5ToHexEncodedArray","len","olda","oldb","oldc","oldd","wordsToMd5","length8","Uint32Array","bytesToWords","rnds","z","ROTL","K","H","l","N","M","pow","_i2","W","_t2","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","definition","o","prop","toStringTag","ExtensionsImpl_1","Extensions_1","VERSION_IS_ALPHA","extensions"],"sourceRoot":""} \ No newline at end of file diff --git a/lib/tableau.extensions.1.12.0.js b/lib/tableau.extensions.1.12.0.js new file mode 100644 index 00000000..daddde15 --- /dev/null +++ b/lib/tableau.extensions.1.12.0.js @@ -0,0 +1,20139 @@ +/******/ (() => { // webpackBootstrap +/******/ var __webpack_modules__ = ({ + +/***/ "../../node_modules/core-js/es/array/find.js": +/*!***************************************************!*\ + !*** ../../node_modules/core-js/es/array/find.js ***! + \***************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.array.find */ "../../node_modules/core-js/modules/es.array.find.js"); +var entryUnbind = __webpack_require__(/*! ../../internals/entry-unbind */ "../../node_modules/core-js/internals/entry-unbind.js"); + +module.exports = entryUnbind('Array', 'find'); + + +/***/ }), + +/***/ "../../node_modules/core-js/es/array/from.js": +/*!***************************************************!*\ + !*** ../../node_modules/core-js/es/array/from.js ***! + \***************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.string.iterator */ "../../node_modules/core-js/modules/es.string.iterator.js"); +__webpack_require__(/*! ../../modules/es.array.from */ "../../node_modules/core-js/modules/es.array.from.js"); +var path = __webpack_require__(/*! ../../internals/path */ "../../node_modules/core-js/internals/path.js"); + +module.exports = path.Array.from; + + +/***/ }), + +/***/ "../../node_modules/core-js/es/map/index.js": +/*!**************************************************!*\ + !*** ../../node_modules/core-js/es/map/index.js ***! + \**************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.array.iterator */ "../../node_modules/core-js/modules/es.array.iterator.js"); +__webpack_require__(/*! ../../modules/es.map */ "../../node_modules/core-js/modules/es.map.js"); +__webpack_require__(/*! ../../modules/es.object.to-string */ "../../node_modules/core-js/modules/es.object.to-string.js"); +__webpack_require__(/*! ../../modules/es.string.iterator */ "../../node_modules/core-js/modules/es.string.iterator.js"); +var path = __webpack_require__(/*! ../../internals/path */ "../../node_modules/core-js/internals/path.js"); + +module.exports = path.Map; + + +/***/ }), + +/***/ "../../node_modules/core-js/es/number/is-integer.js": +/*!**********************************************************!*\ + !*** ../../node_modules/core-js/es/number/is-integer.js ***! + \**********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.number.is-integer */ "../../node_modules/core-js/modules/es.number.is-integer.js"); +var path = __webpack_require__(/*! ../../internals/path */ "../../node_modules/core-js/internals/path.js"); + +module.exports = path.Number.isInteger; + + +/***/ }), + +/***/ "../../node_modules/core-js/es/number/is-nan.js": +/*!******************************************************!*\ + !*** ../../node_modules/core-js/es/number/is-nan.js ***! + \******************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.number.is-nan */ "../../node_modules/core-js/modules/es.number.is-nan.js"); +var path = __webpack_require__(/*! ../../internals/path */ "../../node_modules/core-js/internals/path.js"); + +module.exports = path.Number.isNaN; + + +/***/ }), + +/***/ "../../node_modules/core-js/es/number/parse-float.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/es/number/parse-float.js ***! + \***********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.number.parse-float */ "../../node_modules/core-js/modules/es.number.parse-float.js"); +var path = __webpack_require__(/*! ../../internals/path */ "../../node_modules/core-js/internals/path.js"); + +module.exports = path.Number.parseFloat; + + +/***/ }), + +/***/ "../../node_modules/core-js/es/number/parse-int.js": +/*!*********************************************************!*\ + !*** ../../node_modules/core-js/es/number/parse-int.js ***! + \*********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.number.parse-int */ "../../node_modules/core-js/modules/es.number.parse-int.js"); +var path = __webpack_require__(/*! ../../internals/path */ "../../node_modules/core-js/internals/path.js"); + +module.exports = path.Number.parseInt; + + +/***/ }), + +/***/ "../../node_modules/core-js/es/object/assign.js": +/*!******************************************************!*\ + !*** ../../node_modules/core-js/es/object/assign.js ***! + \******************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.object.assign */ "../../node_modules/core-js/modules/es.object.assign.js"); +var path = __webpack_require__(/*! ../../internals/path */ "../../node_modules/core-js/internals/path.js"); + +module.exports = path.Object.assign; + + +/***/ }), + +/***/ "../../node_modules/core-js/es/object/entries.js": +/*!*******************************************************!*\ + !*** ../../node_modules/core-js/es/object/entries.js ***! + \*******************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.object.entries */ "../../node_modules/core-js/modules/es.object.entries.js"); +var path = __webpack_require__(/*! ../../internals/path */ "../../node_modules/core-js/internals/path.js"); + +module.exports = path.Object.entries; + + +/***/ }), + +/***/ "../../node_modules/core-js/es/object/set-prototype-of.js": +/*!****************************************************************!*\ + !*** ../../node_modules/core-js/es/object/set-prototype-of.js ***! + \****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.object.set-prototype-of */ "../../node_modules/core-js/modules/es.object.set-prototype-of.js"); +var path = __webpack_require__(/*! ../../internals/path */ "../../node_modules/core-js/internals/path.js"); + +module.exports = path.Object.setPrototypeOf; + + +/***/ }), + +/***/ "../../node_modules/core-js/es/promise/index.js": +/*!******************************************************!*\ + !*** ../../node_modules/core-js/es/promise/index.js ***! + \******************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +__webpack_require__(/*! ../../modules/es.aggregate-error */ "../../node_modules/core-js/modules/es.aggregate-error.js"); +__webpack_require__(/*! ../../modules/es.array.iterator */ "../../node_modules/core-js/modules/es.array.iterator.js"); +__webpack_require__(/*! ../../modules/es.object.to-string */ "../../node_modules/core-js/modules/es.object.to-string.js"); +__webpack_require__(/*! ../../modules/es.promise */ "../../node_modules/core-js/modules/es.promise.js"); +__webpack_require__(/*! ../../modules/es.promise.all-settled */ "../../node_modules/core-js/modules/es.promise.all-settled.js"); +__webpack_require__(/*! ../../modules/es.promise.any */ "../../node_modules/core-js/modules/es.promise.any.js"); +__webpack_require__(/*! ../../modules/es.promise.finally */ "../../node_modules/core-js/modules/es.promise.finally.js"); +__webpack_require__(/*! ../../modules/es.string.iterator */ "../../node_modules/core-js/modules/es.string.iterator.js"); +var path = __webpack_require__(/*! ../../internals/path */ "../../node_modules/core-js/internals/path.js"); + +module.exports = path.Promise; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/a-callable.js": +/*!**********************************************************!*\ + !*** ../../node_modules/core-js/internals/a-callable.js ***! + \**********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var tryToString = __webpack_require__(/*! ../internals/try-to-string */ "../../node_modules/core-js/internals/try-to-string.js"); + +var TypeError = global.TypeError; + +// `Assert: IsCallable(argument) is true` +module.exports = function (argument) { + if (isCallable(argument)) return argument; + throw TypeError(tryToString(argument) + ' is not a function'); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/a-constructor.js": +/*!*************************************************************!*\ + !*** ../../node_modules/core-js/internals/a-constructor.js ***! + \*************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isConstructor = __webpack_require__(/*! ../internals/is-constructor */ "../../node_modules/core-js/internals/is-constructor.js"); +var tryToString = __webpack_require__(/*! ../internals/try-to-string */ "../../node_modules/core-js/internals/try-to-string.js"); + +var TypeError = global.TypeError; + +// `Assert: IsConstructor(argument) is true` +module.exports = function (argument) { + if (isConstructor(argument)) return argument; + throw TypeError(tryToString(argument) + ' is not a constructor'); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/a-possible-prototype.js": +/*!********************************************************************!*\ + !*** ../../node_modules/core-js/internals/a-possible-prototype.js ***! + \********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); + +var String = global.String; +var TypeError = global.TypeError; + +module.exports = function (argument) { + if (typeof argument == 'object' || isCallable(argument)) return argument; + throw TypeError("Can't set " + String(argument) + ' as a prototype'); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/add-to-unscopables.js": +/*!******************************************************************!*\ + !*** ../../node_modules/core-js/internals/add-to-unscopables.js ***! + \******************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); +var create = __webpack_require__(/*! ../internals/object-create */ "../../node_modules/core-js/internals/object-create.js"); +var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js"); + +var UNSCOPABLES = wellKnownSymbol('unscopables'); +var ArrayPrototype = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype[UNSCOPABLES] == undefined) { + definePropertyModule.f(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create(null) + }); +} + +// add a key to Array.prototype[@@unscopables] +module.exports = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/an-instance.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/internals/an-instance.js ***! + \***********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isPrototypeOf = __webpack_require__(/*! ../internals/object-is-prototype-of */ "../../node_modules/core-js/internals/object-is-prototype-of.js"); + +var TypeError = global.TypeError; + +module.exports = function (it, Prototype) { + if (isPrototypeOf(Prototype, it)) return it; + throw TypeError('Incorrect invocation'); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/an-object.js": +/*!*********************************************************!*\ + !*** ../../node_modules/core-js/internals/an-object.js ***! + \*********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); + +var String = global.String; +var TypeError = global.TypeError; + +// `Assert: Type(argument) is Object` +module.exports = function (argument) { + if (isObject(argument)) return argument; + throw TypeError(String(argument) + ' is not an object'); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/array-from.js": +/*!**********************************************************!*\ + !*** ../../node_modules/core-js/internals/array-from.js ***! + \**********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var bind = __webpack_require__(/*! ../internals/function-bind-context */ "../../node_modules/core-js/internals/function-bind-context.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var toObject = __webpack_require__(/*! ../internals/to-object */ "../../node_modules/core-js/internals/to-object.js"); +var callWithSafeIterationClosing = __webpack_require__(/*! ../internals/call-with-safe-iteration-closing */ "../../node_modules/core-js/internals/call-with-safe-iteration-closing.js"); +var isArrayIteratorMethod = __webpack_require__(/*! ../internals/is-array-iterator-method */ "../../node_modules/core-js/internals/is-array-iterator-method.js"); +var isConstructor = __webpack_require__(/*! ../internals/is-constructor */ "../../node_modules/core-js/internals/is-constructor.js"); +var lengthOfArrayLike = __webpack_require__(/*! ../internals/length-of-array-like */ "../../node_modules/core-js/internals/length-of-array-like.js"); +var createProperty = __webpack_require__(/*! ../internals/create-property */ "../../node_modules/core-js/internals/create-property.js"); +var getIterator = __webpack_require__(/*! ../internals/get-iterator */ "../../node_modules/core-js/internals/get-iterator.js"); +var getIteratorMethod = __webpack_require__(/*! ../internals/get-iterator-method */ "../../node_modules/core-js/internals/get-iterator-method.js"); + +var Array = global.Array; + +// `Array.from` method implementation +// https://tc39.es/ecma262/#sec-array.from +module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { + var O = toObject(arrayLike); + var IS_CONSTRUCTOR = isConstructor(this); + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined); + var iteratorMethod = getIteratorMethod(O); + var index = 0; + var length, result, step, iterator, next, value; + // if the target is not iterable or it's an array with the default iterator - use a simple case + if (iteratorMethod && !(this == Array && isArrayIteratorMethod(iteratorMethod))) { + iterator = getIterator(O, iteratorMethod); + next = iterator.next; + result = IS_CONSTRUCTOR ? new this() : []; + for (;!(step = call(next, iterator)).done; index++) { + value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value; + createProperty(result, index, value); + } + } else { + length = lengthOfArrayLike(O); + result = IS_CONSTRUCTOR ? new this(length) : Array(length); + for (;length > index; index++) { + value = mapping ? mapfn(O[index], index) : O[index]; + createProperty(result, index, value); + } + } + result.length = index; + return result; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/array-includes.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/internals/array-includes.js ***! + \**************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../../node_modules/core-js/internals/to-indexed-object.js"); +var toAbsoluteIndex = __webpack_require__(/*! ../internals/to-absolute-index */ "../../node_modules/core-js/internals/to-absolute-index.js"); +var lengthOfArrayLike = __webpack_require__(/*! ../internals/length-of-array-like */ "../../node_modules/core-js/internals/length-of-array-like.js"); + +// `Array.prototype.{ indexOf, includes }` methods implementation +var createMethod = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject($this); + var length = lengthOfArrayLike(O); + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el != el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value != value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +module.exports = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod(false) +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/array-iteration.js": +/*!***************************************************************!*\ + !*** ../../node_modules/core-js/internals/array-iteration.js ***! + \***************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var bind = __webpack_require__(/*! ../internals/function-bind-context */ "../../node_modules/core-js/internals/function-bind-context.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var IndexedObject = __webpack_require__(/*! ../internals/indexed-object */ "../../node_modules/core-js/internals/indexed-object.js"); +var toObject = __webpack_require__(/*! ../internals/to-object */ "../../node_modules/core-js/internals/to-object.js"); +var lengthOfArrayLike = __webpack_require__(/*! ../internals/length-of-array-like */ "../../node_modules/core-js/internals/length-of-array-like.js"); +var arraySpeciesCreate = __webpack_require__(/*! ../internals/array-species-create */ "../../node_modules/core-js/internals/array-species-create.js"); + +var push = uncurryThis([].push); + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation +var createMethod = function (TYPE) { + var IS_MAP = TYPE == 1; + var IS_FILTER = TYPE == 2; + var IS_SOME = TYPE == 3; + var IS_EVERY = TYPE == 4; + var IS_FIND_INDEX = TYPE == 6; + var IS_FILTER_REJECT = TYPE == 7; + var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject($this); + var self = IndexedObject(O); + var boundFunction = bind(callbackfn, that); + var length = lengthOfArrayLike(self); + var index = 0; + var create = specificCreate || arraySpeciesCreate; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push(target, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +module.exports = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod(7) +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/array-slice.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/internals/array-slice.js ***! + \***********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); + +module.exports = uncurryThis([].slice); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/array-species-constructor.js": +/*!*************************************************************************!*\ + !*** ../../node_modules/core-js/internals/array-species-constructor.js ***! + \*************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isArray = __webpack_require__(/*! ../internals/is-array */ "../../node_modules/core-js/internals/is-array.js"); +var isConstructor = __webpack_require__(/*! ../internals/is-constructor */ "../../node_modules/core-js/internals/is-constructor.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); + +var SPECIES = wellKnownSymbol('species'); +var Array = global.Array; + +// a part of `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +module.exports = function (originalArray) { + var C; + if (isArray(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor(C) && (C === Array || isArray(C.prototype))) C = undefined; + else if (isObject(C)) { + C = C[SPECIES]; + if (C === null) C = undefined; + } + } return C === undefined ? Array : C; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/array-species-create.js": +/*!********************************************************************!*\ + !*** ../../node_modules/core-js/internals/array-species-create.js ***! + \********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var arraySpeciesConstructor = __webpack_require__(/*! ../internals/array-species-constructor */ "../../node_modules/core-js/internals/array-species-constructor.js"); + +// `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +module.exports = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/call-with-safe-iteration-closing.js": +/*!********************************************************************************!*\ + !*** ../../node_modules/core-js/internals/call-with-safe-iteration-closing.js ***! + \********************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); +var iteratorClose = __webpack_require__(/*! ../internals/iterator-close */ "../../node_modules/core-js/internals/iterator-close.js"); + +// call something on iterator step with safe closing on error +module.exports = function (iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/check-correctness-of-iteration.js": +/*!******************************************************************************!*\ + !*** ../../node_modules/core-js/internals/check-correctness-of-iteration.js ***! + \******************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); + +var ITERATOR = wellKnownSymbol('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +module.exports = function (exec, SKIP_CLOSING) { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/classof-raw.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/internals/classof-raw.js ***! + \***********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); + +var toString = uncurryThis({}.toString); +var stringSlice = uncurryThis(''.slice); + +module.exports = function (it) { + return stringSlice(toString(it), 8, -1); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/classof.js": +/*!*******************************************************!*\ + !*** ../../node_modules/core-js/internals/classof.js ***! + \*******************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var TO_STRING_TAG_SUPPORT = __webpack_require__(/*! ../internals/to-string-tag-support */ "../../node_modules/core-js/internals/to-string-tag-support.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var classofRaw = __webpack_require__(/*! ../internals/classof-raw */ "../../node_modules/core-js/internals/classof-raw.js"); +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var Object = global.Object; + +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw(O) + // ES3 arguments fallback + : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/clear-error-stack.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/clear-error-stack.js ***! + \*****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var arraySlice = __webpack_require__(/*! ../internals/array-slice */ "../../node_modules/core-js/internals/array-slice.js"); + +var replace = uncurryThis(''.replace); +var split = uncurryThis(''.split); +var join = uncurryThis([].join); + +var TEST = (function (arg) { return String(Error(arg).stack); })('zxcasd'); +var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/; +var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST); +var IS_FIREFOX_OR_SAFARI_STACK = /@[^\n]*\n/.test(TEST) && !/zxcasd/.test(TEST); + +module.exports = function (stack, dropEntries) { + if (typeof stack != 'string') return stack; + if (IS_V8_OR_CHAKRA_STACK) { + while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, ''); + } else if (IS_FIREFOX_OR_SAFARI_STACK) { + return join(arraySlice(split(stack, '\n'), dropEntries), '\n'); + } return stack; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/collection-strong.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/collection-strong.js ***! + \*****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var defineProperty = (__webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js").f); +var create = __webpack_require__(/*! ../internals/object-create */ "../../node_modules/core-js/internals/object-create.js"); +var redefineAll = __webpack_require__(/*! ../internals/redefine-all */ "../../node_modules/core-js/internals/redefine-all.js"); +var bind = __webpack_require__(/*! ../internals/function-bind-context */ "../../node_modules/core-js/internals/function-bind-context.js"); +var anInstance = __webpack_require__(/*! ../internals/an-instance */ "../../node_modules/core-js/internals/an-instance.js"); +var iterate = __webpack_require__(/*! ../internals/iterate */ "../../node_modules/core-js/internals/iterate.js"); +var defineIterator = __webpack_require__(/*! ../internals/define-iterator */ "../../node_modules/core-js/internals/define-iterator.js"); +var setSpecies = __webpack_require__(/*! ../internals/set-species */ "../../node_modules/core-js/internals/set-species.js"); +var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); +var fastKey = (__webpack_require__(/*! ../internals/internal-metadata */ "../../node_modules/core-js/internals/internal-metadata.js").fastKey); +var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "../../node_modules/core-js/internals/internal-state.js"); + +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; + +module.exports = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + index: create(null), + first: undefined, + last: undefined, + size: 0 + }); + if (!DESCRIPTORS) that.size = 0; + if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + // change existing entry + if (entry) { + entry.value = value; + // create new entry + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: undefined, + removed: false + }; + if (!state.first) state.first = entry; + if (previous) previous.next = entry; + if (DESCRIPTORS) state.size++; + else that.size++; + // add to index + if (index !== 'F') state.index[index] = entry; + } return that; + }; + + var getEntry = function (that, key) { + var state = getInternalState(that); + // fast case + var index = fastKey(key); + var entry; + if (index !== 'F') return state.index[index]; + // frozen object case + for (entry = state.first; entry; entry = entry.next) { + if (entry.key == key) return entry; + } + }; + + redefineAll(Prototype, { + // `{ Map, Set }.prototype.clear()` methods + // https://tc39.es/ecma262/#sec-map.prototype.clear + // https://tc39.es/ecma262/#sec-set.prototype.clear + clear: function clear() { + var that = this; + var state = getInternalState(that); + var data = state.index; + var entry = state.first; + while (entry) { + entry.removed = true; + if (entry.previous) entry.previous = entry.previous.next = undefined; + delete data[entry.index]; + entry = entry.next; + } + state.first = state.last = undefined; + if (DESCRIPTORS) state.size = 0; + else that.size = 0; + }, + // `{ Map, Set }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.delete + // https://tc39.es/ecma262/#sec-set.prototype.delete + 'delete': function (key) { + var that = this; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) prev.next = next; + if (next) next.previous = prev; + if (state.first == entry) state.first = next; + if (state.last == entry) state.last = prev; + if (DESCRIPTORS) state.size--; + else that.size--; + } return !!entry; + }, + // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods + // https://tc39.es/ecma262/#sec-map.prototype.foreach + // https://tc39.es/ecma262/#sec-set.prototype.foreach + forEach: function forEach(callbackfn /* , that = undefined */) { + var state = getInternalState(this); + var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var entry; + while (entry = entry ? entry.next : state.first) { + boundFunction(entry.value, entry.key, this); + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + } + }, + // `{ Map, Set}.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.has + // https://tc39.es/ecma262/#sec-set.prototype.has + has: function has(key) { + return !!getEntry(this, key); + } + }); + + redefineAll(Prototype, IS_MAP ? { + // `Map.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-map.prototype.get + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + // `Map.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-map.prototype.set + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + // `Set.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-set.prototype.add + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (DESCRIPTORS) defineProperty(Prototype, 'size', { + get: function () { + return getInternalState(this).size; + } + }); + return Constructor; + }, + setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods + // https://tc39.es/ecma262/#sec-map.prototype.entries + // https://tc39.es/ecma262/#sec-map.prototype.keys + // https://tc39.es/ecma262/#sec-map.prototype.values + // https://tc39.es/ecma262/#sec-map.prototype-@@iterator + // https://tc39.es/ecma262/#sec-set.prototype.entries + // https://tc39.es/ecma262/#sec-set.prototype.keys + // https://tc39.es/ecma262/#sec-set.prototype.values + // https://tc39.es/ecma262/#sec-set.prototype-@@iterator + defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: undefined + }); + }, function () { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + // get next entry + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + // or finish the iteration + state.target = undefined; + return { value: undefined, done: true }; + } + // return step by kind + if (kind == 'keys') return { value: entry.key, done: false }; + if (kind == 'values') return { value: entry.value, done: false }; + return { value: [entry.key, entry.value], done: false }; + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + + // `{ Map, Set }.prototype[@@species]` accessors + // https://tc39.es/ecma262/#sec-get-map-@@species + // https://tc39.es/ecma262/#sec-get-set-@@species + setSpecies(CONSTRUCTOR_NAME); + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/collection.js": +/*!**********************************************************!*\ + !*** ../../node_modules/core-js/internals/collection.js ***! + \**********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var isForced = __webpack_require__(/*! ../internals/is-forced */ "../../node_modules/core-js/internals/is-forced.js"); +var redefine = __webpack_require__(/*! ../internals/redefine */ "../../node_modules/core-js/internals/redefine.js"); +var InternalMetadataModule = __webpack_require__(/*! ../internals/internal-metadata */ "../../node_modules/core-js/internals/internal-metadata.js"); +var iterate = __webpack_require__(/*! ../internals/iterate */ "../../node_modules/core-js/internals/iterate.js"); +var anInstance = __webpack_require__(/*! ../internals/an-instance */ "../../node_modules/core-js/internals/an-instance.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var checkCorrectnessOfIteration = __webpack_require__(/*! ../internals/check-correctness-of-iteration */ "../../node_modules/core-js/internals/check-correctness-of-iteration.js"); +var setToStringTag = __webpack_require__(/*! ../internals/set-to-string-tag */ "../../node_modules/core-js/internals/set-to-string-tag.js"); +var inheritIfRequired = __webpack_require__(/*! ../internals/inherit-if-required */ "../../node_modules/core-js/internals/inherit-if-required.js"); + +module.exports = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]); + redefine(NativePrototype, KEY, + KEY == 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY == 'delete' ? function (key) { + return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY == 'get' ? function get(key) { + return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY == 'has' ? function has(key) { + return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $({ global: true, forced: Constructor != NativeConstructor }, exported); + + setToStringTag(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/copy-constructor-properties.js": +/*!***************************************************************************!*\ + !*** ../../node_modules/core-js/internals/copy-constructor-properties.js ***! + \***************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); +var ownKeys = __webpack_require__(/*! ../internals/own-keys */ "../../node_modules/core-js/internals/own-keys.js"); +var getOwnPropertyDescriptorModule = __webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "../../node_modules/core-js/internals/object-get-own-property-descriptor.js"); +var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js"); + +module.exports = function (target, source) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/correct-prototype-getter.js": +/*!************************************************************************!*\ + !*** ../../node_modules/core-js/internals/correct-prototype-getter.js ***! + \************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); + +module.exports = !fails(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/create-iterator-constructor.js": +/*!***************************************************************************!*\ + !*** ../../node_modules/core-js/internals/create-iterator-constructor.js ***! + \***************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var IteratorPrototype = (__webpack_require__(/*! ../internals/iterators-core */ "../../node_modules/core-js/internals/iterators-core.js").IteratorPrototype); +var create = __webpack_require__(/*! ../internals/object-create */ "../../node_modules/core-js/internals/object-create.js"); +var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "../../node_modules/core-js/internals/create-property-descriptor.js"); +var setToStringTag = __webpack_require__(/*! ../internals/set-to-string-tag */ "../../node_modules/core-js/internals/set-to-string-tag.js"); +var Iterators = __webpack_require__(/*! ../internals/iterators */ "../../node_modules/core-js/internals/iterators.js"); + +var returnThis = function () { return this; }; + +module.exports = function (IteratorConstructor, NAME, next) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) }); + setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true); + Iterators[TO_STRING_TAG] = returnThis; + return IteratorConstructor; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/create-non-enumerable-property.js": +/*!******************************************************************************!*\ + !*** ../../node_modules/core-js/internals/create-non-enumerable-property.js ***! + \******************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); +var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js"); +var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "../../node_modules/core-js/internals/create-property-descriptor.js"); + +module.exports = DESCRIPTORS ? function (object, key, value) { + return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/create-property-descriptor.js": +/*!**************************************************************************!*\ + !*** ../../node_modules/core-js/internals/create-property-descriptor.js ***! + \**************************************************************************/ +/***/ ((module) => { + +module.exports = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/create-property.js": +/*!***************************************************************!*\ + !*** ../../node_modules/core-js/internals/create-property.js ***! + \***************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var toPropertyKey = __webpack_require__(/*! ../internals/to-property-key */ "../../node_modules/core-js/internals/to-property-key.js"); +var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js"); +var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "../../node_modules/core-js/internals/create-property-descriptor.js"); + +module.exports = function (object, key, value) { + var propertyKey = toPropertyKey(key); + if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/define-iterator.js": +/*!***************************************************************!*\ + !*** ../../node_modules/core-js/internals/define-iterator.js ***! + \***************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ "../../node_modules/core-js/internals/is-pure.js"); +var FunctionName = __webpack_require__(/*! ../internals/function-name */ "../../node_modules/core-js/internals/function-name.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var createIteratorConstructor = __webpack_require__(/*! ../internals/create-iterator-constructor */ "../../node_modules/core-js/internals/create-iterator-constructor.js"); +var getPrototypeOf = __webpack_require__(/*! ../internals/object-get-prototype-of */ "../../node_modules/core-js/internals/object-get-prototype-of.js"); +var setPrototypeOf = __webpack_require__(/*! ../internals/object-set-prototype-of */ "../../node_modules/core-js/internals/object-set-prototype-of.js"); +var setToStringTag = __webpack_require__(/*! ../internals/set-to-string-tag */ "../../node_modules/core-js/internals/set-to-string-tag.js"); +var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../../node_modules/core-js/internals/create-non-enumerable-property.js"); +var redefine = __webpack_require__(/*! ../internals/redefine */ "../../node_modules/core-js/internals/redefine.js"); +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); +var Iterators = __webpack_require__(/*! ../internals/iterators */ "../../node_modules/core-js/internals/iterators.js"); +var IteratorsCore = __webpack_require__(/*! ../internals/iterators-core */ "../../node_modules/core-js/internals/iterators-core.js"); + +var PROPER_FUNCTION_NAME = FunctionName.PROPER; +var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; +var IteratorPrototype = IteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR = wellKnownSymbol('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; + +var returnThis = function () { return this; }; + +module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND]; + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf) { + setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) { + redefine(CurrentIteratorPrototype, ITERATOR, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true); + if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis; + } + } + + // fix Array.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call(nativeIterator, this); }; + } + } + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + redefine(IterablePrototype, KEY, methods[KEY]); + } + } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) { + redefine(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT }); + } + Iterators[NAME] = defaultIterator; + + return methods; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/descriptors.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/internals/descriptors.js ***! + \***********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); + +// Detect IE8's incomplete defineProperty implementation +module.exports = !fails(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7; +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/document-create-element.js": +/*!***********************************************************************!*\ + !*** ../../node_modules/core-js/internals/document-create-element.js ***! + \***********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); + +var document = global.document; +// typeof document.createElement is 'object' in old IE +var EXISTS = isObject(document) && isObject(document.createElement); + +module.exports = function (it) { + return EXISTS ? document.createElement(it) : {}; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/engine-is-browser.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/engine-is-browser.js ***! + \*****************************************************************/ +/***/ ((module) => { + +module.exports = typeof window == 'object'; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/engine-is-ios-pebble.js": +/*!********************************************************************!*\ + !*** ../../node_modules/core-js/internals/engine-is-ios-pebble.js ***! + \********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var userAgent = __webpack_require__(/*! ../internals/engine-user-agent */ "../../node_modules/core-js/internals/engine-user-agent.js"); +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); + +module.exports = /ipad|iphone|ipod/i.test(userAgent) && global.Pebble !== undefined; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/engine-is-ios.js": +/*!*************************************************************!*\ + !*** ../../node_modules/core-js/internals/engine-is-ios.js ***! + \*************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var userAgent = __webpack_require__(/*! ../internals/engine-user-agent */ "../../node_modules/core-js/internals/engine-user-agent.js"); + +module.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/engine-is-node.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/internals/engine-is-node.js ***! + \**************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var classof = __webpack_require__(/*! ../internals/classof-raw */ "../../node_modules/core-js/internals/classof-raw.js"); +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); + +module.exports = classof(global.process) == 'process'; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/engine-is-webos-webkit.js": +/*!**********************************************************************!*\ + !*** ../../node_modules/core-js/internals/engine-is-webos-webkit.js ***! + \**********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var userAgent = __webpack_require__(/*! ../internals/engine-user-agent */ "../../node_modules/core-js/internals/engine-user-agent.js"); + +module.exports = /web0s(?!.*chrome)/i.test(userAgent); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/engine-user-agent.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/engine-user-agent.js ***! + \*****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../../node_modules/core-js/internals/get-built-in.js"); + +module.exports = getBuiltIn('navigator', 'userAgent') || ''; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/engine-v8-version.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/engine-v8-version.js ***! + \*****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var userAgent = __webpack_require__(/*! ../internals/engine-user-agent */ "../../node_modules/core-js/internals/engine-user-agent.js"); + +var process = global.process; +var Deno = global.Deno; +var versions = process && process.versions || Deno && Deno.version; +var v8 = versions && versions.v8; +var match, version; + +if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); +} + +// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` +// so check `userAgent` even if `.v8` exists, but 0 +if (!version && userAgent) { + match = userAgent.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } +} + +module.exports = version; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/entry-unbind.js": +/*!************************************************************!*\ + !*** ../../node_modules/core-js/internals/entry-unbind.js ***! + \************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); + +module.exports = function (CONSTRUCTOR, METHOD) { + return uncurryThis(global[CONSTRUCTOR].prototype[METHOD]); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/enum-bug-keys.js": +/*!*************************************************************!*\ + !*** ../../node_modules/core-js/internals/enum-bug-keys.js ***! + \*************************************************************/ +/***/ ((module) => { + +// IE8- don't enum bug keys +module.exports = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/error-stack-installable.js": +/*!***********************************************************************!*\ + !*** ../../node_modules/core-js/internals/error-stack-installable.js ***! + \***********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "../../node_modules/core-js/internals/create-property-descriptor.js"); + +module.exports = !fails(function () { + var error = Error('a'); + if (!('stack' in error)) return true; + // eslint-disable-next-line es/no-object-defineproperty -- safe + Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7)); + return error.stack !== 7; +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/export.js": +/*!******************************************************!*\ + !*** ../../node_modules/core-js/internals/export.js ***! + \******************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var getOwnPropertyDescriptor = (__webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "../../node_modules/core-js/internals/object-get-own-property-descriptor.js").f); +var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../../node_modules/core-js/internals/create-non-enumerable-property.js"); +var redefine = __webpack_require__(/*! ../internals/redefine */ "../../node_modules/core-js/internals/redefine.js"); +var setGlobal = __webpack_require__(/*! ../internals/set-global */ "../../node_modules/core-js/internals/set-global.js"); +var copyConstructorProperties = __webpack_require__(/*! ../internals/copy-constructor-properties */ "../../node_modules/core-js/internals/copy-constructor-properties.js"); +var isForced = __webpack_require__(/*! ../internals/is-forced */ "../../node_modules/core-js/internals/is-forced.js"); + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.noTargetGet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key +*/ +module.exports = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global; + } else if (STATIC) { + target = global[TARGET] || setGlobal(TARGET, {}); + } else { + target = (global[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.noTargetGet) { + descriptor = getOwnPropertyDescriptor(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty(sourceProperty, 'sham', true); + } + // extend global + redefine(target, key, sourceProperty, options); + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/fails.js": +/*!*****************************************************!*\ + !*** ../../node_modules/core-js/internals/fails.js ***! + \*****************************************************/ +/***/ ((module) => { + +module.exports = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/freezing.js": +/*!********************************************************!*\ + !*** ../../node_modules/core-js/internals/freezing.js ***! + \********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); + +module.exports = !fails(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/function-apply.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/internals/function-apply.js ***! + \**************************************************************/ +/***/ ((module) => { + +var FunctionPrototype = Function.prototype; +var apply = FunctionPrototype.apply; +var bind = FunctionPrototype.bind; +var call = FunctionPrototype.call; + +// eslint-disable-next-line es/no-reflect -- safe +module.exports = typeof Reflect == 'object' && Reflect.apply || (bind ? call.bind(apply) : function () { + return call.apply(apply, arguments); +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/function-bind-context.js": +/*!*********************************************************************!*\ + !*** ../../node_modules/core-js/internals/function-bind-context.js ***! + \*********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var aCallable = __webpack_require__(/*! ../internals/a-callable */ "../../node_modules/core-js/internals/a-callable.js"); + +var bind = uncurryThis(uncurryThis.bind); + +// optional / simple context binding +module.exports = function (fn, that) { + aCallable(fn); + return that === undefined ? fn : bind ? bind(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/function-call.js": +/*!*************************************************************!*\ + !*** ../../node_modules/core-js/internals/function-call.js ***! + \*************************************************************/ +/***/ ((module) => { + +var call = Function.prototype.call; + +module.exports = call.bind ? call.bind(call) : function () { + return call.apply(call, arguments); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/function-name.js": +/*!*************************************************************!*\ + !*** ../../node_modules/core-js/internals/function-name.js ***! + \*************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); + +var FunctionPrototype = Function.prototype; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor; + +var EXISTS = hasOwn(FunctionPrototype, 'name'); +// additional protection from minified / mangled / dropped function names +var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something'; +var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable)); + +module.exports = { + EXISTS: EXISTS, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/function-uncurry-this.js": +/*!*********************************************************************!*\ + !*** ../../node_modules/core-js/internals/function-uncurry-this.js ***! + \*********************************************************************/ +/***/ ((module) => { + +var FunctionPrototype = Function.prototype; +var bind = FunctionPrototype.bind; +var call = FunctionPrototype.call; +var callBind = bind && bind.bind(call); + +module.exports = bind ? function (fn) { + return fn && callBind(call, fn); +} : function (fn) { + return fn && function () { + return call.apply(fn, arguments); + }; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/get-built-in.js": +/*!************************************************************!*\ + !*** ../../node_modules/core-js/internals/get-built-in.js ***! + \************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); + +var aFunction = function (argument) { + return isCallable(argument) ? argument : undefined; +}; + +module.exports = function (namespace, method) { + return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method]; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/get-iterator-method.js": +/*!*******************************************************************!*\ + !*** ../../node_modules/core-js/internals/get-iterator-method.js ***! + \*******************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var classof = __webpack_require__(/*! ../internals/classof */ "../../node_modules/core-js/internals/classof.js"); +var getMethod = __webpack_require__(/*! ../internals/get-method */ "../../node_modules/core-js/internals/get-method.js"); +var Iterators = __webpack_require__(/*! ../internals/iterators */ "../../node_modules/core-js/internals/iterators.js"); +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); + +var ITERATOR = wellKnownSymbol('iterator'); + +module.exports = function (it) { + if (it != undefined) return getMethod(it, ITERATOR) + || getMethod(it, '@@iterator') + || Iterators[classof(it)]; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/get-iterator.js": +/*!************************************************************!*\ + !*** ../../node_modules/core-js/internals/get-iterator.js ***! + \************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var aCallable = __webpack_require__(/*! ../internals/a-callable */ "../../node_modules/core-js/internals/a-callable.js"); +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); +var tryToString = __webpack_require__(/*! ../internals/try-to-string */ "../../node_modules/core-js/internals/try-to-string.js"); +var getIteratorMethod = __webpack_require__(/*! ../internals/get-iterator-method */ "../../node_modules/core-js/internals/get-iterator-method.js"); + +var TypeError = global.TypeError; + +module.exports = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator; + if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument)); + throw TypeError(tryToString(argument) + ' is not iterable'); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/get-method.js": +/*!**********************************************************!*\ + !*** ../../node_modules/core-js/internals/get-method.js ***! + \**********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var aCallable = __webpack_require__(/*! ../internals/a-callable */ "../../node_modules/core-js/internals/a-callable.js"); + +// `GetMethod` abstract operation +// https://tc39.es/ecma262/#sec-getmethod +module.exports = function (V, P) { + var func = V[P]; + return func == null ? undefined : aCallable(func); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/global.js": +/*!******************************************************!*\ + !*** ../../node_modules/core-js/internals/global.js ***! + \******************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var check = function (it) { + return it && it.Math == Math && it; +}; + +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +module.exports = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof __webpack_require__.g == 'object' && __webpack_require__.g) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/has-own-property.js": +/*!****************************************************************!*\ + !*** ../../node_modules/core-js/internals/has-own-property.js ***! + \****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var toObject = __webpack_require__(/*! ../internals/to-object */ "../../node_modules/core-js/internals/to-object.js"); + +var hasOwnProperty = uncurryThis({}.hasOwnProperty); + +// `HasOwnProperty` abstract operation +// https://tc39.es/ecma262/#sec-hasownproperty +module.exports = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject(it), key); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/hidden-keys.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/internals/hidden-keys.js ***! + \***********************************************************/ +/***/ ((module) => { + +module.exports = {}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/host-report-errors.js": +/*!******************************************************************!*\ + !*** ../../node_modules/core-js/internals/host-report-errors.js ***! + \******************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); + +module.exports = function (a, b) { + var console = global.console; + if (console && console.error) { + arguments.length == 1 ? console.error(a) : console.error(a, b); + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/html.js": +/*!****************************************************!*\ + !*** ../../node_modules/core-js/internals/html.js ***! + \****************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../../node_modules/core-js/internals/get-built-in.js"); + +module.exports = getBuiltIn('document', 'documentElement'); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/ie8-dom-define.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/internals/ie8-dom-define.js ***! + \**************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var createElement = __webpack_require__(/*! ../internals/document-create-element */ "../../node_modules/core-js/internals/document-create-element.js"); + +// Thank's IE8 for his funny defineProperty +module.exports = !DESCRIPTORS && !fails(function () { + // eslint-disable-next-line es/no-object-defineproperty -- requied for testing + return Object.defineProperty(createElement('div'), 'a', { + get: function () { return 7; } + }).a != 7; +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/indexed-object.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/internals/indexed-object.js ***! + \**************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var classof = __webpack_require__(/*! ../internals/classof-raw */ "../../node_modules/core-js/internals/classof-raw.js"); + +var Object = global.Object; +var split = uncurryThis(''.split); + +// fallback for non-array-like ES3 and non-enumerable old V8 strings +module.exports = fails(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !Object('z').propertyIsEnumerable(0); +}) ? function (it) { + return classof(it) == 'String' ? split(it, '') : Object(it); +} : Object; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/inherit-if-required.js": +/*!*******************************************************************!*\ + !*** ../../node_modules/core-js/internals/inherit-if-required.js ***! + \*******************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); +var setPrototypeOf = __webpack_require__(/*! ../internals/object-set-prototype-of */ "../../node_modules/core-js/internals/object-set-prototype-of.js"); + +// makes subclassing work correct for wrapped built-ins +module.exports = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/inspect-source.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/internals/inspect-source.js ***! + \**************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var store = __webpack_require__(/*! ../internals/shared-store */ "../../node_modules/core-js/internals/shared-store.js"); + +var functionToString = uncurryThis(Function.toString); + +// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper +if (!isCallable(store.inspectSource)) { + store.inspectSource = function (it) { + return functionToString(it); + }; +} + +module.exports = store.inspectSource; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/install-error-cause.js": +/*!*******************************************************************!*\ + !*** ../../node_modules/core-js/internals/install-error-cause.js ***! + \*******************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); +var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../../node_modules/core-js/internals/create-non-enumerable-property.js"); + +// `InstallErrorCause` abstract operation +// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause +module.exports = function (O, options) { + if (isObject(options) && 'cause' in options) { + createNonEnumerableProperty(O, 'cause', options.cause); + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/internal-metadata.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/internal-metadata.js ***! + \*****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "../../node_modules/core-js/internals/hidden-keys.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); +var defineProperty = (__webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js").f); +var getOwnPropertyNamesModule = __webpack_require__(/*! ../internals/object-get-own-property-names */ "../../node_modules/core-js/internals/object-get-own-property-names.js"); +var getOwnPropertyNamesExternalModule = __webpack_require__(/*! ../internals/object-get-own-property-names-external */ "../../node_modules/core-js/internals/object-get-own-property-names-external.js"); +var uid = __webpack_require__(/*! ../internals/uid */ "../../node_modules/core-js/internals/uid.js"); +var FREEZING = __webpack_require__(/*! ../internals/freezing */ "../../node_modules/core-js/internals/freezing.js"); + +var REQUIRED = false; +var METADATA = uid('meta'); +var id = 0; + +// eslint-disable-next-line es/no-object-isextensible -- safe +var isExtensible = Object.isExtensible || function () { + return true; +}; + +var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + id++, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData = function (it, create) { + if (!hasOwn(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it); + return it; +}; + +var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis([].splice); + var test = {}; + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } +}; + +var meta = module.exports = { + enable: enable, + fastKey: fastKey, + getWeakData: getWeakData, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/internal-state.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/internals/internal-state.js ***! + \**************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var NATIVE_WEAK_MAP = __webpack_require__(/*! ../internals/native-weak-map */ "../../node_modules/core-js/internals/native-weak-map.js"); +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); +var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../../node_modules/core-js/internals/create-non-enumerable-property.js"); +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); +var shared = __webpack_require__(/*! ../internals/shared-store */ "../../node_modules/core-js/internals/shared-store.js"); +var sharedKey = __webpack_require__(/*! ../internals/shared-key */ "../../node_modules/core-js/internals/shared-key.js"); +var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "../../node_modules/core-js/internals/hidden-keys.js"); + +var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; +var TypeError = global.TypeError; +var WeakMap = global.WeakMap; +var set, get, has; + +var enforce = function (it) { + return has(it) ? get(it) : set(it, {}); +}; + +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject(it) || (state = get(it)).type !== TYPE) { + throw TypeError('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; +}; + +if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + var wmget = uncurryThis(store.get); + var wmhas = uncurryThis(store.has); + var wmset = uncurryThis(store.set); + set = function (it, metadata) { + if (wmhas(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + wmset(store, it, metadata); + return metadata; + }; + get = function (it) { + return wmget(store, it) || {}; + }; + has = function (it) { + return wmhas(store, it); + }; +} else { + var STATE = sharedKey('state'); + hiddenKeys[STATE] = true; + set = function (it, metadata) { + if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn(it, STATE); + }; +} + +module.exports = { + set: set, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/is-array-iterator-method.js": +/*!************************************************************************!*\ + !*** ../../node_modules/core-js/internals/is-array-iterator-method.js ***! + \************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); +var Iterators = __webpack_require__(/*! ../internals/iterators */ "../../node_modules/core-js/internals/iterators.js"); + +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayPrototype = Array.prototype; + +// check on default Array iterator +module.exports = function (it) { + return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/is-array.js": +/*!********************************************************!*\ + !*** ../../node_modules/core-js/internals/is-array.js ***! + \********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var classof = __webpack_require__(/*! ../internals/classof-raw */ "../../node_modules/core-js/internals/classof-raw.js"); + +// `IsArray` abstract operation +// https://tc39.es/ecma262/#sec-isarray +// eslint-disable-next-line es/no-array-isarray -- safe +module.exports = Array.isArray || function isArray(argument) { + return classof(argument) == 'Array'; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/is-callable.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/internals/is-callable.js ***! + \***********************************************************/ +/***/ ((module) => { + +// `IsCallable` abstract operation +// https://tc39.es/ecma262/#sec-iscallable +module.exports = function (argument) { + return typeof argument == 'function'; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/is-constructor.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/internals/is-constructor.js ***! + \**************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var classof = __webpack_require__(/*! ../internals/classof */ "../../node_modules/core-js/internals/classof.js"); +var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../../node_modules/core-js/internals/get-built-in.js"); +var inspectSource = __webpack_require__(/*! ../internals/inspect-source */ "../../node_modules/core-js/internals/inspect-source.js"); + +var noop = function () { /* empty */ }; +var empty = []; +var construct = getBuiltIn('Reflect', 'construct'); +var constructorRegExp = /^\s*(?:class|function)\b/; +var exec = uncurryThis(constructorRegExp.exec); +var INCORRECT_TO_STRING = !constructorRegExp.exec(noop); + +var isConstructorModern = function (argument) { + if (!isCallable(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } +}; + +var isConstructorLegacy = function (argument) { + if (!isCallable(argument)) return false; + switch (classof(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + // we can't check .prototype since constructors produced by .bind haven't it + } return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument)); +}; + +// `IsConstructor` abstract operation +// https://tc39.es/ecma262/#sec-isconstructor +module.exports = !construct || fails(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; +}) ? isConstructorLegacy : isConstructorModern; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/is-forced.js": +/*!*********************************************************!*\ + !*** ../../node_modules/core-js/internals/is-forced.js ***! + \*********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); + +var replacement = /#|\.prototype\./; + +var isForced = function (feature, detection) { + var value = data[normalize(feature)]; + return value == POLYFILL ? true + : value == NATIVE ? false + : isCallable(detection) ? fails(detection) + : !!detection; +}; + +var normalize = isForced.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced.data = {}; +var NATIVE = isForced.NATIVE = 'N'; +var POLYFILL = isForced.POLYFILL = 'P'; + +module.exports = isForced; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/is-integral-number.js": +/*!******************************************************************!*\ + !*** ../../node_modules/core-js/internals/is-integral-number.js ***! + \******************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); + +var floor = Math.floor; + +// `IsIntegralNumber` abstract operation +// https://tc39.es/ecma262/#sec-isintegralnumber +// eslint-disable-next-line es/no-number-isinteger -- safe +module.exports = Number.isInteger || function isInteger(it) { + return !isObject(it) && isFinite(it) && floor(it) === it; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/is-object.js": +/*!*********************************************************!*\ + !*** ../../node_modules/core-js/internals/is-object.js ***! + \*********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); + +module.exports = function (it) { + return typeof it == 'object' ? it !== null : isCallable(it); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/is-pure.js": +/*!*******************************************************!*\ + !*** ../../node_modules/core-js/internals/is-pure.js ***! + \*******************************************************/ +/***/ ((module) => { + +module.exports = false; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/is-symbol.js": +/*!*********************************************************!*\ + !*** ../../node_modules/core-js/internals/is-symbol.js ***! + \*********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../../node_modules/core-js/internals/get-built-in.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var isPrototypeOf = __webpack_require__(/*! ../internals/object-is-prototype-of */ "../../node_modules/core-js/internals/object-is-prototype-of.js"); +var USE_SYMBOL_AS_UID = __webpack_require__(/*! ../internals/use-symbol-as-uid */ "../../node_modules/core-js/internals/use-symbol-as-uid.js"); + +var Object = global.Object; + +module.exports = USE_SYMBOL_AS_UID ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + var $Symbol = getBuiltIn('Symbol'); + return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, Object(it)); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/iterate.js": +/*!*******************************************************!*\ + !*** ../../node_modules/core-js/internals/iterate.js ***! + \*******************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var bind = __webpack_require__(/*! ../internals/function-bind-context */ "../../node_modules/core-js/internals/function-bind-context.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); +var tryToString = __webpack_require__(/*! ../internals/try-to-string */ "../../node_modules/core-js/internals/try-to-string.js"); +var isArrayIteratorMethod = __webpack_require__(/*! ../internals/is-array-iterator-method */ "../../node_modules/core-js/internals/is-array-iterator-method.js"); +var lengthOfArrayLike = __webpack_require__(/*! ../internals/length-of-array-like */ "../../node_modules/core-js/internals/length-of-array-like.js"); +var isPrototypeOf = __webpack_require__(/*! ../internals/object-is-prototype-of */ "../../node_modules/core-js/internals/object-is-prototype-of.js"); +var getIterator = __webpack_require__(/*! ../internals/get-iterator */ "../../node_modules/core-js/internals/get-iterator.js"); +var getIteratorMethod = __webpack_require__(/*! ../internals/get-iterator-method */ "../../node_modules/core-js/internals/get-iterator-method.js"); +var iteratorClose = __webpack_require__(/*! ../internals/iterator-close */ "../../node_modules/core-js/internals/iterator-close.js"); + +var TypeError = global.TypeError; + +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; + +var ResultPrototype = Result.prototype; + +module.exports = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (!iterFn) throw TypeError(tryToString(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator(iterable, iterFn); + } + + next = iterator.next; + while (!(step = call(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/iterator-close.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/internals/iterator-close.js ***! + \**************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); +var getMethod = __webpack_require__(/*! ../internals/get-method */ "../../node_modules/core-js/internals/get-method.js"); + +module.exports = function (iterator, kind, value) { + var innerResult, innerError; + anObject(iterator); + try { + innerResult = getMethod(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject(innerResult); + return value; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/iterators-core.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/internals/iterators-core.js ***! + \**************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var create = __webpack_require__(/*! ../internals/object-create */ "../../node_modules/core-js/internals/object-create.js"); +var getPrototypeOf = __webpack_require__(/*! ../internals/object-get-prototype-of */ "../../node_modules/core-js/internals/object-get-prototype-of.js"); +var redefine = __webpack_require__(/*! ../internals/redefine */ "../../node_modules/core-js/internals/redefine.js"); +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); +var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ "../../node_modules/core-js/internals/is-pure.js"); + +var ITERATOR = wellKnownSymbol('iterator'); +var BUGGY_SAFARI_ITERATORS = false; + +// `%IteratorPrototype%` object +// https://tc39.es/ecma262/#sec-%iteratorprototype%-object +var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator; + +/* eslint-disable es/no-array-prototype-keys -- safe */ +if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype; + } +} + +var NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype[ITERATOR].call(test) !== test; +}); + +if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {}; +else if (IS_PURE) IteratorPrototype = create(IteratorPrototype); + +// `%IteratorPrototype%[@@iterator]()` method +// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator +if (!isCallable(IteratorPrototype[ITERATOR])) { + redefine(IteratorPrototype, ITERATOR, function () { + return this; + }); +} + +module.exports = { + IteratorPrototype: IteratorPrototype, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/iterators.js": +/*!*********************************************************!*\ + !*** ../../node_modules/core-js/internals/iterators.js ***! + \*********************************************************/ +/***/ ((module) => { + +module.exports = {}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/length-of-array-like.js": +/*!********************************************************************!*\ + !*** ../../node_modules/core-js/internals/length-of-array-like.js ***! + \********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var toLength = __webpack_require__(/*! ../internals/to-length */ "../../node_modules/core-js/internals/to-length.js"); + +// `LengthOfArrayLike` abstract operation +// https://tc39.es/ecma262/#sec-lengthofarraylike +module.exports = function (obj) { + return toLength(obj.length); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/microtask.js": +/*!*********************************************************!*\ + !*** ../../node_modules/core-js/internals/microtask.js ***! + \*********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var bind = __webpack_require__(/*! ../internals/function-bind-context */ "../../node_modules/core-js/internals/function-bind-context.js"); +var getOwnPropertyDescriptor = (__webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "../../node_modules/core-js/internals/object-get-own-property-descriptor.js").f); +var macrotask = (__webpack_require__(/*! ../internals/task */ "../../node_modules/core-js/internals/task.js").set); +var IS_IOS = __webpack_require__(/*! ../internals/engine-is-ios */ "../../node_modules/core-js/internals/engine-is-ios.js"); +var IS_IOS_PEBBLE = __webpack_require__(/*! ../internals/engine-is-ios-pebble */ "../../node_modules/core-js/internals/engine-is-ios-pebble.js"); +var IS_WEBOS_WEBKIT = __webpack_require__(/*! ../internals/engine-is-webos-webkit */ "../../node_modules/core-js/internals/engine-is-webos-webkit.js"); +var IS_NODE = __webpack_require__(/*! ../internals/engine-is-node */ "../../node_modules/core-js/internals/engine-is-node.js"); + +var MutationObserver = global.MutationObserver || global.WebKitMutationObserver; +var document = global.document; +var process = global.process; +var Promise = global.Promise; +// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` +var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask'); +var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; + +var flush, head, last, notify, toggle, node, promise, then; + +// modern engines have queueMicrotask method +if (!queueMicrotask) { + flush = function () { + var parent, fn; + if (IS_NODE && (parent = process.domain)) parent.exit(); + while (head) { + fn = head.fn; + head = head.next; + try { + fn(); + } catch (error) { + if (head) notify(); + else last = undefined; + throw error; + } + } last = undefined; + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) { + toggle = true; + node = document.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise; + then = bind(promise.then, promise); + notify = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE) { + notify = function () { + process.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessag + // - onreadystatechange + // - setTimeout + } else { + // strange IE + webpack dev server bug - use .bind(global) + macrotask = bind(macrotask, global); + notify = function () { + macrotask(flush); + }; + } +} + +module.exports = queueMicrotask || function (fn) { + var task = { fn: fn, next: undefined }; + if (last) last.next = task; + if (!head) { + head = task; + notify(); + } last = task; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/native-promise-constructor.js": +/*!**************************************************************************!*\ + !*** ../../node_modules/core-js/internals/native-promise-constructor.js ***! + \**************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); + +module.exports = global.Promise; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/native-symbol.js": +/*!*************************************************************!*\ + !*** ../../node_modules/core-js/internals/native-symbol.js ***! + \*************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +/* eslint-disable es/no-symbol -- required for testing */ +var V8_VERSION = __webpack_require__(/*! ../internals/engine-v8-version */ "../../node_modules/core-js/internals/engine-v8-version.js"); +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing +module.exports = !!Object.getOwnPropertySymbols && !fails(function () { + var symbol = Symbol(); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + return !String(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION && V8_VERSION < 41; +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/native-weak-map.js": +/*!***************************************************************!*\ + !*** ../../node_modules/core-js/internals/native-weak-map.js ***! + \***************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var inspectSource = __webpack_require__(/*! ../internals/inspect-source */ "../../node_modules/core-js/internals/inspect-source.js"); + +var WeakMap = global.WeakMap; + +module.exports = isCallable(WeakMap) && /native code/.test(inspectSource(WeakMap)); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/new-promise-capability.js": +/*!**********************************************************************!*\ + !*** ../../node_modules/core-js/internals/new-promise-capability.js ***! + \**********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var aCallable = __webpack_require__(/*! ../internals/a-callable */ "../../node_modules/core-js/internals/a-callable.js"); + +var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable(resolve); + this.reject = aCallable(reject); +}; + +// `NewPromiseCapability` abstract operation +// https://tc39.es/ecma262/#sec-newpromisecapability +module.exports.f = function (C) { + return new PromiseCapability(C); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/normalize-string-argument.js": +/*!*************************************************************************!*\ + !*** ../../node_modules/core-js/internals/normalize-string-argument.js ***! + \*************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var toString = __webpack_require__(/*! ../internals/to-string */ "../../node_modules/core-js/internals/to-string.js"); + +module.exports = function (argument, $default) { + return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/number-parse-float.js": +/*!******************************************************************!*\ + !*** ../../node_modules/core-js/internals/number-parse-float.js ***! + \******************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var toString = __webpack_require__(/*! ../internals/to-string */ "../../node_modules/core-js/internals/to-string.js"); +var trim = (__webpack_require__(/*! ../internals/string-trim */ "../../node_modules/core-js/internals/string-trim.js").trim); +var whitespaces = __webpack_require__(/*! ../internals/whitespaces */ "../../node_modules/core-js/internals/whitespaces.js"); + +var charAt = uncurryThis(''.charAt); +var n$ParseFloat = global.parseFloat; +var Symbol = global.Symbol; +var ITERATOR = Symbol && Symbol.iterator; +var FORCED = 1 / n$ParseFloat(whitespaces + '-0') !== -Infinity + // MS Edge 18- broken with boxed symbols + || (ITERATOR && !fails(function () { n$ParseFloat(Object(ITERATOR)); })); + +// `parseFloat` method +// https://tc39.es/ecma262/#sec-parsefloat-string +module.exports = FORCED ? function parseFloat(string) { + var trimmedString = trim(toString(string)); + var result = n$ParseFloat(trimmedString); + return result === 0 && charAt(trimmedString, 0) == '-' ? -0 : result; +} : n$ParseFloat; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/number-parse-int.js": +/*!****************************************************************!*\ + !*** ../../node_modules/core-js/internals/number-parse-int.js ***! + \****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var toString = __webpack_require__(/*! ../internals/to-string */ "../../node_modules/core-js/internals/to-string.js"); +var trim = (__webpack_require__(/*! ../internals/string-trim */ "../../node_modules/core-js/internals/string-trim.js").trim); +var whitespaces = __webpack_require__(/*! ../internals/whitespaces */ "../../node_modules/core-js/internals/whitespaces.js"); + +var $parseInt = global.parseInt; +var Symbol = global.Symbol; +var ITERATOR = Symbol && Symbol.iterator; +var hex = /^[+-]?0x/i; +var exec = uncurryThis(hex.exec); +var FORCED = $parseInt(whitespaces + '08') !== 8 || $parseInt(whitespaces + '0x16') !== 22 + // MS Edge 18- broken with boxed symbols + || (ITERATOR && !fails(function () { $parseInt(Object(ITERATOR)); })); + +// `parseInt` method +// https://tc39.es/ecma262/#sec-parseint-string-radix +module.exports = FORCED ? function parseInt(string, radix) { + var S = trim(toString(string)); + return $parseInt(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10)); +} : $parseInt; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-assign.js": +/*!*************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-assign.js ***! + \*************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var objectKeys = __webpack_require__(/*! ../internals/object-keys */ "../../node_modules/core-js/internals/object-keys.js"); +var getOwnPropertySymbolsModule = __webpack_require__(/*! ../internals/object-get-own-property-symbols */ "../../node_modules/core-js/internals/object-get-own-property-symbols.js"); +var propertyIsEnumerableModule = __webpack_require__(/*! ../internals/object-property-is-enumerable */ "../../node_modules/core-js/internals/object-property-is-enumerable.js"); +var toObject = __webpack_require__(/*! ../internals/to-object */ "../../node_modules/core-js/internals/to-object.js"); +var IndexedObject = __webpack_require__(/*! ../internals/indexed-object */ "../../node_modules/core-js/internals/indexed-object.js"); + +// eslint-disable-next-line es/no-object-assign -- safe +var $assign = Object.assign; +// eslint-disable-next-line es/no-object-defineproperty -- required for testing +var defineProperty = Object.defineProperty; +var concat = uncurryThis([].concat); + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +module.exports = !$assign || fails(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', { + enumerable: true, + get: function () { + defineProperty(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol(); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet; +}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; +} : $assign; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-create.js": +/*!*************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-create.js ***! + \*************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +/* global ActiveXObject -- old IE, WSH */ +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); +var defineProperties = __webpack_require__(/*! ../internals/object-define-properties */ "../../node_modules/core-js/internals/object-define-properties.js"); +var enumBugKeys = __webpack_require__(/*! ../internals/enum-bug-keys */ "../../node_modules/core-js/internals/enum-bug-keys.js"); +var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "../../node_modules/core-js/internals/hidden-keys.js"); +var html = __webpack_require__(/*! ../internals/html */ "../../node_modules/core-js/internals/html.js"); +var documentCreateElement = __webpack_require__(/*! ../internals/document-create-element */ "../../node_modules/core-js/internals/document-create-element.js"); +var sharedKey = __webpack_require__(/*! ../internals/shared-key */ "../../node_modules/core-js/internals/shared-key.js"); + +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO = sharedKey('IE_PROTO'); + +var EmptyConstructor = function () { /* empty */ }; + +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; + +// Create object with fake `null` prototype: use ActiveX Object with cleared prototype +var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; +}; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; + +// Check for document.domain and active x support +// No need to use active x approach when document.domain is not set +// see https://github.com/es-shims/es5-shim/issues/150 +// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 +// avoid IE GC bug +var activeXDocument; +var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; + +hiddenKeys[IE_PROTO] = true; + +// `Object.create` method +// https://tc39.es/ecma262/#sec-object.create +module.exports = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : defineProperties(result, Properties); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-define-properties.js": +/*!************************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-define-properties.js ***! + \************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); +var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js"); +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); +var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../../node_modules/core-js/internals/to-indexed-object.js"); +var objectKeys = __webpack_require__(/*! ../internals/object-keys */ "../../node_modules/core-js/internals/object-keys.js"); + +// `Object.defineProperties` method +// https://tc39.es/ecma262/#sec-object.defineproperties +// eslint-disable-next-line es/no-object-defineproperties -- safe +module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) { + anObject(O); + var props = toIndexedObject(Properties); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]); + return O; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-define-property.js": +/*!**********************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-define-property.js ***! + \**********************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); +var IE8_DOM_DEFINE = __webpack_require__(/*! ../internals/ie8-dom-define */ "../../node_modules/core-js/internals/ie8-dom-define.js"); +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); +var toPropertyKey = __webpack_require__(/*! ../internals/to-property-key */ "../../node_modules/core-js/internals/to-property-key.js"); + +var TypeError = global.TypeError; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var $defineProperty = Object.defineProperty; + +// `Object.defineProperty` method +// https://tc39.es/ecma262/#sec-object.defineproperty +exports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPropertyKey(P); + anObject(Attributes); + if (IE8_DOM_DEFINE) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-get-own-property-descriptor.js": +/*!**********************************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-get-own-property-descriptor.js ***! + \**********************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var propertyIsEnumerableModule = __webpack_require__(/*! ../internals/object-property-is-enumerable */ "../../node_modules/core-js/internals/object-property-is-enumerable.js"); +var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "../../node_modules/core-js/internals/create-property-descriptor.js"); +var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../../node_modules/core-js/internals/to-indexed-object.js"); +var toPropertyKey = __webpack_require__(/*! ../internals/to-property-key */ "../../node_modules/core-js/internals/to-property-key.js"); +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); +var IE8_DOM_DEFINE = __webpack_require__(/*! ../internals/ie8-dom-define */ "../../node_modules/core-js/internals/ie8-dom-define.js"); + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor +exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject(O); + P = toPropertyKey(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-get-own-property-names-external.js": +/*!**************************************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-get-own-property-names-external.js ***! + \**************************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +/* eslint-disable es/no-object-getownpropertynames -- safe */ +var classof = __webpack_require__(/*! ../internals/classof-raw */ "../../node_modules/core-js/internals/classof-raw.js"); +var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../../node_modules/core-js/internals/to-indexed-object.js"); +var $getOwnPropertyNames = (__webpack_require__(/*! ../internals/object-get-own-property-names */ "../../node_modules/core-js/internals/object-get-own-property-names.js").f); +var arraySlice = __webpack_require__(/*! ../internals/array-slice */ "../../node_modules/core-js/internals/array-slice.js"); + +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function (it) { + try { + return $getOwnPropertyNames(it); + } catch (error) { + return arraySlice(windowNames); + } +}; + +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +module.exports.f = function getOwnPropertyNames(it) { + return windowNames && classof(it) == 'Window' + ? getWindowNames(it) + : $getOwnPropertyNames(toIndexedObject(it)); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-get-own-property-names.js": +/*!*****************************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-get-own-property-names.js ***! + \*****************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +var internalObjectKeys = __webpack_require__(/*! ../internals/object-keys-internal */ "../../node_modules/core-js/internals/object-keys-internal.js"); +var enumBugKeys = __webpack_require__(/*! ../internals/enum-bug-keys */ "../../node_modules/core-js/internals/enum-bug-keys.js"); + +var hiddenKeys = enumBugKeys.concat('length', 'prototype'); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +// eslint-disable-next-line es/no-object-getownpropertynames -- safe +exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys(O, hiddenKeys); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-get-own-property-symbols.js": +/*!*******************************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-get-own-property-symbols.js ***! + \*******************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe +exports.f = Object.getOwnPropertySymbols; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-get-prototype-of.js": +/*!***********************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-get-prototype-of.js ***! + \***********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var toObject = __webpack_require__(/*! ../internals/to-object */ "../../node_modules/core-js/internals/to-object.js"); +var sharedKey = __webpack_require__(/*! ../internals/shared-key */ "../../node_modules/core-js/internals/shared-key.js"); +var CORRECT_PROTOTYPE_GETTER = __webpack_require__(/*! ../internals/correct-prototype-getter */ "../../node_modules/core-js/internals/correct-prototype-getter.js"); + +var IE_PROTO = sharedKey('IE_PROTO'); +var Object = global.Object; +var ObjectPrototype = Object.prototype; + +// `Object.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.getprototypeof +module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) { + var object = toObject(O); + if (hasOwn(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof Object ? ObjectPrototype : null; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-is-prototype-of.js": +/*!**********************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-is-prototype-of.js ***! + \**********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); + +module.exports = uncurryThis({}.isPrototypeOf); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-keys-internal.js": +/*!********************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-keys-internal.js ***! + \********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); +var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../../node_modules/core-js/internals/to-indexed-object.js"); +var indexOf = (__webpack_require__(/*! ../internals/array-includes */ "../../node_modules/core-js/internals/array-includes.js").indexOf); +var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "../../node_modules/core-js/internals/hidden-keys.js"); + +var push = uncurryThis([].push); + +module.exports = function (object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn(O, key = names[i++])) { + ~indexOf(result, key) || push(result, key); + } + return result; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-keys.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/internals/object-keys.js ***! + \***********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var internalObjectKeys = __webpack_require__(/*! ../internals/object-keys-internal */ "../../node_modules/core-js/internals/object-keys-internal.js"); +var enumBugKeys = __webpack_require__(/*! ../internals/enum-bug-keys */ "../../node_modules/core-js/internals/enum-bug-keys.js"); + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +// eslint-disable-next-line es/no-object-keys -- safe +module.exports = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-property-is-enumerable.js": +/*!*****************************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-property-is-enumerable.js ***! + \*****************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +var $propertyIsEnumerable = {}.propertyIsEnumerable; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// Nashorn ~ JDK8 bug +var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1); + +// `Object.prototype.propertyIsEnumerable` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable +exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor(this, V); + return !!descriptor && descriptor.enumerable; +} : $propertyIsEnumerable; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-set-prototype-of.js": +/*!***********************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-set-prototype-of.js ***! + \***********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +/* eslint-disable no-proto -- safe */ +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); +var aPossiblePrototype = __webpack_require__(/*! ../internals/a-possible-prototype */ "../../node_modules/core-js/internals/a-possible-prototype.js"); + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +// Works with __proto__ only. Old v8 can't work with null proto objects. +// eslint-disable-next-line es/no-object-setprototypeof -- safe +module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + setter = uncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-to-array.js": +/*!***************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-to-array.js ***! + \***************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var objectKeys = __webpack_require__(/*! ../internals/object-keys */ "../../node_modules/core-js/internals/object-keys.js"); +var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../../node_modules/core-js/internals/to-indexed-object.js"); +var $propertyIsEnumerable = (__webpack_require__(/*! ../internals/object-property-is-enumerable */ "../../node_modules/core-js/internals/object-property-is-enumerable.js").f); + +var propertyIsEnumerable = uncurryThis($propertyIsEnumerable); +var push = uncurryThis([].push); + +// `Object.{ entries, values }` methods implementation +var createMethod = function (TO_ENTRIES) { + return function (it) { + var O = toIndexedObject(it); + var keys = objectKeys(O); + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!DESCRIPTORS || propertyIsEnumerable(O, key)) { + push(result, TO_ENTRIES ? [key, O[key]] : O[key]); + } + } + return result; + }; +}; + +module.exports = { + // `Object.entries` method + // https://tc39.es/ecma262/#sec-object.entries + entries: createMethod(true), + // `Object.values` method + // https://tc39.es/ecma262/#sec-object.values + values: createMethod(false) +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/object-to-string.js": +/*!****************************************************************!*\ + !*** ../../node_modules/core-js/internals/object-to-string.js ***! + \****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var TO_STRING_TAG_SUPPORT = __webpack_require__(/*! ../internals/to-string-tag-support */ "../../node_modules/core-js/internals/to-string-tag-support.js"); +var classof = __webpack_require__(/*! ../internals/classof */ "../../node_modules/core-js/internals/classof.js"); + +// `Object.prototype.toString` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.tostring +module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() { + return '[object ' + classof(this) + ']'; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/ordinary-to-primitive.js": +/*!*********************************************************************!*\ + !*** ../../node_modules/core-js/internals/ordinary-to-primitive.js ***! + \*********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); + +var TypeError = global.TypeError; + +// `OrdinaryToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-ordinarytoprimitive +module.exports = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val; + if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val; + if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val; + throw TypeError("Can't convert object to primitive value"); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/own-keys.js": +/*!********************************************************!*\ + !*** ../../node_modules/core-js/internals/own-keys.js ***! + \********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../../node_modules/core-js/internals/get-built-in.js"); +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var getOwnPropertyNamesModule = __webpack_require__(/*! ../internals/object-get-own-property-names */ "../../node_modules/core-js/internals/object-get-own-property-names.js"); +var getOwnPropertySymbolsModule = __webpack_require__(/*! ../internals/object-get-own-property-symbols */ "../../node_modules/core-js/internals/object-get-own-property-symbols.js"); +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); + +var concat = uncurryThis([].concat); + +// all object keys, includes non-enumerable and symbols +module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/path.js": +/*!****************************************************!*\ + !*** ../../node_modules/core-js/internals/path.js ***! + \****************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); + +module.exports = global; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/perform.js": +/*!*******************************************************!*\ + !*** ../../node_modules/core-js/internals/perform.js ***! + \*******************************************************/ +/***/ ((module) => { + +module.exports = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/promise-resolve.js": +/*!***************************************************************!*\ + !*** ../../node_modules/core-js/internals/promise-resolve.js ***! + \***************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); +var newPromiseCapability = __webpack_require__(/*! ../internals/new-promise-capability */ "../../node_modules/core-js/internals/new-promise-capability.js"); + +module.exports = function (C, x) { + anObject(C); + if (isObject(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/redefine-all.js": +/*!************************************************************!*\ + !*** ../../node_modules/core-js/internals/redefine-all.js ***! + \************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var redefine = __webpack_require__(/*! ../internals/redefine */ "../../node_modules/core-js/internals/redefine.js"); + +module.exports = function (target, src, options) { + for (var key in src) redefine(target, key, src[key], options); + return target; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/redefine.js": +/*!********************************************************!*\ + !*** ../../node_modules/core-js/internals/redefine.js ***! + \********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); +var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../../node_modules/core-js/internals/create-non-enumerable-property.js"); +var setGlobal = __webpack_require__(/*! ../internals/set-global */ "../../node_modules/core-js/internals/set-global.js"); +var inspectSource = __webpack_require__(/*! ../internals/inspect-source */ "../../node_modules/core-js/internals/inspect-source.js"); +var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "../../node_modules/core-js/internals/internal-state.js"); +var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(/*! ../internals/function-name */ "../../node_modules/core-js/internals/function-name.js").CONFIGURABLE); + +var getInternalState = InternalStateModule.get; +var enforceInternalState = InternalStateModule.enforce; +var TEMPLATE = String(String).split('String'); + +(module.exports = function (O, key, value, options) { + var unsafe = options ? !!options.unsafe : false; + var simple = options ? !!options.enumerable : false; + var noTargetGet = options ? !!options.noTargetGet : false; + var name = options && options.name !== undefined ? options.name : key; + var state; + if (isCallable(value)) { + if (String(name).slice(0, 7) === 'Symbol(') { + name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) { + createNonEnumerableProperty(value, 'name', name); + } + state = enforceInternalState(value); + if (!state.source) { + state.source = TEMPLATE.join(typeof name == 'string' ? name : ''); + } + } + if (O === global) { + if (simple) O[key] = value; + else setGlobal(key, value); + return; + } else if (!unsafe) { + delete O[key]; + } else if (!noTargetGet && O[key]) { + simple = true; + } + if (simple) O[key] = value; + else createNonEnumerableProperty(O, key, value); +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +})(Function.prototype, 'toString', function toString() { + return isCallable(this) && getInternalState(this).source || inspectSource(this); +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/require-object-coercible.js": +/*!************************************************************************!*\ + !*** ../../node_modules/core-js/internals/require-object-coercible.js ***! + \************************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); + +var TypeError = global.TypeError; + +// `RequireObjectCoercible` abstract operation +// https://tc39.es/ecma262/#sec-requireobjectcoercible +module.exports = function (it) { + if (it == undefined) throw TypeError("Can't call method on " + it); + return it; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/set-global.js": +/*!**********************************************************!*\ + !*** ../../node_modules/core-js/internals/set-global.js ***! + \**********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); + +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty = Object.defineProperty; + +module.exports = function (key, value) { + try { + defineProperty(global, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global[key] = value; + } return value; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/set-species.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/internals/set-species.js ***! + \***********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../../node_modules/core-js/internals/get-built-in.js"); +var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js"); +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); +var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); + +var SPECIES = wellKnownSymbol('species'); + +module.exports = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn(CONSTRUCTOR_NAME); + var defineProperty = definePropertyModule.f; + + if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) { + defineProperty(Constructor, SPECIES, { + configurable: true, + get: function () { return this; } + }); + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/set-to-string-tag.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/set-to-string-tag.js ***! + \*****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var defineProperty = (__webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js").f); +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); + +module.exports = function (it, TAG, STATIC) { + if (it && !hasOwn(it = STATIC ? it : it.prototype, TO_STRING_TAG)) { + defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/shared-key.js": +/*!**********************************************************!*\ + !*** ../../node_modules/core-js/internals/shared-key.js ***! + \**********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var shared = __webpack_require__(/*! ../internals/shared */ "../../node_modules/core-js/internals/shared.js"); +var uid = __webpack_require__(/*! ../internals/uid */ "../../node_modules/core-js/internals/uid.js"); + +var keys = shared('keys'); + +module.exports = function (key) { + return keys[key] || (keys[key] = uid(key)); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/shared-store.js": +/*!************************************************************!*\ + !*** ../../node_modules/core-js/internals/shared-store.js ***! + \************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var setGlobal = __webpack_require__(/*! ../internals/set-global */ "../../node_modules/core-js/internals/set-global.js"); + +var SHARED = '__core-js_shared__'; +var store = global[SHARED] || setGlobal(SHARED, {}); + +module.exports = store; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/shared.js": +/*!******************************************************!*\ + !*** ../../node_modules/core-js/internals/shared.js ***! + \******************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ "../../node_modules/core-js/internals/is-pure.js"); +var store = __webpack_require__(/*! ../internals/shared-store */ "../../node_modules/core-js/internals/shared-store.js"); + +(module.exports = function (key, value) { + return store[key] || (store[key] = value !== undefined ? value : {}); +})('versions', []).push({ + version: '3.19.0', + mode: IS_PURE ? 'pure' : 'global', + copyright: '© 2021 Denis Pushkarev (zloirock.ru)' +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/species-constructor.js": +/*!*******************************************************************!*\ + !*** ../../node_modules/core-js/internals/species-constructor.js ***! + \*******************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var anObject = __webpack_require__(/*! ../internals/an-object */ "../../node_modules/core-js/internals/an-object.js"); +var aConstructor = __webpack_require__(/*! ../internals/a-constructor */ "../../node_modules/core-js/internals/a-constructor.js"); +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); + +var SPECIES = wellKnownSymbol('species'); + +// `SpeciesConstructor` abstract operation +// https://tc39.es/ecma262/#sec-speciesconstructor +module.exports = function (O, defaultConstructor) { + var C = anObject(O).constructor; + var S; + return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aConstructor(S); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/string-multibyte.js": +/*!****************************************************************!*\ + !*** ../../node_modules/core-js/internals/string-multibyte.js ***! + \****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var toIntegerOrInfinity = __webpack_require__(/*! ../internals/to-integer-or-infinity */ "../../node_modules/core-js/internals/to-integer-or-infinity.js"); +var toString = __webpack_require__(/*! ../internals/to-string */ "../../node_modules/core-js/internals/to-string.js"); +var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ "../../node_modules/core-js/internals/require-object-coercible.js"); + +var charAt = uncurryThis(''.charAt); +var charCodeAt = uncurryThis(''.charCodeAt); +var stringSlice = uncurryThis(''.slice); + +var createMethod = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = toString(requireObjectCoercible($this)); + var position = toIntegerOrInfinity(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = charCodeAt(S, position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; +}; + +module.exports = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod(true) +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/string-trim.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/internals/string-trim.js ***! + \***********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); +var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ "../../node_modules/core-js/internals/require-object-coercible.js"); +var toString = __webpack_require__(/*! ../internals/to-string */ "../../node_modules/core-js/internals/to-string.js"); +var whitespaces = __webpack_require__(/*! ../internals/whitespaces */ "../../node_modules/core-js/internals/whitespaces.js"); + +var replace = uncurryThis(''.replace); +var whitespace = '[' + whitespaces + ']'; +var ltrim = RegExp('^' + whitespace + whitespace + '*'); +var rtrim = RegExp(whitespace + whitespace + '*$'); + +// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation +var createMethod = function (TYPE) { + return function ($this) { + var string = toString(requireObjectCoercible($this)); + if (TYPE & 1) string = replace(string, ltrim, ''); + if (TYPE & 2) string = replace(string, rtrim, ''); + return string; + }; +}; + +module.exports = { + // `String.prototype.{ trimLeft, trimStart }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimstart + start: createMethod(1), + // `String.prototype.{ trimRight, trimEnd }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimend + end: createMethod(2), + // `String.prototype.trim` method + // https://tc39.es/ecma262/#sec-string.prototype.trim + trim: createMethod(3) +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/task.js": +/*!****************************************************!*\ + !*** ../../node_modules/core-js/internals/task.js ***! + \****************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var apply = __webpack_require__(/*! ../internals/function-apply */ "../../node_modules/core-js/internals/function-apply.js"); +var bind = __webpack_require__(/*! ../internals/function-bind-context */ "../../node_modules/core-js/internals/function-bind-context.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var html = __webpack_require__(/*! ../internals/html */ "../../node_modules/core-js/internals/html.js"); +var arraySlice = __webpack_require__(/*! ../internals/array-slice */ "../../node_modules/core-js/internals/array-slice.js"); +var createElement = __webpack_require__(/*! ../internals/document-create-element */ "../../node_modules/core-js/internals/document-create-element.js"); +var IS_IOS = __webpack_require__(/*! ../internals/engine-is-ios */ "../../node_modules/core-js/internals/engine-is-ios.js"); +var IS_NODE = __webpack_require__(/*! ../internals/engine-is-node */ "../../node_modules/core-js/internals/engine-is-node.js"); + +var set = global.setImmediate; +var clear = global.clearImmediate; +var process = global.process; +var Dispatch = global.Dispatch; +var Function = global.Function; +var MessageChannel = global.MessageChannel; +var String = global.String; +var counter = 0; +var queue = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var location, defer, channel, port; + +try { + // Deno throws a ReferenceError on `location` access without `--location` flag + location = global.location; +} catch (error) { /* empty */ } + +var run = function (id) { + if (hasOwn(queue, id)) { + var fn = queue[id]; + delete queue[id]; + fn(); + } +}; + +var runner = function (id) { + return function () { + run(id); + }; +}; + +var listener = function (event) { + run(event.data); +}; + +var post = function (id) { + // old engines have not location.origin + global.postMessage(String(id), location.protocol + '//' + location.host); +}; + +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!set || !clear) { + set = function setImmediate(fn) { + var args = arraySlice(arguments, 1); + queue[++counter] = function () { + apply(isCallable(fn) ? fn : Function(fn), undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue[id]; + }; + // Node.js 0.8- + if (IS_NODE) { + defer = function (id) { + process.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = listener; + defer = bind(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global.addEventListener && + isCallable(global.postMessage) && + !global.importScripts && + location && location.protocol !== 'file:' && + !fails(post) + ) { + defer = post; + global.addEventListener('message', listener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } +} + +module.exports = { + set: set, + clear: clear +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/to-absolute-index.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/to-absolute-index.js ***! + \*****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var toIntegerOrInfinity = __webpack_require__(/*! ../internals/to-integer-or-infinity */ "../../node_modules/core-js/internals/to-integer-or-infinity.js"); + +var max = Math.max; +var min = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). +module.exports = function (index, length) { + var integer = toIntegerOrInfinity(index); + return integer < 0 ? max(integer + length, 0) : min(integer, length); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/to-indexed-object.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/to-indexed-object.js ***! + \*****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +// toObject with fallback for non-array-like ES3 strings +var IndexedObject = __webpack_require__(/*! ../internals/indexed-object */ "../../node_modules/core-js/internals/indexed-object.js"); +var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ "../../node_modules/core-js/internals/require-object-coercible.js"); + +module.exports = function (it) { + return IndexedObject(requireObjectCoercible(it)); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/to-integer-or-infinity.js": +/*!**********************************************************************!*\ + !*** ../../node_modules/core-js/internals/to-integer-or-infinity.js ***! + \**********************************************************************/ +/***/ ((module) => { + +var ceil = Math.ceil; +var floor = Math.floor; + +// `ToIntegerOrInfinity` abstract operation +// https://tc39.es/ecma262/#sec-tointegerorinfinity +module.exports = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- safe + return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/to-length.js": +/*!*********************************************************!*\ + !*** ../../node_modules/core-js/internals/to-length.js ***! + \*********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var toIntegerOrInfinity = __webpack_require__(/*! ../internals/to-integer-or-infinity */ "../../node_modules/core-js/internals/to-integer-or-infinity.js"); + +var min = Math.min; + +// `ToLength` abstract operation +// https://tc39.es/ecma262/#sec-tolength +module.exports = function (argument) { + return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/to-object.js": +/*!*********************************************************!*\ + !*** ../../node_modules/core-js/internals/to-object.js ***! + \*********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ "../../node_modules/core-js/internals/require-object-coercible.js"); + +var Object = global.Object; + +// `ToObject` abstract operation +// https://tc39.es/ecma262/#sec-toobject +module.exports = function (argument) { + return Object(requireObjectCoercible(argument)); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/to-primitive.js": +/*!************************************************************!*\ + !*** ../../node_modules/core-js/internals/to-primitive.js ***! + \************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); +var isSymbol = __webpack_require__(/*! ../internals/is-symbol */ "../../node_modules/core-js/internals/is-symbol.js"); +var getMethod = __webpack_require__(/*! ../internals/get-method */ "../../node_modules/core-js/internals/get-method.js"); +var ordinaryToPrimitive = __webpack_require__(/*! ../internals/ordinary-to-primitive */ "../../node_modules/core-js/internals/ordinary-to-primitive.js"); +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); + +var TypeError = global.TypeError; +var TO_PRIMITIVE = wellKnownSymbol('toPrimitive'); + +// `ToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-toprimitive +module.exports = function (input, pref) { + if (!isObject(input) || isSymbol(input)) return input; + var exoticToPrim = getMethod(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call(exoticToPrim, input, pref); + if (!isObject(result) || isSymbol(result)) return result; + throw TypeError("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/to-property-key.js": +/*!***************************************************************!*\ + !*** ../../node_modules/core-js/internals/to-property-key.js ***! + \***************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var toPrimitive = __webpack_require__(/*! ../internals/to-primitive */ "../../node_modules/core-js/internals/to-primitive.js"); +var isSymbol = __webpack_require__(/*! ../internals/is-symbol */ "../../node_modules/core-js/internals/is-symbol.js"); + +// `ToPropertyKey` abstract operation +// https://tc39.es/ecma262/#sec-topropertykey +module.exports = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/to-string-tag-support.js": +/*!*********************************************************************!*\ + !*** ../../node_modules/core-js/internals/to-string-tag-support.js ***! + \*********************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); + +var TO_STRING_TAG = wellKnownSymbol('toStringTag'); +var test = {}; + +test[TO_STRING_TAG] = 'z'; + +module.exports = String(test) === '[object z]'; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/to-string.js": +/*!*********************************************************!*\ + !*** ../../node_modules/core-js/internals/to-string.js ***! + \*********************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var classof = __webpack_require__(/*! ../internals/classof */ "../../node_modules/core-js/internals/classof.js"); + +var String = global.String; + +module.exports = function (argument) { + if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string'); + return String(argument); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/try-to-string.js": +/*!*************************************************************!*\ + !*** ../../node_modules/core-js/internals/try-to-string.js ***! + \*************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); + +var String = global.String; + +module.exports = function (argument) { + try { + return String(argument); + } catch (error) { + return 'Object'; + } +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/uid.js": +/*!***************************************************!*\ + !*** ../../node_modules/core-js/internals/uid.js ***! + \***************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); + +var id = 0; +var postfix = Math.random(); +var toString = uncurryThis(1.0.toString); + +module.exports = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36); +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/use-symbol-as-uid.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/use-symbol-as-uid.js ***! + \*****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +/* eslint-disable es/no-symbol -- required for testing */ +var NATIVE_SYMBOL = __webpack_require__(/*! ../internals/native-symbol */ "../../node_modules/core-js/internals/native-symbol.js"); + +module.exports = NATIVE_SYMBOL + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/well-known-symbol.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/internals/well-known-symbol.js ***! + \*****************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var shared = __webpack_require__(/*! ../internals/shared */ "../../node_modules/core-js/internals/shared.js"); +var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); +var uid = __webpack_require__(/*! ../internals/uid */ "../../node_modules/core-js/internals/uid.js"); +var NATIVE_SYMBOL = __webpack_require__(/*! ../internals/native-symbol */ "../../node_modules/core-js/internals/native-symbol.js"); +var USE_SYMBOL_AS_UID = __webpack_require__(/*! ../internals/use-symbol-as-uid */ "../../node_modules/core-js/internals/use-symbol-as-uid.js"); + +var WellKnownSymbolsStore = shared('wks'); +var Symbol = global.Symbol; +var symbolFor = Symbol && Symbol['for']; +var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid; + +module.exports = function (name) { + if (!hasOwn(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) { + var description = 'Symbol.' + name; + if (NATIVE_SYMBOL && hasOwn(Symbol, name)) { + WellKnownSymbolsStore[name] = Symbol[name]; + } else if (USE_SYMBOL_AS_UID && symbolFor) { + WellKnownSymbolsStore[name] = symbolFor(description); + } else { + WellKnownSymbolsStore[name] = createWellKnownSymbol(description); + } + } return WellKnownSymbolsStore[name]; +}; + + +/***/ }), + +/***/ "../../node_modules/core-js/internals/whitespaces.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/internals/whitespaces.js ***! + \***********************************************************/ +/***/ ((module) => { + +// a string of all valid unicode whitespaces +module.exports = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + + '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.aggregate-error.js": +/*!****************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.aggregate-error.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var isPrototypeOf = __webpack_require__(/*! ../internals/object-is-prototype-of */ "../../node_modules/core-js/internals/object-is-prototype-of.js"); +var getPrototypeOf = __webpack_require__(/*! ../internals/object-get-prototype-of */ "../../node_modules/core-js/internals/object-get-prototype-of.js"); +var setPrototypeOf = __webpack_require__(/*! ../internals/object-set-prototype-of */ "../../node_modules/core-js/internals/object-set-prototype-of.js"); +var copyConstructorProperties = __webpack_require__(/*! ../internals/copy-constructor-properties */ "../../node_modules/core-js/internals/copy-constructor-properties.js"); +var create = __webpack_require__(/*! ../internals/object-create */ "../../node_modules/core-js/internals/object-create.js"); +var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../../node_modules/core-js/internals/create-non-enumerable-property.js"); +var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "../../node_modules/core-js/internals/create-property-descriptor.js"); +var clearErrorStack = __webpack_require__(/*! ../internals/clear-error-stack */ "../../node_modules/core-js/internals/clear-error-stack.js"); +var installErrorCause = __webpack_require__(/*! ../internals/install-error-cause */ "../../node_modules/core-js/internals/install-error-cause.js"); +var iterate = __webpack_require__(/*! ../internals/iterate */ "../../node_modules/core-js/internals/iterate.js"); +var normalizeStringArgument = __webpack_require__(/*! ../internals/normalize-string-argument */ "../../node_modules/core-js/internals/normalize-string-argument.js"); +var ERROR_STACK_INSTALLABLE = __webpack_require__(/*! ../internals/error-stack-installable */ "../../node_modules/core-js/internals/error-stack-installable.js"); + +var Error = global.Error; +var push = [].push; + +var $AggregateError = function AggregateError(errors, message /* , options */) { + var that = isPrototypeOf(AggregateErrorPrototype, this) ? this : create(AggregateErrorPrototype); + var options = arguments.length > 2 ? arguments[2] : undefined; + if (setPrototypeOf) { + that = setPrototypeOf(new Error(undefined), getPrototypeOf(that)); + } + createNonEnumerableProperty(that, 'message', normalizeStringArgument(message, '')); + if (ERROR_STACK_INSTALLABLE) createNonEnumerableProperty(that, 'stack', clearErrorStack(that.stack, 1)); + installErrorCause(that, options); + var errorsArray = []; + iterate(errors, push, { that: errorsArray }); + createNonEnumerableProperty(that, 'errors', errorsArray); + return that; +}; + +if (setPrototypeOf) setPrototypeOf($AggregateError, Error); +else copyConstructorProperties($AggregateError, Error); + +var AggregateErrorPrototype = $AggregateError.prototype = create(Error.prototype, { + constructor: createPropertyDescriptor(1, $AggregateError), + message: createPropertyDescriptor(1, ''), + name: createPropertyDescriptor(1, 'AggregateError') +}); + +// `AggregateError` constructor +// https://tc39.es/ecma262/#sec-aggregate-error-constructor +$({ global: true }, { + AggregateError: $AggregateError +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.array.find.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/modules/es.array.find.js ***! + \***********************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var $find = (__webpack_require__(/*! ../internals/array-iteration */ "../../node_modules/core-js/internals/array-iteration.js").find); +var addToUnscopables = __webpack_require__(/*! ../internals/add-to-unscopables */ "../../node_modules/core-js/internals/add-to-unscopables.js"); + +var FIND = 'find'; +var SKIPS_HOLES = true; + +// Shouldn't skip holes +if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; }); + +// `Array.prototype.find` method +// https://tc39.es/ecma262/#sec-array.prototype.find +$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, { + find: function find(callbackfn /* , that = undefined */) { + return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables(FIND); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.array.from.js": +/*!***********************************************************!*\ + !*** ../../node_modules/core-js/modules/es.array.from.js ***! + \***********************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var from = __webpack_require__(/*! ../internals/array-from */ "../../node_modules/core-js/internals/array-from.js"); +var checkCorrectnessOfIteration = __webpack_require__(/*! ../internals/check-correctness-of-iteration */ "../../node_modules/core-js/internals/check-correctness-of-iteration.js"); + +var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { + // eslint-disable-next-line es/no-array-from -- required for testing + Array.from(iterable); +}); + +// `Array.from` method +// https://tc39.es/ecma262/#sec-array.from +$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { + from: from +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.array.iterator.js": +/*!***************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.array.iterator.js ***! + \***************************************************************/ +/***/ ((module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../../node_modules/core-js/internals/to-indexed-object.js"); +var addToUnscopables = __webpack_require__(/*! ../internals/add-to-unscopables */ "../../node_modules/core-js/internals/add-to-unscopables.js"); +var Iterators = __webpack_require__(/*! ../internals/iterators */ "../../node_modules/core-js/internals/iterators.js"); +var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "../../node_modules/core-js/internals/internal-state.js"); +var defineIterator = __webpack_require__(/*! ../internals/define-iterator */ "../../node_modules/core-js/internals/define-iterator.js"); + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.es/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.es/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.es/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.es/ecma262/#sec-createarrayiterator +module.exports = defineIterator(Array, 'Array', function (iterated, kind) { + setInternalState(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject(iterated), // target + index: 0, // next index + kind: kind // kind + }); +// `%ArrayIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState(this); + var target = state.target; + var kind = state.kind; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return { value: undefined, done: true }; + } + if (kind == 'keys') return { value: index, done: false }; + if (kind == 'values') return { value: target[index], done: false }; + return { value: [index, target[index]], done: false }; +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.es/ecma262/#sec-createunmappedargumentsobject +// https://tc39.es/ecma262/#sec-createmappedargumentsobject +Iterators.Arguments = Iterators.Array; + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.map.js": +/*!****************************************************!*\ + !*** ../../node_modules/core-js/modules/es.map.js ***! + \****************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var collection = __webpack_require__(/*! ../internals/collection */ "../../node_modules/core-js/internals/collection.js"); +var collectionStrong = __webpack_require__(/*! ../internals/collection-strong */ "../../node_modules/core-js/internals/collection-strong.js"); + +// `Map` constructor +// https://tc39.es/ecma262/#sec-map-objects +collection('Map', function (init) { + return function Map() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionStrong); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.number.is-integer.js": +/*!******************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.number.is-integer.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var isIntegralNumber = __webpack_require__(/*! ../internals/is-integral-number */ "../../node_modules/core-js/internals/is-integral-number.js"); + +// `Number.isInteger` method +// https://tc39.es/ecma262/#sec-number.isinteger +$({ target: 'Number', stat: true }, { + isInteger: isIntegralNumber +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.number.is-nan.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.number.is-nan.js ***! + \**************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); + +// `Number.isNaN` method +// https://tc39.es/ecma262/#sec-number.isnan +$({ target: 'Number', stat: true }, { + isNaN: function isNaN(number) { + // eslint-disable-next-line no-self-compare -- NaN check + return number != number; + } +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.number.parse-float.js": +/*!*******************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.number.parse-float.js ***! + \*******************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var parseFloat = __webpack_require__(/*! ../internals/number-parse-float */ "../../node_modules/core-js/internals/number-parse-float.js"); + +// `Number.parseFloat` method +// https://tc39.es/ecma262/#sec-number.parseFloat +// eslint-disable-next-line es/no-number-parsefloat -- required for testing +$({ target: 'Number', stat: true, forced: Number.parseFloat != parseFloat }, { + parseFloat: parseFloat +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.number.parse-int.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.number.parse-int.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var parseInt = __webpack_require__(/*! ../internals/number-parse-int */ "../../node_modules/core-js/internals/number-parse-int.js"); + +// `Number.parseInt` method +// https://tc39.es/ecma262/#sec-number.parseint +// eslint-disable-next-line es/no-number-parseint -- required for testing +$({ target: 'Number', stat: true, forced: Number.parseInt != parseInt }, { + parseInt: parseInt +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.object.assign.js": +/*!**************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.object.assign.js ***! + \**************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var assign = __webpack_require__(/*! ../internals/object-assign */ "../../node_modules/core-js/internals/object-assign.js"); + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +// eslint-disable-next-line es/no-object-assign -- required for testing +$({ target: 'Object', stat: true, forced: Object.assign !== assign }, { + assign: assign +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.object.entries.js": +/*!***************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.object.entries.js ***! + \***************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var $entries = (__webpack_require__(/*! ../internals/object-to-array */ "../../node_modules/core-js/internals/object-to-array.js").entries); + +// `Object.entries` method +// https://tc39.es/ecma262/#sec-object.entries +$({ target: 'Object', stat: true }, { + entries: function entries(O) { + return $entries(O); + } +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.object.set-prototype-of.js": +/*!************************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.object.set-prototype-of.js ***! + \************************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var setPrototypeOf = __webpack_require__(/*! ../internals/object-set-prototype-of */ "../../node_modules/core-js/internals/object-set-prototype-of.js"); + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +$({ target: 'Object', stat: true }, { + setPrototypeOf: setPrototypeOf +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.object.to-string.js": +/*!*****************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.object.to-string.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +var TO_STRING_TAG_SUPPORT = __webpack_require__(/*! ../internals/to-string-tag-support */ "../../node_modules/core-js/internals/to-string-tag-support.js"); +var redefine = __webpack_require__(/*! ../internals/redefine */ "../../node_modules/core-js/internals/redefine.js"); +var toString = __webpack_require__(/*! ../internals/object-to-string */ "../../node_modules/core-js/internals/object-to-string.js"); + +// `Object.prototype.toString` method +// https://tc39.es/ecma262/#sec-object.prototype.tostring +if (!TO_STRING_TAG_SUPPORT) { + redefine(Object.prototype, 'toString', toString, { unsafe: true }); +} + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.promise.all-settled.js": +/*!********************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.promise.all-settled.js ***! + \********************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var aCallable = __webpack_require__(/*! ../internals/a-callable */ "../../node_modules/core-js/internals/a-callable.js"); +var newPromiseCapabilityModule = __webpack_require__(/*! ../internals/new-promise-capability */ "../../node_modules/core-js/internals/new-promise-capability.js"); +var perform = __webpack_require__(/*! ../internals/perform */ "../../node_modules/core-js/internals/perform.js"); +var iterate = __webpack_require__(/*! ../internals/iterate */ "../../node_modules/core-js/internals/iterate.js"); + +// `Promise.allSettled` method +// https://tc39.es/ecma262/#sec-promise.allsettled +$({ target: 'Promise', stat: true }, { + allSettled: function allSettled(iterable) { + var C = this; + var capability = newPromiseCapabilityModule.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aCallable(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call(promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'fulfilled', value: value }; + --remaining || resolve(values); + }, function (error) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'rejected', reason: error }; + --remaining || resolve(values); + }); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.promise.any.js": +/*!************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.promise.any.js ***! + \************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var aCallable = __webpack_require__(/*! ../internals/a-callable */ "../../node_modules/core-js/internals/a-callable.js"); +var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../../node_modules/core-js/internals/get-built-in.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var newPromiseCapabilityModule = __webpack_require__(/*! ../internals/new-promise-capability */ "../../node_modules/core-js/internals/new-promise-capability.js"); +var perform = __webpack_require__(/*! ../internals/perform */ "../../node_modules/core-js/internals/perform.js"); +var iterate = __webpack_require__(/*! ../internals/iterate */ "../../node_modules/core-js/internals/iterate.js"); + +var PROMISE_ANY_ERROR = 'No one promise resolved'; + +// `Promise.any` method +// https://tc39.es/ecma262/#sec-promise.any +$({ target: 'Promise', stat: true }, { + any: function any(iterable) { + var C = this; + var AggregateError = getBuiltIn('AggregateError'); + var capability = newPromiseCapabilityModule.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aCallable(C.resolve); + var errors = []; + var counter = 0; + var remaining = 1; + var alreadyResolved = false; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyRejected = false; + remaining++; + call(promiseResolve, C, promise).then(function (value) { + if (alreadyRejected || alreadyResolved) return; + alreadyResolved = true; + resolve(value); + }, function (error) { + if (alreadyRejected || alreadyResolved) return; + alreadyRejected = true; + errors[index] = error; + --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR)); + }); + }); + --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR)); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.promise.finally.js": +/*!****************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.promise.finally.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ "../../node_modules/core-js/internals/is-pure.js"); +var NativePromise = __webpack_require__(/*! ../internals/native-promise-constructor */ "../../node_modules/core-js/internals/native-promise-constructor.js"); +var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); +var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../../node_modules/core-js/internals/get-built-in.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var speciesConstructor = __webpack_require__(/*! ../internals/species-constructor */ "../../node_modules/core-js/internals/species-constructor.js"); +var promiseResolve = __webpack_require__(/*! ../internals/promise-resolve */ "../../node_modules/core-js/internals/promise-resolve.js"); +var redefine = __webpack_require__(/*! ../internals/redefine */ "../../node_modules/core-js/internals/redefine.js"); + +// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829 +var NON_GENERIC = !!NativePromise && fails(function () { + NativePromise.prototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ }); +}); + +// `Promise.prototype.finally` method +// https://tc39.es/ecma262/#sec-promise.prototype.finally +$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, { + 'finally': function (onFinally) { + var C = speciesConstructor(this, getBuiltIn('Promise')); + var isFunction = isCallable(onFinally); + return this.then( + isFunction ? function (x) { + return promiseResolve(C, onFinally()).then(function () { return x; }); + } : onFinally, + isFunction ? function (e) { + return promiseResolve(C, onFinally()).then(function () { throw e; }); + } : onFinally + ); + } +}); + +// makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then` +if (!IS_PURE && isCallable(NativePromise)) { + var method = getBuiltIn('Promise').prototype['finally']; + if (NativePromise.prototype['finally'] !== method) { + redefine(NativePromise.prototype, 'finally', method, { unsafe: true }); + } +} + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.promise.js": +/*!********************************************************!*\ + !*** ../../node_modules/core-js/modules/es.promise.js ***! + \********************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); +var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ "../../node_modules/core-js/internals/is-pure.js"); +var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); +var getBuiltIn = __webpack_require__(/*! ../internals/get-built-in */ "../../node_modules/core-js/internals/get-built-in.js"); +var call = __webpack_require__(/*! ../internals/function-call */ "../../node_modules/core-js/internals/function-call.js"); +var NativePromise = __webpack_require__(/*! ../internals/native-promise-constructor */ "../../node_modules/core-js/internals/native-promise-constructor.js"); +var redefine = __webpack_require__(/*! ../internals/redefine */ "../../node_modules/core-js/internals/redefine.js"); +var redefineAll = __webpack_require__(/*! ../internals/redefine-all */ "../../node_modules/core-js/internals/redefine-all.js"); +var setPrototypeOf = __webpack_require__(/*! ../internals/object-set-prototype-of */ "../../node_modules/core-js/internals/object-set-prototype-of.js"); +var setToStringTag = __webpack_require__(/*! ../internals/set-to-string-tag */ "../../node_modules/core-js/internals/set-to-string-tag.js"); +var setSpecies = __webpack_require__(/*! ../internals/set-species */ "../../node_modules/core-js/internals/set-species.js"); +var aCallable = __webpack_require__(/*! ../internals/a-callable */ "../../node_modules/core-js/internals/a-callable.js"); +var isCallable = __webpack_require__(/*! ../internals/is-callable */ "../../node_modules/core-js/internals/is-callable.js"); +var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); +var anInstance = __webpack_require__(/*! ../internals/an-instance */ "../../node_modules/core-js/internals/an-instance.js"); +var inspectSource = __webpack_require__(/*! ../internals/inspect-source */ "../../node_modules/core-js/internals/inspect-source.js"); +var iterate = __webpack_require__(/*! ../internals/iterate */ "../../node_modules/core-js/internals/iterate.js"); +var checkCorrectnessOfIteration = __webpack_require__(/*! ../internals/check-correctness-of-iteration */ "../../node_modules/core-js/internals/check-correctness-of-iteration.js"); +var speciesConstructor = __webpack_require__(/*! ../internals/species-constructor */ "../../node_modules/core-js/internals/species-constructor.js"); +var task = (__webpack_require__(/*! ../internals/task */ "../../node_modules/core-js/internals/task.js").set); +var microtask = __webpack_require__(/*! ../internals/microtask */ "../../node_modules/core-js/internals/microtask.js"); +var promiseResolve = __webpack_require__(/*! ../internals/promise-resolve */ "../../node_modules/core-js/internals/promise-resolve.js"); +var hostReportErrors = __webpack_require__(/*! ../internals/host-report-errors */ "../../node_modules/core-js/internals/host-report-errors.js"); +var newPromiseCapabilityModule = __webpack_require__(/*! ../internals/new-promise-capability */ "../../node_modules/core-js/internals/new-promise-capability.js"); +var perform = __webpack_require__(/*! ../internals/perform */ "../../node_modules/core-js/internals/perform.js"); +var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "../../node_modules/core-js/internals/internal-state.js"); +var isForced = __webpack_require__(/*! ../internals/is-forced */ "../../node_modules/core-js/internals/is-forced.js"); +var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); +var IS_BROWSER = __webpack_require__(/*! ../internals/engine-is-browser */ "../../node_modules/core-js/internals/engine-is-browser.js"); +var IS_NODE = __webpack_require__(/*! ../internals/engine-is-node */ "../../node_modules/core-js/internals/engine-is-node.js"); +var V8_VERSION = __webpack_require__(/*! ../internals/engine-v8-version */ "../../node_modules/core-js/internals/engine-v8-version.js"); + +var SPECIES = wellKnownSymbol('species'); +var PROMISE = 'Promise'; + +var getInternalState = InternalStateModule.get; +var setInternalState = InternalStateModule.set; +var getInternalPromiseState = InternalStateModule.getterFor(PROMISE); +var NativePromisePrototype = NativePromise && NativePromise.prototype; +var PromiseConstructor = NativePromise; +var PromisePrototype = NativePromisePrototype; +var TypeError = global.TypeError; +var document = global.document; +var process = global.process; +var newPromiseCapability = newPromiseCapabilityModule.f; +var newGenericPromiseCapability = newPromiseCapability; + +var DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent); +var NATIVE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent); +var UNHANDLED_REJECTION = 'unhandledrejection'; +var REJECTION_HANDLED = 'rejectionhandled'; +var PENDING = 0; +var FULFILLED = 1; +var REJECTED = 2; +var HANDLED = 1; +var UNHANDLED = 2; +var SUBCLASSING = false; + +var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + +var FORCED = isForced(PROMISE, function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true; + // We need Promise#finally in the pure version for preventing prototype pollution + if (IS_PURE && !PromisePrototype['finally']) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (V8_VERSION >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false; + // Detect correctness of subclassing with @@species support + var promise = new PromiseConstructor(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT; +}); + +var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) { + PromiseConstructor.all(iterable)['catch'](function () { /* empty */ }); +}); + +// helpers +var isThenable = function (it) { + var then; + return isObject(it) && isCallable(then = it.then) ? then : false; +}; + +var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + var chain = state.reactions; + microtask(function () { + var value = state.value; + var ok = state.state == FULFILLED; + var index = 0; + // variable length - can't use forEach + while (chain.length > index) { + var reaction = chain[index++]; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(TypeError('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } + } + state.reactions = []; + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); +}; + +var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_REJECTION_EVENT && (handler = global['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); +}; + +var onUnhandled = function (state) { + call(task, global, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); +}; + +var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; +}; + +var onHandleUnhandled = function (state) { + call(task, global, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); +}; + +var bind = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; +}; + +var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); +}; + +var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw TypeError("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call(then, value, + bind(internalResolve, wrapper, state), + bind(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } +}; + +// constructor polyfill +if (FORCED) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance(this, PromisePrototype); + aCallable(executor); + call(Internal, this); + var state = getInternalState(this); + try { + executor(bind(internalResolve, state), bind(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + PromisePrototype = PromiseConstructor.prototype; + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: [], + rejection: false, + state: PENDING, + value: undefined + }); + }; + Internal.prototype = redefineAll(PromisePrototype, { + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + then: function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reactions = state.reactions; + var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor)); + reaction.ok = isCallable(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + state.parent = true; + reactions[reactions.length] = reaction; + if (state.state != PENDING) notify(state, false); + return reaction.promise; + }, + // `Promise.prototype.catch` method + // https://tc39.es/ecma262/#sec-promise.prototype.catch + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalState(promise); + this.promise = promise; + this.resolve = bind(internalResolve, state); + this.reject = bind(internalReject, state); + }; + newPromiseCapabilityModule.f = newPromiseCapability = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (!IS_PURE && isCallable(NativePromise) && NativePromisePrototype !== Object.prototype) { + nativeThen = NativePromisePrototype.then; + + if (!SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + redefine(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + + // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` + redefine(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf) { + setPrototypeOf(NativePromisePrototype, PromisePrototype); + } + } +} + +$({ global: true, wrap: true, forced: FORCED }, { + Promise: PromiseConstructor +}); + +setToStringTag(PromiseConstructor, PROMISE, false, true); +setSpecies(PROMISE); + +PromiseWrapper = getBuiltIn(PROMISE); + +// statics +$({ target: PROMISE, stat: true, forced: FORCED }, { + // `Promise.reject` method + // https://tc39.es/ecma262/#sec-promise.reject + reject: function reject(r) { + var capability = newPromiseCapability(this); + call(capability.reject, undefined, r); + return capability.promise; + } +}); + +$({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, { + // `Promise.resolve` method + // https://tc39.es/ecma262/#sec-promise.resolve + resolve: function resolve(x) { + return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x); + } +}); + +$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, { + // `Promise.all` method + // https://tc39.es/ecma262/#sec-promise.all + all: function all(iterable) { + var C = this; + var capability = newPromiseCapability(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aCallable(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + }, + // `Promise.race` method + // https://tc39.es/ecma262/#sec-promise.race + race: function race(iterable) { + var C = this; + var capability = newPromiseCapability(C); + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aCallable(C.resolve); + iterate(iterable, function (promise) { + call($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + + +/***/ }), + +/***/ "../../node_modules/core-js/modules/es.string.iterator.js": +/*!****************************************************************!*\ + !*** ../../node_modules/core-js/modules/es.string.iterator.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { + +"use strict"; + +var charAt = (__webpack_require__(/*! ../internals/string-multibyte */ "../../node_modules/core-js/internals/string-multibyte.js").charAt); +var toString = __webpack_require__(/*! ../internals/to-string */ "../../node_modules/core-js/internals/to-string.js"); +var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "../../node_modules/core-js/internals/internal-state.js"); +var defineIterator = __webpack_require__(/*! ../internals/define-iterator */ "../../node_modules/core-js/internals/define-iterator.js"); + +var STRING_ITERATOR = 'String Iterator'; +var setInternalState = InternalStateModule.set; +var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-string.prototype-@@iterator +defineIterator(String, 'String', function (iterated) { + setInternalState(this, { + type: STRING_ITERATOR, + string: toString(iterated), + index: 0 + }); +// `%StringIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next +}, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return { value: undefined, done: true }; + point = charAt(string, index); + state.index += point.length; + return { value: point, done: false }; +}); + + +/***/ }), + +/***/ "../../node_modules/guid/guid.js": +/*!***************************************!*\ + !*** ../../node_modules/guid/guid.js ***! + \***************************************/ +/***/ ((module) => { + +(function () { + var validator = new RegExp("^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$", "i"); + + function gen(count) { + var out = ""; + for (var i=0; i { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var TableauEvent = /** @class */ (function () { + function TableauEvent(type) { + this._type = type; + } + Object.defineProperty(TableauEvent.prototype, "type", { + get: function () { + return this._type; + }, + enumerable: true, + configurable: true + }); + return TableauEvent; +}()); +exports.TableauEvent = TableauEvent; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Events/TableauSheetEvent.js": +/*!***********************************************************!*\ + !*** ./lib/src/ExtensionsApi/Events/TableauSheetEvent.js ***! + \***********************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var TableauEvent_1 = __webpack_require__(/*! ./TableauEvent */ "./lib/src/ExtensionsApi/Events/TableauEvent.js"); +var TableauSheetEvent = /** @class */ (function (_super) { + __extends(TableauSheetEvent, _super); + function TableauSheetEvent(type, sheet) { + var _this = _super.call(this, type) || this; + _this._sheet = sheet; + return _this; + } + Object.defineProperty(TableauSheetEvent.prototype, "sheet", { + get: function () { + return this._sheet; + }, + enumerable: true, + configurable: true + }); + return TableauSheetEvent; +}(TableauEvent_1.TableauEvent)); +exports.TableauSheetEvent = TableauSheetEvent; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Events/TableauWorksheetEvent.js": +/*!***************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Events/TableauWorksheetEvent.js ***! + \***************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var TableauSheetEvent_1 = __webpack_require__(/*! ./TableauSheetEvent */ "./lib/src/ExtensionsApi/Events/TableauSheetEvent.js"); +var TableauWorksheetEvent = /** @class */ (function (_super) { + __extends(TableauWorksheetEvent, _super); + function TableauWorksheetEvent(type, _worksheet) { + var _this = _super.call(this, type, _worksheet) || this; + _this._worksheet = _worksheet; + return _this; + } + Object.defineProperty(TableauWorksheetEvent.prototype, "worksheet", { + get: function () { + return this._worksheet; + }, + enumerable: true, + configurable: true + }); + return TableauWorksheetEvent; +}(TableauSheetEvent_1.TableauSheetEvent)); +exports.TableauWorksheetEvent = TableauWorksheetEvent; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Events/WorkbookFormattingChangedEvent.js": +/*!************************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Events/WorkbookFormattingChangedEvent.js ***! + \************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var TableauEvent_1 = __webpack_require__(/*! ./TableauEvent */ "./lib/src/ExtensionsApi/Events/TableauEvent.js"); +var WorkbookFormattingChangedEvent = /** @class */ (function (_super) { + __extends(WorkbookFormattingChangedEvent, _super); + function WorkbookFormattingChangedEvent(_formatting) { + var _this = _super.call(this, Contract.TableauEventType.WorkbookFormattingChanged) || this; + _this._formatting = _formatting; + return _this; + } + Object.defineProperty(WorkbookFormattingChangedEvent.prototype, "formatting", { + get: function () { + return this._formatting; + }, + enumerable: true, + configurable: true + }); + return WorkbookFormattingChangedEvent; +}(TableauEvent_1.TableauEvent)); +exports.WorkbookFormattingChangedEvent = WorkbookFormattingChangedEvent; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Impl/BentonSansFontNameConstants.js": +/*!*******************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Impl/BentonSansFontNameConstants.js ***! + \*******************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.BentonSansFontFamilyName = 'Benton Sans'; +exports.BentonSansLowDPIFontFamilyName = 'Benton Sans Low-DPI'; +exports.BentonSansBookFontFaceName = 'Benton Sans Book'; +exports.BentonSansBookItalicFontFaceName = 'Benton Sans Book Italic'; +exports.BentonSansSemiDemiFontFaceName = 'Benton Sans SemiDemi'; +exports.BentonSansSemiDemiItalicFontFaceName = 'Benton Sans SemiDemi Italic'; +exports.BentonSansLightFontFaceName = 'Benton Sans Light'; +exports.BentonSansMediumFontFaceName = 'Benton Sans Medium'; +exports.SupportedBentonSansFontFaces = [ + exports.BentonSansBookFontFaceName, + exports.BentonSansBookItalicFontFaceName, + exports.BentonSansSemiDemiFontFaceName, + exports.BentonSansSemiDemiItalicFontFaceName, + exports.BentonSansLightFontFaceName, + exports.BentonSansMediumFontFaceName, +]; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Impl/ConnectedServer.js": +/*!*******************************************************!*\ + !*** ./lib/src/ExtensionsApi/Impl/ConnectedServer.js ***! + \*******************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var ConnectedServer = /** @class */ (function () { + function ConnectedServer(_userId, _siteId, _siteNamespace, _workbookId) { + this._userId = _userId; + this._siteId = _siteId; + this._siteNamespace = _siteNamespace; + this._workbookId = _workbookId; + } + Object.defineProperty(ConnectedServer.prototype, "userId", { + get: function () { + return this._userId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ConnectedServer.prototype, "siteId", { + get: function () { + return this._siteId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ConnectedServer.prototype, "siteNamespace", { + get: function () { + return this._siteNamespace; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ConnectedServer.prototype, "workbookId", { + get: function () { + return this._workbookId; + }, + enumerable: true, + configurable: true + }); + return ConnectedServer; +}()); +exports.ConnectedServer = ConnectedServer; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Impl/ExtensionWorkbookImpl.js": +/*!*************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Impl/ExtensionWorkbookImpl.js ***! + \*************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var ServiceRegistryUtil_1 = __webpack_require__(/*! ../Services/ServiceRegistryUtil */ "./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js"); +var ExtensionWorkbookImpl = /** @class */ (function (_super) { + __extends(ExtensionWorkbookImpl, _super); + function ExtensionWorkbookImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + ExtensionWorkbookImpl.prototype.getAllDataSourcesAsync = function () { + var _this = this; + var service = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("data-source-service" /* DataSourceService */); + return service.getAllDataSourcesAsync().then(function (result) { + var dataSchema = result; + var dataSources = []; + // Loop through all data sources and add them. + Object.values(dataSchema.dataSources).forEach(function (ds) { + dataSources.push(_this.createDataSourceFromInfo(ds)); + }); + return dataSources; + }); + }; + ExtensionWorkbookImpl.prototype.createDataSourceFromInfo = function (dataSourceInfo) { + var dataSourceImpl = new api_shared_js_1.DataSourceImpl(dataSourceInfo, ServiceRegistryUtil_1.ExtensionsRegistryId); + var dataSource = new api_shared_js_1.DataSource(dataSourceImpl); + dataSourceImpl.initializeWithPublicInterfaces(dataSource); + return dataSource; + }; + return ExtensionWorkbookImpl; +}(api_shared_js_1.WorkbookImpl)); +exports.ExtensionWorkbookImpl = ExtensionWorkbookImpl; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Impl/ExtensionsImpl.js": +/*!******************************************************!*\ + !*** ./lib/src/ExtensionsApi/Impl/ExtensionsImpl.js ***! + \******************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __spreadArrays = (this && this.__spreadArrays) || function () { + for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; + for (var r = Array(s), k = 0, i = 0; i < il; i++) + for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) + r[k] = a[j]; + return r; +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var Dashboard_1 = __webpack_require__(/*! ../Models/Dashboard */ "./lib/src/ExtensionsApi/Models/Dashboard.js"); +var Workbook_1 = __webpack_require__(/*! ../Models/Workbook */ "./lib/src/ExtensionsApi/Models/Workbook.js"); +var Worksheet_1 = __webpack_require__(/*! ../Models/Worksheet */ "./lib/src/ExtensionsApi/Models/Worksheet.js"); +var DashboardContent_1 = __webpack_require__(/*! ../Namespaces/DashboardContent */ "./lib/src/ExtensionsApi/Namespaces/DashboardContent.js"); +var Environment_1 = __webpack_require__(/*! ../Namespaces/Environment */ "./lib/src/ExtensionsApi/Namespaces/Environment.js"); +var Settings_1 = __webpack_require__(/*! ../Namespaces/Settings */ "./lib/src/ExtensionsApi/Namespaces/Settings.js"); +var UI_1 = __webpack_require__(/*! ../Namespaces/UI */ "./lib/src/ExtensionsApi/Namespaces/UI.js"); +var WorksheetContent_1 = __webpack_require__(/*! ../Namespaces/WorksheetContent */ "./lib/src/ExtensionsApi/Namespaces/WorksheetContent.js"); +var RegisterAllExtensionsServices_1 = __webpack_require__(/*! ../Services/RegisterAllExtensionsServices */ "./lib/src/ExtensionsApi/Services/RegisterAllExtensionsServices.js"); +var ServiceRegistryUtil_1 = __webpack_require__(/*! ../Services/ServiceRegistryUtil */ "./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js"); +var BentonSansFontNameConstants_1 = __webpack_require__(/*! ./BentonSansFontNameConstants */ "./lib/src/ExtensionsApi/Impl/BentonSansFontNameConstants.js"); +var ExtensionWorkbookImpl_1 = __webpack_require__(/*! ./ExtensionWorkbookImpl */ "./lib/src/ExtensionsApi/Impl/ExtensionWorkbookImpl.js"); +var LegacyInternalApiDispatcherHolder_1 = __webpack_require__(/*! ./LegacyInternalApiDispatcherHolder */ "./lib/src/ExtensionsApi/Impl/LegacyInternalApiDispatcherHolder.js"); +var SettingsImpl_1 = __webpack_require__(/*! ./SettingsImpl */ "./lib/src/ExtensionsApi/Impl/SettingsImpl.js"); +var TableauBookFontNameConstants_1 = __webpack_require__(/*! ./TableauBookFontNameConstants */ "./lib/src/ExtensionsApi/Impl/TableauBookFontNameConstants.js"); +var UIImpl_1 = __webpack_require__(/*! ./UIImpl */ "./lib/src/ExtensionsApi/Impl/UIImpl.js"); +var ExtensionsImpl = /** @class */ (function () { + function ExtensionsImpl() { + } + ExtensionsImpl.prototype.initializeAsync = function (isExtensionDialog, contextMenuCallbacks) { + var _this = this; + if (!this._initializationPromise) { + this._initializationPromise = new Promise(function (resolve, reject) { + var _a; + var initOptions = { isAlpha: api_shared_js_1.ApiVersion.Instance.isAlpha }; + // First thing we want to do is check to see if there is a desktop dispatcher already registered for us + if (LegacyInternalApiDispatcherHolder_1.LegacyInternalApiDispatcherHolder.hasDesktopApiDispatcherPromise(initOptions)) { + // Running in a pre-2019.3 desktop, use our legacy dispatcher promise + var desktopDispatcherPromise = LegacyInternalApiDispatcherHolder_1.LegacyInternalApiDispatcherHolder.getDesktopDispatcherPromise(initOptions); + (_a = desktopDispatcherPromise) === null || _a === void 0 ? void 0 : _a.then(function (dispatcherFactory) { return _this.onDispatcherReceived(dispatcherFactory, isExtensionDialog, contextMenuCallbacks); }).then(function (openPayload) { + resolve(openPayload); + }).catch(function (error) { + reject(error); + }); + } + else { + // We must be running in server, so we should try to kick of the server dispatcher bootstrapping + var onDispatcherReceivedCallback_1 = _this.onDispatcherReceived.bind(_this); + api_shared_js_1.doCrossFrameBootstrap(window, api_internal_contract_js_1.INTERNAL_CONTRACT_VERSION, initOptions) + .then(function (factory) { + return onDispatcherReceivedCallback_1(factory, isExtensionDialog, contextMenuCallbacks); + }) + .then(function (openPayload) { + resolve(openPayload); + }) + .catch(function (error) { + reject(error); + }); + } + }); + } + return this._initializationPromise; + }; + ExtensionsImpl.prototype.createVizImageAsync = function (inputSpec) { + var vizService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("viz-service" /* Viz */); + return vizService.createVizImageAsync(inputSpec); + }; + ExtensionsImpl.prototype.setClickThroughAsync = function (clickThroughEnabled) { + var uiService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("UIService" /* UIService */); + return uiService.setClickThroughAsync(clickThroughEnabled, this.extensionZoneId); + }; + ExtensionsImpl.prototype.isDashboardExtensionLocator = function (locator) { + var dashboardExtensionLocator = locator; + if (!dashboardExtensionLocator.dashboardPath) { + throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, 'Unexpected error during initialization.'); + } + return true; + }; + ExtensionsImpl.prototype.onDispatcherReceived = function (dispatcherFactory, isExtensionDialog, contextMenuFunctions) { + var _this = this; + var dispatcher = dispatcherFactory(api_internal_contract_js_1.INTERNAL_CONTRACT_VERSION); + // Call to register all the services which will use the newly initialized dispatcher + RegisterAllExtensionsServices_1.registerInitializationExtensionsServices(dispatcher); + // Get the initialization service and initialize this extension + var initializationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("InitializationService" /* InitializationService */); + var callbackMapKeys = contextMenuFunctions ? Object.keys(contextMenuFunctions) : []; + return initializationService.initializeDashboardExtensionsAsync(isExtensionDialog, callbackMapKeys).then(function (result) { + // If we receive an invalid plaform version, this means that platform is runnning 1.4 or 2.1 and + // doesn't pass the platform version to external. In this case we assume the platform version to be 1.9 + var platformVersion = result.extensionEnvironment.platformVersion + ? result.extensionEnvironment.platformVersion + : { major: 1, minor: 9, fix: 0 }; + // Wrap our existing dispatcher in a dispatcher that can downgrade/upgrade for an older platform. + if (api_shared_js_1.VersionedExternalApiDispatcher.needsVersionConverter(platformVersion)) { + dispatcher = new api_shared_js_1.VersionedExternalApiDispatcher(dispatcher, platformVersion); + } + // Registration of services must happen before initializing content and environment + // Extensions doesn't need to pass in a registryId. By default, the service registry instance is associated with registryId=0. + api_shared_js_1.registerAllSharedServices(dispatcher, ServiceRegistryUtil_1.ExtensionsRegistryId, platformVersion); + RegisterAllExtensionsServices_1.registerAllExtensionsServices(dispatcher); + if (result.extensionDashboardInfo && _this.isDashboardExtensionLocator(result.extensionInstance.locator)) { + _this.dashboardContent = _this.initializeDashboardContent(result.extensionDashboardInfo, result.extensionInstance.locator.dashboardPath); + _this.extensionZoneId = result.extensionDashboardInfo.extensionZoneId; + } + if (result.extensionWorksheetInfo) { + _this.worksheetContent = _this.initializeWorksheetContent(result.extensionWorksheetInfo); + } + _this.environment = new Environment_1.Environment(result.extensionEnvironment); + _this.settings = _this.initializeSettings(result.extensionSettingsInfo); + _this.ui = new UI_1.UI(new UIImpl_1.UIImpl()); + _this.workbook = new Workbook_1.Workbook(new ExtensionWorkbookImpl_1.ExtensionWorkbookImpl()); + if (result.extensionEnvironment.workbookFormatting) { + _this.initializeTableauFonts(dispatcher, result.extensionEnvironment.workbookFormatting); + _this.applyAllFormatting(result.extensionEnvironment.workbookFormatting); + } + // After initialization has completed, setup listeners for the callback functions that + // are meant to be triggered whenever a context menu item is clicked. + _this.initializeContextMenuCallbacks(contextMenuFunctions); + // Also set up listeners for ExtensionStylesChangedEvent + _this.initializeWorkbookFormattingChangedEventCallback(dispatcher); + // In the normal initialization case, this will be an empty string. When returning from initializeAsync to the + // developer, we just ingore that string. In the case of initializing from an extension dialog, this string + // is an optional payload sent from the parent extension. + return result.extensionDialogPayload; + }); + }; + ExtensionsImpl.prototype.applyAllFormatting = function (formattingModel) { + var _this = this; + if (!this._styleElement) { + this._styleElement = document.createElement('style'); + this._styleElement.id = 'Tableau-Extension-Formatting'; + document.head.appendChild(this._styleElement); + } + if (!this._styleElement.sheet || !formattingModel) { + return; + } + var stylesheet = this._styleElement.sheet; + while (stylesheet.cssRules.length > 0) { + stylesheet.deleteRule(stylesheet.cssRules.length - 1); + } + formattingModel.formattingSheets.map(function (currentFormattingSheet) { + _this.applyFormattingSheetToStyleSheet(currentFormattingSheet, stylesheet); + }); + }; + ExtensionsImpl.prototype.applyFormattingSheetToStyleSheet = function (currentFormattingSheet, stylesheet) { + var styleInfo = ''; + var cssProperties = currentFormattingSheet.cssProperties; + if (cssProperties.fontFamily) { + styleInfo += 'font-family: ' + cssProperties.fontFamily.toString() + '; '; + } + if (cssProperties.fontSize) { + styleInfo += 'font-size: ' + cssProperties.fontSize.toString() + '; '; + } + if (cssProperties.fontWeight) { + styleInfo += 'font-weight: ' + cssProperties.fontWeight.toString() + '; '; + } + if (cssProperties.fontStyle) { + styleInfo += 'font-style: ' + cssProperties.fontStyle.toString() + '; '; + } + if (cssProperties.textDecoration) { + styleInfo += 'text-decoration: ' + cssProperties.textDecoration.toString() + '; '; + } + if (cssProperties.color) { + styleInfo += 'color: ' + cssProperties.color + '; '; + } + var selector = '.' + currentFormattingSheet.classNameKey; + var rule = selector + ' { ' + styleInfo + ' }'; + stylesheet.insertRule(rule, stylesheet.cssRules.length); + }; + ExtensionsImpl.prototype.initializeWorkbookFormattingChangedEventCallback = function (dispatcher) { + var _this = this; + var notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("notification-service" /* Notification */); + // Unregister function not used since these notifications should be + // observed for the full lifetime of the extension. + notificationService.registerHandler(api_internal_contract_js_1.NotificationId.WorkbookFormattingChanged, function () { return true; }, function (eventFormatting) { + if (eventFormatting) { + _this.initializeTableauFonts(dispatcher, eventFormatting); + _this.applyAllFormatting(eventFormatting); + } + }); + }; + ExtensionsImpl.prototype.initializeTableauFonts = function (dispatcher, workbookFormatting) { + var _a; + var _this = this; + var fontNames = __spreadArrays(BentonSansFontNameConstants_1.SupportedBentonSansFontFaces, TableauBookFontNameConstants_1.SupportedTableauFontFaces); + workbookFormatting.formattingSheets.forEach(function (formattingSheet) { + if (formattingSheet.cssProperties.fontFamily) { + fontNames.push(formattingSheet.cssProperties.fontFamily); + } + }); + if (fontNames.length > 0) { + var parameters = (_a = {}, _a[api_internal_contract_js_1.ParameterId.FontNameListItems] = fontNames, _a); + dispatcher + .execute(api_internal_contract_js_1.VerbId.GetFonts, parameters) + .then(function (response) { + _this.loadFonts(response.result); + }) + .catch(); + } + }; + ExtensionsImpl.prototype.loadFonts = function (fonts) { + var _this = this; + fonts.forEach(function (fontNameAndInfo) { + if (TableauBookFontNameConstants_1.SupportedTableauFontFaces.includes(fontNameAndInfo.fontName)) { + _this.loadTableauFonts(fontNameAndInfo); + } + else if (BentonSansFontNameConstants_1.SupportedBentonSansFontFaces.includes(fontNameAndInfo.fontName)) { + _this.loadBentonSansFonts(fontNameAndInfo); + } + else { + document.fonts.add(new FontFace(fontNameAndInfo.fontName, fontNameAndInfo.fontBinaryInfo)); + } + }); + }; + ExtensionsImpl.prototype.initializeDashboardContent = function (info, sheetPath) { + // sheets are always active for Extensions + var sheetInfoImpl = new api_shared_js_1.SheetInfoImpl(info.name, api_external_contract_js_1.SheetType.Dashboard, { width: info.size.w, height: info.size.h }, undefined, true); + var dashboardImpl = new api_shared_js_1.DashboardImpl(sheetInfoImpl, info.zones, sheetPath, ServiceRegistryUtil_1.ExtensionsRegistryId, null, info.activeDashboardObjectId); + var dashboard = new Dashboard_1.Dashboard(dashboardImpl); + return new DashboardContent_1.DashboardContent(dashboard); + }; + ExtensionsImpl.prototype.initializeWorksheetContent = function (info) { + var sheetInfoImpl = new api_shared_js_1.SheetInfoImpl(info.visualId.worksheet, api_external_contract_js_1.SheetType.Worksheet, { width: info.size.w, height: info.size.h }, undefined, // index property is embedding specific + true); + var worksheetImpl = new api_shared_js_1.WorksheetImpl(sheetInfoImpl, ServiceRegistryUtil_1.ExtensionsRegistryId, info.visualId, null, // parentDashboard is always null for worksheet in WorksheetContent + null); + var worksheet = new Worksheet_1.Worksheet(worksheetImpl); + return new WorksheetContent_1.WorksheetContent(worksheet); + }; + ExtensionsImpl.prototype.initializeSettings = function (settingsInfo) { + var settingsImpl = new SettingsImpl_1.SettingsImpl(settingsInfo); + return new Settings_1.Settings(settingsImpl); + }; + ExtensionsImpl.prototype.initializeContextMenuCallbacks = function (contextMenuFunctions) { + var notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("notification-service" /* Notification */); + // Unregister function not used since these notifications should be + // observed for the full lifetime of the extension. + notificationService.registerHandler(api_internal_contract_js_1.NotificationId.ContextMenuClick, function () { + // Let through any context menu event, these are already filtered on api-core + // based on the extension locator. + return true; + }, function (event) { + // Execute the function associated with this context menu ID + if (contextMenuFunctions) { + if (!contextMenuFunctions[event.id]) { + throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, "Received unexpected context menu Id from event: " + event.id); + } + contextMenuFunctions[event.id](); + } + }); + }; + ExtensionsImpl.prototype.loadTableauFonts = function (fontNameAndInfo) { + switch (fontNameAndInfo.fontName) { + case TableauBookFontNameConstants_1.TableauBookFontFaceName: + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauBookFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' })); + break; + case TableauBookFontNameConstants_1.TableauLightFontFaceName: + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauLightFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' })); + break; + case TableauBookFontNameConstants_1.TableauRegularFontFaceName: + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauRegularFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' })); + break; + case TableauBookFontNameConstants_1.TableauSemiBoldFontFaceName: + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauSemiboldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' })); + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauRegularFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' })); + break; + case TableauBookFontNameConstants_1.TableauBoldFontFaceName: + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauBoldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' })); + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauBoldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' })); + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauMediumFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' })); + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauSemiboldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' })); + break; + case TableauBookFontNameConstants_1.TableauMediumFontFaceName: + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauMediumFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' })); + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauLightFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' })); + document.fonts.add(new FontFace(TableauBookFontNameConstants_1.TableauBookFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' })); + break; + default: + throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, "'attempted to load unsupported font: " + fontNameAndInfo.fontName + ".'"); + } + }; + ExtensionsImpl.prototype.loadBentonSansFonts = function (fontNameAndInfo) { + switch (fontNameAndInfo.fontName) { + case BentonSansFontNameConstants_1.BentonSansBookFontFaceName: + document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' })); + document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: '100', style: 'normal' })); + break; + case BentonSansFontNameConstants_1.BentonSansLightFontFaceName: + document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: '100', style: 'normal' })); + break; + case BentonSansFontNameConstants_1.BentonSansMediumFontFaceName: + document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' })); + document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' })); + break; + case BentonSansFontNameConstants_1.BentonSansSemiDemiFontFaceName: + document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' })); + break; + case BentonSansFontNameConstants_1.BentonSansBookItalicFontFaceName: + document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { style: 'italic' })); + break; + case BentonSansFontNameConstants_1.BentonSansSemiDemiItalicFontFaceName: + document.fonts.add(new FontFace(BentonSansFontNameConstants_1.BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { style: 'italic' })); + break; + default: + throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, "'attempted to load unsupported font: " + fontNameAndInfo.fontName + ".'"); + } + }; + return ExtensionsImpl; +}()); +exports.ExtensionsImpl = ExtensionsImpl; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Impl/LegacyInternalApiDispatcherHolder.js": +/*!*************************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Impl/LegacyInternalApiDispatcherHolder.js ***! + \*************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +/** + * LegacyInternalApiDispatcherHolder has been moved (and renamed) from api-internal-contract. + * It supports running a newer external library against a pre 2019.3 desktop. + * Starting in 2019.3, we have a merged bootstrap style for both desktop and server. + * In addition, the alpha checking that is happening here is not necessary in external-api-js + * after 2019.3 because that checking happens in api-platform-js (ApiDispatcherTest.ts) + * TFSID: 1091561 tracks an improvement to this system to make it less complex and tie it directly to + * tableau beta release versions. + * @deprecated + */ +// eslint-disable-next-line @typescript-eslint/no-namespace +var LegacyInternalApiDispatcherHolder; +(function (LegacyInternalApiDispatcherHolder) { + /** + * @param options + */ + function getDesktopDispatcherPromise(options) { + var _a; + if ((!options || typeof options.isAlpha === 'undefined') && !window.__warningIssued) { + // tslint:disable-next-line:no-console + console.warn('This is a beta version of the Extensions API. Please upgrade to an official release.'); + window.__warningIssued = true; + } + else if (((_a = options) === null || _a === void 0 ? void 0 : _a.isAlpha) && window.__platformIsOfficialRelease) { + window.__tableauDesktopDispatcher + .then(function (dispatcherFactory) { + var dispatcher = dispatcherFactory(api_internal_contract_js_1.INTERNAL_CONTRACT_VERSION); + dispatcher.execute(api_internal_contract_js_1.VerbId.BlockExtension, {}).catch(); + }) + .catch(); + } + // this will be undefined if promise is rejected or throws + return window.__tableauDesktopDispatcher; + } + LegacyInternalApiDispatcherHolder.getDesktopDispatcherPromise = getDesktopDispatcherPromise; + /** + * @param options + */ + function hasDesktopApiDispatcherPromise(options) { + return !!getDesktopDispatcherPromise(options); + } + LegacyInternalApiDispatcherHolder.hasDesktopApiDispatcherPromise = hasDesktopApiDispatcherPromise; +})(LegacyInternalApiDispatcherHolder = exports.LegacyInternalApiDispatcherHolder || (exports.LegacyInternalApiDispatcherHolder = {})); + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Impl/SettingsImpl.js": +/*!****************************************************!*\ + !*** ./lib/src/ExtensionsApi/Impl/SettingsImpl.js ***! + \****************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var TableauEvent_1 = __webpack_require__(/*! ../Events/TableauEvent */ "./lib/src/ExtensionsApi/Events/TableauEvent.js"); +var ServiceRegistryUtil_1 = __webpack_require__(/*! ../Services/ServiceRegistryUtil */ "./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js"); +var SettingsChangedEvent = /** @class */ (function (_super) { + __extends(SettingsChangedEvent, _super); + function SettingsChangedEvent(_newSettings) { + var _this = _super.call(this, Contract.TableauEventType.SettingsChanged) || this; + _this._newSettings = _newSettings; + return _this; + } + Object.defineProperty(SettingsChangedEvent.prototype, "newSettings", { + get: function () { + return this._newSettings; + }, + enumerable: true, + configurable: true + }); + return SettingsChangedEvent; +}(TableauEvent_1.TableauEvent)); +var SettingsImpl = /** @class */ (function () { + function SettingsImpl(settingsInfo) { + // Since promises can't be introspected for state, keep a variable that + // indicates a save is in progress, so that set/erase can't be called during a save. + this._saveInProgress = false; + this.initializeSettings(settingsInfo); + } + SettingsImpl.prototype.erase = function (key) { + api_shared_js_1.ErrorHelpers.verifyParameter(key, 'key'); + // Only make a modification if we have the key already + if (this._currentSettings[key]) { + this.verifySettingsAreUnlocked(); + delete this._currentSettings[key]; + this._isModified = true; + } + }; + SettingsImpl.prototype.get = function (key) { + api_shared_js_1.ErrorHelpers.verifyParameter(key, 'key'); + return this._currentSettings[key]; + }; + SettingsImpl.prototype.getAll = function () { + // Returns a mutable copy of the settings + return Object.assign({}, this._currentSettings); + }; + Object.defineProperty(SettingsImpl.prototype, "isModified", { + get: function () { + return this._isModified; + }, + enumerable: true, + configurable: true + }); + SettingsImpl.prototype.saveAsync = function () { + var _this = this; + this.verifySettingsAreUnlocked(); + // Just resolve immediately if settings are unchanged + if (!this._isModified) { + return Promise.resolve(this._currentSettings); + } + this._saveInProgress = true; + // Use the settings service to save settings to twb + var settingsService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("SettingsService" /* SettingsService */); + return settingsService.saveSettingsAsync(this._currentSettings).then(function (newSettings) { + _this._saveInProgress = false; + _this._isModified = false; + if (_this._currentSettings === undefined) { + _this._currentSettings = newSettings; + } + else { + Object.assign(_this._currentSettings, newSettings); + } + return newSettings; + }, function (reason) { + _this._saveInProgress = false; + return Promise.reject(reason); + }); + }; + SettingsImpl.prototype.set = function (key, value) { + api_shared_js_1.ErrorHelpers.verifyStringParameter(key, 'key'); // Key shouldn't be an empty string. + api_shared_js_1.ErrorHelpers.verifyParameter(value, 'value'); // Empty string value is allowed. + this.verifySettingsAreUnlocked(); + this._currentSettings[key] = value; + this._isModified = true; + }; + /** + * Initializes all events relevant to settings object. This is only a settingsUpdate event currently. + * + * @returns {Array} Collection of event managers to pass to an EventListenerManager. + */ + SettingsImpl.prototype.initializeEvents = function () { + var _this = this; + var results = new Array(); + var notificationService; + try { + notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("notification-service" /* Notification */); + } + catch (e) { + // If we don't have this service registered, just return + return results; + } + var settingsChangedEvent = new api_shared_js_1.SingleEventManagerImpl(Contract.TableauEventType.SettingsChanged); + notificationService.registerHandler(api_internal_contract_js_1.NotificationId.SettingsChanged, function () { return true; }, function (event) { + _this._currentSettings = event.newSettings; + settingsChangedEvent.triggerEvent(function () { return new SettingsChangedEvent(event.newSettings); }); + }); + results.push(settingsChangedEvent); + return results; + }; + SettingsImpl.prototype.initializeSettings = function (settingsInfo) { + api_shared_js_1.ErrorHelpers.verifyParameter(settingsInfo, 'settingsInfo'); + api_shared_js_1.ErrorHelpers.verifyParameter(settingsInfo.settingsValues, 'settingsInfo.SettingsValues'); + this._currentSettings = settingsInfo.settingsValues; + // Reset the isModified flag + this._isModified = false; + }; + /** + * This helper should be called before any local update to this.currentSettings. + * Checks if a current save call is still in progress and throws an error if so. + */ + SettingsImpl.prototype.verifySettingsAreUnlocked = function () { + if (this._saveInProgress) { + throw new api_shared_js_1.TableauError(Contract.ErrorCodes.SettingSaveInProgress, SettingsImpl.ASYNC_SAVE_IN_PROGRESS); + } + }; + SettingsImpl.ASYNC_SAVE_IN_PROGRESS = 'Async Save is in progress, updating settings is not allowed.'; + return SettingsImpl; +}()); +exports.SettingsImpl = SettingsImpl; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Impl/TableauBookFontNameConstants.js": +/*!********************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Impl/TableauBookFontNameConstants.js ***! + \********************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.TableauBookFontFamilyName = 'Tableau Book'; +exports.TableauLightFontFamilyName = 'Tableau Light'; +exports.TableauRegularFontFamilyName = 'Tableau Regular'; +exports.TableauMediumFontFamilyName = 'Tableau Medium'; +exports.TableauSemiboldFontFamilyName = 'Tableau Semibold'; +exports.TableauBoldFontFamilyName = 'Tableau Bold'; +exports.TableauBookFontFaceName = 'Tableau Book'; +exports.TableauBoldFontFaceName = 'Tableau Bold'; +exports.TableauLightFontFaceName = 'Tableau Light'; +exports.TableauMediumFontFaceName = 'Tableau Medium'; +exports.TableauRegularFontFaceName = 'Tableau Regular'; +exports.TableauSemiBoldFontFaceName = 'Tableau Semi Bold'; +exports.SupportedTableauFontFaces = [ + exports.TableauBookFontFaceName, + exports.TableauBoldFontFaceName, + exports.TableauLightFontFaceName, + exports.TableauMediumFontFaceName, + exports.TableauRegularFontFaceName, + exports.TableauSemiBoldFontFaceName, +]; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Impl/UIImpl.js": +/*!**********************************************!*\ + !*** ./lib/src/ExtensionsApi/Impl/UIImpl.js ***! + \**********************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var ServiceRegistryUtil_1 = __webpack_require__(/*! ../Services/ServiceRegistryUtil */ "./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js"); +var UIImpl = /** @class */ (function () { + function UIImpl() { + } + UIImpl.prototype.displayDialogAsync = function (url, payload, options) { + var uiService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("UIService" /* UIService */); + var notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("notification-service" /* Notification */); + return new Promise(function (resolve, reject) { + uiService + .displayDialogAsync(url, payload || '', options) + .then(function () { + var unregisterFn = notificationService.registerHandler(api_internal_contract_js_1.NotificationId.ExtensionDialogUpdate, function () { + // Let through any dialog update event + return true; + }, function (event) { + if (event.isCloseEvent) { + if (event.closePayload === undefined) { + throw new api_shared_js_1.TableauError(Contract.ErrorCodes.InternalError, 'closePayload is undefined'); + } + resolve(event.closePayload); + } + else { + reject(new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.DialogClosedByUser, 'Extension dialog closed by user.')); + } + unregisterFn(); + }); + }) + .catch(function (error) { + reject(error); + }); + }); + }; + UIImpl.prototype.closeDialog = function (payload) { + var uiService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("UIService" /* UIService */); + uiService.closeDialog(payload); + }; + return UIImpl; +}()); +exports.UIImpl = UIImpl; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Models/Dashboard.js": +/*!***************************************************!*\ + !*** ./lib/src/ExtensionsApi/Models/Dashboard.js ***! + \***************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var DashboardLayoutChangedEvent_1 = __webpack_require__(/*! ../Events/DashboardLayoutChangedEvent */ "./lib/src/ExtensionsApi/Events/DashboardLayoutChangedEvent.js"); +var WorkbookFormattingChangedEvent_1 = __webpack_require__(/*! ../Events/WorkbookFormattingChangedEvent */ "./lib/src/ExtensionsApi/Events/WorkbookFormattingChangedEvent.js"); +var ServiceRegistryUtil_1 = __webpack_require__(/*! ../Services/ServiceRegistryUtil */ "./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js"); +var DashboardObject_1 = __webpack_require__(/*! ./DashboardObject */ "./lib/src/ExtensionsApi/Models/DashboardObject.js"); +var Sheet_1 = __webpack_require__(/*! ./Sheet */ "./lib/src/ExtensionsApi/Models/Sheet.js"); +var Worksheet_1 = __webpack_require__(/*! ./Worksheet */ "./lib/src/ExtensionsApi/Models/Worksheet.js"); +var Dashboard = /** @class */ (function (_super) { + __extends(Dashboard, _super); + function Dashboard(_dashboardImpl) { + var _this = _super.call(this, _dashboardImpl) || this; + _this._dashboardImpl = _dashboardImpl; + _dashboardImpl.initializeWithPublicInterfaces(); + _this.initializeEvents().forEach(function (e) { return _this.addNewEventType(e); }); + return _this; + } + Object.defineProperty(Dashboard.prototype, "worksheets", { + get: function () { + return this._dashboardImpl.worksheetsImpl.map(function (worksheetImpl) { + return new Worksheet_1.Worksheet(worksheetImpl); + }); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Dashboard.prototype, "objects", { + get: function () { + return this._dashboardImpl.objects.map(function (dashboardObjectImpl) { + return new DashboardObject_1.DashboardObject(dashboardObjectImpl); + }); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Dashboard.prototype, "activeDashboardObjectId", { + get: function () { + return this._dashboardImpl.activeDashboardObjectId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Dashboard.prototype, "activeDashboardName", { + get: function () { + return this._dashboardImpl.activeDashboardName; + }, + enumerable: true, + configurable: true + }); + Dashboard.prototype.setZoneVisibilityAsync = function (zoneVisibilityMap) { + return this._dashboardImpl.setDashboardObjectVisibilityAsync(zoneVisibilityMap); + }; + Dashboard.prototype.setDashboardObjectVisibilityAsync = function (dashboardObjectVisibilityMap) { + return this._dashboardImpl.setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap); + }; + Dashboard.prototype.getDashboardObjectById = function (dashboardObjectId) { + var zone = this._dashboardImpl.getDashboardObjectById(dashboardObjectId); + return zone && new DashboardObject_1.DashboardObject(zone); + }; + Dashboard.prototype.initializeEvents = function () { + var _this = this; + var results = new Array(); + // Initializing events and registering notification service + var notificationService; + try { + notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("notification-service" /* Notification */); + } + catch (e) { + // If we don't have this service registered, just return (allows unit testing without NotificationService mock) + return results; + } + var dashboardLayoutChangedEvent = new api_shared_js_1.SingleEventManagerImpl(api_external_contract_js_1.TableauEventType.DashboardLayoutChanged); + notificationService.registerHandler(api_internal_contract_js_1.NotificationId.DashboardLayoutChanged, function () { return true; }, function (event) { + var dashboardObjectChanges = _this._dashboardImpl.updateZones(event.zones, event.activeZoneId, event.activeDashboardName); + dashboardLayoutChangedEvent.triggerEvent(function () { return new DashboardLayoutChangedEvent_1.DashboardLayoutChangedEvent(dashboardObjectChanges); }); + }); + results.push(dashboardLayoutChangedEvent); + var workbookFormattingChangedEvent = new api_shared_js_1.SingleEventManagerImpl(api_external_contract_js_1.TableauEventType.WorkbookFormattingChanged); + notificationService.registerHandler(api_internal_contract_js_1.NotificationId.WorkbookFormattingChanged, function () { return true; }, function (eventFormatting) { + workbookFormattingChangedEvent.triggerEvent(function () { return new WorkbookFormattingChangedEvent_1.WorkbookFormattingChangedEvent(eventFormatting); }); + }); + results.push(workbookFormattingChangedEvent); + return results; + }; + Dashboard.prototype.moveAndResizeDashboardObjectsAsync = function (dashboardObjectPositionAndSizeUpdateArray) { + return this._dashboardImpl.moveAndResizeDashboardObjectsAsync(dashboardObjectPositionAndSizeUpdateArray); + }; + Dashboard.prototype.replayAnimationAsync = function (replaySpeed) { + return this._dashboardImpl.replayAnimationAsync(replaySpeed); + }; + Dashboard.prototype.getFiltersAsync = function () { + return this._dashboardImpl.getFiltersAsync(); + }; + Dashboard.prototype.applyFilterAsync = function (fieldName, values, updateType, options) { + return this._dashboardImpl.applyFilterAsync(fieldName, values, updateType, options); + }; + return Dashboard; +}(Sheet_1.Sheet)); +exports.Dashboard = Dashboard; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Models/DashboardObject.js": +/*!*********************************************************!*\ + !*** ./lib/src/ExtensionsApi/Models/DashboardObject.js ***! + \*********************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Dashboard_1 = __webpack_require__(/*! ./Dashboard */ "./lib/src/ExtensionsApi/Models/Dashboard.js"); +var Worksheet_1 = __webpack_require__(/*! ./Worksheet */ "./lib/src/ExtensionsApi/Models/Worksheet.js"); +/** + * Implementation of the dashboard objects - the zones in a dashboard. + */ +var DashboardObject = /** @class */ (function () { + function DashboardObject(_dashboardObjectImpl) { + this._dashboardObjectImpl = _dashboardObjectImpl; + } + Object.defineProperty(DashboardObject.prototype, "dashboard", { + get: function () { + return new Dashboard_1.Dashboard(this._dashboardObjectImpl.dashboardImpl); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "type", { + get: function () { + return this._dashboardObjectImpl.type; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "position", { + get: function () { + return this._dashboardObjectImpl.position; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "size", { + get: function () { + return this._dashboardObjectImpl.size; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "worksheet", { + get: function () { + if (this._dashboardObjectImpl.worksheetImpl) { + return new Worksheet_1.Worksheet(this._dashboardObjectImpl.worksheetImpl); + } + return undefined; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "name", { + get: function () { + return this._dashboardObjectImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "isFloating", { + get: function () { + return this._dashboardObjectImpl.isFloating; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "isVisible", { + get: function () { + return this._dashboardObjectImpl.isVisible; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "id", { + get: function () { + return this._dashboardObjectImpl.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObject.prototype, "fieldId", { + get: function () { + return this._dashboardObjectImpl.fieldId; + }, + enumerable: true, + configurable: true + }); + return DashboardObject; +}()); +exports.DashboardObject = DashboardObject; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Models/Parameter.js": +/*!***************************************************!*\ + !*** ./lib/src/ExtensionsApi/Models/Parameter.js ***! + \***************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var ParameterChangedEvent_1 = __webpack_require__(/*! ../Events/ParameterChangedEvent */ "./lib/src/ExtensionsApi/Events/ParameterChangedEvent.js"); +var ServiceRegistryUtil_1 = __webpack_require__(/*! ../Services/ServiceRegistryUtil */ "./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js"); +/** + * Implementation of the Parameter contract. Calls down to the impl + * class for almost all of the work it does. + */ +var Parameter = /** @class */ (function (_super) { + __extends(Parameter, _super); + function Parameter(parameterImpl, sheet) { + var _this = _super.call(this) || this; + _this.parameterImpl = parameterImpl; + // Initialize our event handling for this class + _this.initializeEvents(sheet).forEach(function (e) { return _this.addNewEventType(e); }); + return _this; + } + Object.defineProperty(Parameter.prototype, "name", { + get: function () { + return this.parameterImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Parameter.prototype, "currentValue", { + get: function () { + return this.parameterImpl.currentValue; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Parameter.prototype, "dataType", { + get: function () { + return this.parameterImpl.dataType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Parameter.prototype, "allowableValues", { + get: function () { + return this.parameterImpl.allowableValues; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Parameter.prototype, "id", { + get: function () { + return this.parameterImpl.id; + }, + enumerable: true, + configurable: true + }); + Parameter.prototype.changeValueAsync = function (newValue) { + return this.parameterImpl.changeValueAsync(newValue); + }; + /** + * Helper method which goes through and registers each event type this impl knows about + * with the NotificationService. It returns an array of SingleEventManager objects which + * can then be passed to an EventListenerManager to handle user registration / unregistration. + * + * @param sheet The sheet object which will be included with the event notifications + * @returns {Array} Collection of event managers to pass to an EventListenerManager + */ + Parameter.prototype.initializeEvents = function (sheet) { + var _this = this; + api_shared_js_1.ErrorHelpers.verifyInternalValue(sheet, 'sheet'); + var results = new Array(); + var notificationService; + try { + notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("notification-service" /* Notification */); + } + catch (e) { + // If we don't have this service registered, just return + return results; + } + // Initialize all of the event managers we'll need (one for each event type) + var parameterEvent = new api_shared_js_1.SingleEventManagerImpl(Contract.TableauEventType.ParameterChanged); + notificationService.registerHandler(api_internal_contract_js_1.NotificationId.ParameterChanged, function (model) { + var fieldName = model; + return fieldName === _this.parameterImpl.id; + }, function (fieldName) { + parameterEvent.triggerEvent(function () { return new ParameterChangedEvent_1.ParameterChangedEvent(fieldName, sheet); }); + }); + results.push(parameterEvent); + return results; + }; + return Parameter; +}(api_shared_js_1.EventListenerManager)); +exports.Parameter = Parameter; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Models/Sheet.js": +/*!***********************************************!*\ + !*** ./lib/src/ExtensionsApi/Models/Sheet.js ***! + \***********************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var Parameter_1 = __webpack_require__(/*! ./Parameter */ "./lib/src/ExtensionsApi/Models/Parameter.js"); +var Sheet = /** @class */ (function (_super) { + __extends(Sheet, _super); + function Sheet(_sheetImpl) { + var _this = _super.call(this) || this; + _this._sheetImpl = _sheetImpl; + return _this; + } + Object.defineProperty(Sheet.prototype, "name", { + get: function () { + return this._sheetImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Sheet.prototype, "sheetType", { + get: function () { + return this._sheetImpl.sheetType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Sheet.prototype, "size", { + get: function () { + if (this.isValidSize(this._sheetImpl.size)) { + return this._sheetImpl.size; + } + throw new api_shared_js_1.TableauError(Contract.EmbeddingErrorCodes.ImplementationError, 'Size not implemented'); + }, + enumerable: true, + configurable: true + }); + Sheet.prototype.isValidSize = function (size) { + var testSize = size; + if (testSize.width !== undefined && testSize.height !== undefined) { + return true; + } + return false; + }; + Sheet.prototype.findParameterAsync = function (parameterName) { + var _this = this; + return this._sheetImpl.findParameterAsync(parameterName).then(function (parameterImpl) { + if (parameterImpl) { + return new Promise(function (resolve) { return resolve(new Parameter_1.Parameter(parameterImpl, _this)); }); + } + else { + return new Promise(function (resolve) { return resolve(undefined); }); + } + }); + }; + Sheet.prototype.getParametersAsync = function () { + var _this = this; + return this._sheetImpl.getParametersAsync().then(function (parametersImpl) { + return parametersImpl.map(function (parameterImpl) { + return new Parameter_1.Parameter(parameterImpl, _this); + }); + }); + }; + return Sheet; +}(api_shared_js_1.EventListenerManager)); +exports.Sheet = Sheet; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Models/Workbook.js": +/*!**************************************************!*\ + !*** ./lib/src/ExtensionsApi/Models/Workbook.js ***! + \**************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Workbook = /** @class */ (function () { + function Workbook(_workbookImpl) { + this._workbookImpl = _workbookImpl; + } + Workbook.prototype.getAllDataSourcesAsync = function () { + return this._workbookImpl.getAllDataSourcesAsync(); + }; + return Workbook; +}()); +exports.Workbook = Workbook; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Models/Worksheet.js": +/*!***************************************************!*\ + !*** ./lib/src/ExtensionsApi/Models/Worksheet.js ***! + \***************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var FilterChangedEvent_1 = __webpack_require__(/*! ../Events/FilterChangedEvent */ "./lib/src/ExtensionsApi/Events/FilterChangedEvent.js"); +var MarksSelectedEvent_1 = __webpack_require__(/*! ../Events/MarksSelectedEvent */ "./lib/src/ExtensionsApi/Events/MarksSelectedEvent.js"); +var SummaryDataChangedEvent_1 = __webpack_require__(/*! ../Events/SummaryDataChangedEvent */ "./lib/src/ExtensionsApi/Events/SummaryDataChangedEvent.js"); +var ServiceRegistryUtil_1 = __webpack_require__(/*! ../Services/ServiceRegistryUtil */ "./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js"); +var Dashboard_1 = __webpack_require__(/*! ./Dashboard */ "./lib/src/ExtensionsApi/Models/Dashboard.js"); +var Sheet_1 = __webpack_require__(/*! ./Sheet */ "./lib/src/ExtensionsApi/Models/Sheet.js"); +var Worksheet = /** @class */ (function (_super) { + __extends(Worksheet, _super); + function Worksheet(_worksheetImpl) { + var _this = _super.call(this, _worksheetImpl) || this; + _this._worksheetImpl = _worksheetImpl; + // Call to initialize events and then call down to the event listener manager to handle things + _this.initializeEvents().forEach(function (e) { return _this.addNewEventType(e); }); + return _this; + } + Object.defineProperty(Worksheet.prototype, "parentDashboard", { + get: function () { + // This should never happen for Extensions if the DashboardImpls are created correctly + if (this._worksheetImpl.parentDashboard == null) { + throw new api_shared_js_1.TableauError(Contract.SharedErrorCodes.ImplementationError, "Parent dashboard not implemented"); + } + return new Dashboard_1.Dashboard(this._worksheetImpl.parentDashboard); + }, + enumerable: true, + configurable: true + }); + /** + * Helper method which goes through and registers each event type this impl knows about + * with the NotificationService. It returns an array of SingleEventManager objects which + * can then be passed to an EventListenerManager to handle user registration / unregistration. + * + * @param {Worksheet} worksheet The worksheet object which will be included with the event notifications + * @returns {Array} Collection of event managers to pass to an EventListenerManager + */ + Worksheet.prototype.initializeEvents = function () { + var _this = this; + var results = new Array(); + var notificationService; + try { + notificationService = api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).getService("notification-service" /* Notification */); + } + catch (e) { + // If we don't have this service registered, just return + return results; + } + // Initialize all of the event managers we'll need (one for each event type) + var marksEvent = new api_shared_js_1.SingleEventManagerImpl(api_external_contract_js_1.TableauEventType.MarkSelectionChanged); + notificationService.registerHandler(api_internal_contract_js_1.NotificationId.SelectedMarksChanged, function (model) { + var visualId = model; + return _this.visualIdsAreEqual(visualId, _this._worksheetImpl.visualId); + }, function () { return marksEvent.triggerEvent(function () { return new MarksSelectedEvent_1.MarksSelectedEvent(_this); }); }); + var filterEvent = new api_shared_js_1.SingleEventManagerImpl(api_external_contract_js_1.TableauEventType.FilterChanged); + notificationService.registerHandler(api_internal_contract_js_1.NotificationId.FilterChanged, function (model) { + var filterEventResponse = model; + return _this._worksheetImpl.visualId.worksheet === filterEventResponse.visualId.worksheet; + }, function (event) { + filterEvent.triggerEvent(function () { return new FilterChangedEvent_1.FilterChangedEvent(_this, event.fieldName, event.fieldId); }); + }); + var summaryDataEvent = new api_shared_js_1.SingleEventManagerImpl(api_external_contract_js_1.TableauEventType.SummaryDataChanged); + notificationService.registerHandler(api_internal_contract_js_1.NotificationId.SummaryDataChanged, function (model) { + var summaryDataEventResponse = model; + return _this._worksheetImpl.visualId.worksheet === summaryDataEventResponse.visualId.worksheet; + }, function (event) { + summaryDataEvent.triggerEvent(function () { return new SummaryDataChangedEvent_1.SummaryDataChangedEvent(_this); }); + }); + results.push(marksEvent); + results.push(filterEvent); + results.push(summaryDataEvent); + return results; + }; + Worksheet.prototype.applyFilterAsync = function (fieldName, values, updateType, options) { + return this._worksheetImpl.applyFilterAsync(fieldName, values, updateType, options); + }; + Worksheet.prototype.applyRangeFilterAsync = function (fieldName, filterOptions) { + return this._worksheetImpl.applyRangeFilterAsync(fieldName, filterOptions); + }; + Worksheet.prototype.applyHierarchicalFilterAsync = function (fieldName, values, updateType, options) { + return this._worksheetImpl.applyHierarchicalFilterAsync(fieldName, values, updateType, options); + }; + Worksheet.prototype.applyRelativeDateFilterAsync = function (fieldName, options) { + return this._worksheetImpl.applyRelativeDateFilterAsync(fieldName, options); + }; + Worksheet.prototype.clearFilterAsync = function (fieldName) { + return this._worksheetImpl.clearFilterAsync(fieldName); + }; + Worksheet.prototype.getDataSourcesAsync = function () { + return this._worksheetImpl.getDataSourcesAsync(); + }; + Worksheet.prototype.getFiltersAsync = function () { + return this._worksheetImpl.getFiltersAsync(); + }; + Worksheet.prototype.getSelectedMarksAsync = function () { + return this._worksheetImpl.getSelectedMarksAsync(); + }; + Worksheet.prototype.getHighlightedMarksAsync = function () { + return this._worksheetImpl.getHighlightedMarksAsync(); + }; + Worksheet.prototype.getSummaryDataAsync = function (options) { + return this._worksheetImpl.getSummaryDataAsync(options); + }; + Worksheet.prototype.getSummaryDataReaderAsync = function (pageRowCount, options) { + return this._worksheetImpl.getSummaryDataReaderAsync(pageRowCount, options); + }; + Worksheet.prototype.getSummaryColumnsInfoAsync = function () { + return this._worksheetImpl.getSummaryColumnsInfoAsync(); + }; + Worksheet.prototype.getUnderlyingDataAsync = function (options) { + console.warn('Worksheet.getUnderlyingDataAsync is deprecated. Please use ' + + 'Worksheet.getUnderlyingTablesAsync and Worksheet.getUnderlyingTableDataAsync'); + return this._worksheetImpl.getUnderlyingDataAsync(options); + }; + Worksheet.prototype.getUnderlyingTablesAsync = function () { + return this._worksheetImpl.getUnderlyingTablesAsync(); + }; + Worksheet.prototype.getUnderlyingTableDataAsync = function (logicalTableId, options) { + return this._worksheetImpl.getUnderlyingTableDataAsync(logicalTableId, options); + }; + Worksheet.prototype.getUnderlyingTableDataReaderAsync = function (logicalTableId, pageRowCount, options) { + return this._worksheetImpl.getUnderlyingTableDataReaderAsync(logicalTableId, pageRowCount, options); + }; + Worksheet.prototype.getVisualSpecificationAsync = function () { + return this._worksheetImpl.getVisualSpecificationAsync(); + }; + Worksheet.prototype.clearSelectedMarksAsync = function () { + return this._worksheetImpl.clearSelectedMarksAsync(); + }; + Worksheet.prototype.selectMarksByIDAsync = function (marksInfo, updateType) { + return this._worksheetImpl.selectMarksByIdAsync(marksInfo, updateType); + }; + Worksheet.prototype.selectMarksByValueAsync = function (selections, selectionUpdateType) { + return this._worksheetImpl.selectMarksByValueAsync(selections, selectionUpdateType); + }; + Worksheet.prototype.selectMarksByIdAsync = function (selections, selectionUpdateType) { + return this._worksheetImpl.selectMarksByIdAsync(selections, selectionUpdateType); + }; + Worksheet.prototype.annotateMarkAsync = function (mark, annotationText) { + return this._worksheetImpl.annotateMarkAsync(mark, annotationText); + }; + Worksheet.prototype.getAnnotationsAsync = function () { + return this._worksheetImpl.getAnnotationsAsync(); + }; + Worksheet.prototype.removeAnnotationAsync = function (annotation) { + return this._worksheetImpl.removeAnnotationAsync(annotation); + }; + Worksheet.prototype.hoverTupleAsync = function (hoveredTuple, tooltip, allowHoverActions) { + if (allowHoverActions === void 0) { allowHoverActions = true; } + return this._worksheetImpl.hoverTupleAsync(hoveredTuple, tooltip, allowHoverActions); + }; + Worksheet.prototype.selectTuplesAsync = function (selectedTuples, selectOption, tooltip) { + return this._worksheetImpl.selectTuplesAsync(selectedTuples, selectOption, tooltip); + }; + Worksheet.prototype.getTooltipTextAsync = function (tupleId) { + return this._worksheetImpl.getTooltipTextAsync(tupleId); + }; + Worksheet.prototype.leaveMarkNavigationAsync = function () { + return this._worksheetImpl.leaveMarkNavigationAsync(); + }; + Worksheet.prototype.visualIdsAreEqual = function (a, b) { + return (a && + b && + a.worksheet === b.worksheet && + a.dashboard === b.dashboard && + a.storyboard === b.storyboard && + a.storyPointID === b.storyPointID); + }; + return Worksheet; +}(Sheet_1.Sheet)); +exports.Worksheet = Worksheet; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Namespaces/DashboardContent.js": +/*!**************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Namespaces/DashboardContent.js ***! + \**************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Implementation of the external DashboardContent namespace. + * This does not follow the Impl pattern as DashboardContent is + * currently just a (single) property bag. + */ +var DashboardContent = /** @class */ (function () { + function DashboardContent(_dashboard) { + this._dashboard = _dashboard; + } + Object.defineProperty(DashboardContent.prototype, "dashboard", { + get: function () { + return this._dashboard; + }, + enumerable: true, + configurable: true + }); + return DashboardContent; +}()); +exports.DashboardContent = DashboardContent; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Namespaces/Environment.js": +/*!*********************************************************!*\ + !*** ./lib/src/ExtensionsApi/Namespaces/Environment.js ***! + \*********************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var ConnectedServer_1 = __webpack_require__(/*! ../Impl/ConnectedServer */ "./lib/src/ExtensionsApi/Impl/ConnectedServer.js"); +var WorkbookFormattingEnvUtil_1 = __webpack_require__(/*! ./WorkbookFormattingEnvUtil */ "./lib/src/ExtensionsApi/Namespaces/WorkbookFormattingEnvUtil.js"); +/** + * Implementation of the external environment namespace. + * Environment does not follow the Impl pattern as it is + * just a property bag. + * First class extensions can get to ConnectedServer with: environment['connectedServer'] + */ +var Environment = /** @class */ (function () { + function Environment(extensionEnvironment) { + this._apiVersion = api_shared_js_1.ApiVersion.Instance && api_shared_js_1.ApiVersion.Instance.formattedValue; // maj.min.fix (no build) + this._context = api_shared_js_1.InternalToExternalEnumMappings.extensionContext.convert(extensionEnvironment.extensionContext); + this._formatting = WorkbookFormattingEnvUtil_1.WorkbookFormattingEnvUtil.convertToWorkbookFormatting(extensionEnvironment.workbookFormatting); + this._language = extensionEnvironment.extensionLanguage; + this._country = extensionEnvironment.extensionCountry; + this._locale = extensionEnvironment.extensionLocale; + this._mode = api_shared_js_1.InternalToExternalEnumMappings.extensionMode.convert(extensionEnvironment.extensionMode); + this._operatingSystem = extensionEnvironment.operatingSystem; + this._tableauVersion = extensionEnvironment.tableauVersion; + this._uniqueUserId = extensionEnvironment.uniqueUserId; + // If we have a userId, then we are a first class extension + if (extensionEnvironment.userId) { + this.connectedServer = new ConnectedServer_1.ConnectedServer(extensionEnvironment.userId, extensionEnvironment.siteId, extensionEnvironment.siteNamespace, extensionEnvironment.workbookId); + this.featureFlags = extensionEnvironment.featureFlags; + } + } + Object.defineProperty(Environment.prototype, "apiVersion", { + get: function () { + return this._apiVersion; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "context", { + get: function () { + return this._context; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "workbookFormatting", { + get: function () { + return this._formatting; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "language", { + get: function () { + return this._language; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "country", { + get: function () { + return this._country; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "locale", { + get: function () { + return this._locale; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "mode", { + get: function () { + return this._mode; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "operatingSystem", { + get: function () { + return this._operatingSystem; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "tableauVersion", { + get: function () { + return this._tableauVersion; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Environment.prototype, "uniqueUserId", { + get: function () { + return this._uniqueUserId; + }, + enumerable: true, + configurable: true + }); + return Environment; +}()); +exports.Environment = Environment; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Namespaces/Extensions.js": +/*!********************************************************!*\ + !*** ./lib/src/ExtensionsApi/Namespaces/Extensions.js ***! + \********************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Implementation of the external Extensions namespace. + */ +var Extensions = /** @class */ (function () { + function Extensions(extensionImpl) { + this.extensionImpl = extensionImpl; + this.extensionImpl = extensionImpl; + } + Object.defineProperty(Extensions.prototype, "dashboardContent", { + get: function () { + return this.extensionImpl.dashboardContent; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Extensions.prototype, "worksheetContent", { + get: function () { + return this.extensionImpl.worksheetContent; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Extensions.prototype, "environment", { + get: function () { + return this.extensionImpl.environment; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Extensions.prototype, "settings", { + get: function () { + return this.extensionImpl.settings; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Extensions.prototype, "ui", { + get: function () { + return this.extensionImpl.ui; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Extensions.prototype, "workbook", { + get: function () { + return this.extensionImpl.workbook; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Extensions.prototype, "dashboardObjectId", { + get: function () { + return this.extensionImpl.extensionZoneId; + }, + enumerable: true, + configurable: true + }); + Extensions.prototype.initializeAsync = function (contextMenuCallbacks) { + return this.extensionImpl.initializeAsync(false, contextMenuCallbacks).then(); + }; + Extensions.prototype.initializeDialogAsync = function () { + return this.extensionImpl.initializeAsync(true); + }; + Extensions.prototype.createVizImageAsync = function (inputSpec) { + return this.extensionImpl.createVizImageAsync(inputSpec); + }; + Extensions.prototype.setClickThroughAsync = function (clickThroughEnabled) { + return this.extensionImpl.setClickThroughAsync(clickThroughEnabled); + }; + return Extensions; +}()); +exports.Extensions = Extensions; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Namespaces/Settings.js": +/*!******************************************************!*\ + !*** ./lib/src/ExtensionsApi/Namespaces/Settings.js ***! + \******************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +/** + * Implementation of the external settings namespace. + */ +var Settings = /** @class */ (function (_super) { + __extends(Settings, _super); + function Settings(_settingsImpl) { + var _this = _super.call(this) || this; + _this._settingsImpl = _settingsImpl; + // Initialize our event handling for this class + _this._settingsImpl.initializeEvents().forEach(function (e) { return _this.addNewEventType(e); }); + return _this; + } + Settings.prototype.erase = function (key) { + this._settingsImpl.erase(key); + }; + Settings.prototype.get = function (key) { + return this._settingsImpl.get(key); + }; + Settings.prototype.getAll = function () { + return this._settingsImpl.getAll(); + }; + Object.defineProperty(Settings.prototype, "isModified", { + get: function () { + return this._settingsImpl.isModified; + }, + enumerable: true, + configurable: true + }); + Settings.prototype.saveAsync = function () { + return this._settingsImpl.saveAsync(); + }; + Settings.prototype.set = function (key, value) { + this._settingsImpl.set(key, value); + }; + return Settings; +}(api_shared_js_1.EventListenerManager)); +exports.Settings = Settings; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Namespaces/UI.js": +/*!************************************************!*\ + !*** ./lib/src/ExtensionsApi/Namespaces/UI.js ***! + \************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Implementation of the external UI namespace. + */ +var UI = /** @class */ (function () { + function UI(_impl) { + this._impl = _impl; + } + UI.prototype.displayDialogAsync = function (url, payload, options) { + return this._impl.displayDialogAsync(url, payload, options); + }; + UI.prototype.closeDialog = function (payload) { + this._impl.closeDialog(payload); + }; + return UI; +}()); +exports.UI = UI; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Namespaces/WorkbookFormattingEnvUtil.js": +/*!***********************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Namespaces/WorkbookFormattingEnvUtil.js ***! + \***********************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var WorkbookFormattingEnvUtil = /** @class */ (function () { + function WorkbookFormattingEnvUtil() { + } + WorkbookFormattingEnvUtil.convertToWorkbookFormatting = function (workbookFormattingModel) { + if (!workbookFormattingModel) { + return undefined; + } + else { + var formattingMap = workbookFormattingModel.formattingSheets.map(function (currentFormattingSheet) { + var formattingSheet = { + classNameKey: api_shared_js_1.InternalToExternalEnumMappings.classNameKey.convert(currentFormattingSheet.classNameKey), + cssProperties: { + fontFamily: currentFormattingSheet.cssProperties.fontFamily, + fontSize: currentFormattingSheet.cssProperties.fontSize, + fontWeight: currentFormattingSheet.cssProperties.fontWeight, + fontStyle: currentFormattingSheet.cssProperties.fontStyle, + textDecoration: currentFormattingSheet.cssProperties.textDecoration, + color: currentFormattingSheet.cssProperties.color, + }, + }; + return formattingSheet; + }); + var result = { + formattingSheets: formattingMap, + }; + return result; + } + }; + return WorkbookFormattingEnvUtil; +}()); +exports.WorkbookFormattingEnvUtil = WorkbookFormattingEnvUtil; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Namespaces/WorksheetContent.js": +/*!**************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Namespaces/WorksheetContent.js ***! + \**************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Implementation of the external WorksheetContent namespace. + * This does not follow the Impl pattern as WorksheetContent is + * currently just a (single) property bag. + */ +var WorksheetContent = /** @class */ (function () { + function WorksheetContent(_worksheet) { + this._worksheet = _worksheet; + } + Object.defineProperty(WorksheetContent.prototype, "worksheet", { + get: function () { + return this._worksheet; + }, + enumerable: true, + configurable: true + }); + return WorksheetContent; +}()); +exports.WorksheetContent = WorksheetContent; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Services/Impl/InitializationServiceImpl.js": +/*!**************************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Services/Impl/InitializationServiceImpl.js ***! + \**************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var InitializationServiceImpl = /** @class */ (function (_super) { + __extends(InitializationServiceImpl, _super); + function InitializationServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(InitializationServiceImpl.prototype, "serviceName", { + get: function () { + return "InitializationService" /* InitializationService */; + }, + enumerable: true, + configurable: true + }); + InitializationServiceImpl.prototype.initializeDashboardExtensionsAsync = function (isExtensionDialog, contextMenuIds) { + var _a; + var params = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'initializeDashboardExtensionsAsync', + _a[api_internal_contract_js_1.ParameterId.ExtensionContextMenuIds] = contextMenuIds, + _a[api_internal_contract_js_1.ParameterId.IsExtensionDialog] = isExtensionDialog, + _a); + return this.execute(api_internal_contract_js_1.VerbId.InitializeExtension, params).then(function (response) { + // TODO - Validate return value + var result = response.result; + return result; + }); + }; + return InitializationServiceImpl; +}(api_shared_js_1.ServiceImplBase)); +exports.InitializationServiceImpl = InitializationServiceImpl; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Services/Impl/SettingsServiceImpl.js": +/*!********************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Services/Impl/SettingsServiceImpl.js ***! + \********************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var SettingsServiceImpl = /** @class */ (function (_super) { + __extends(SettingsServiceImpl, _super); + function SettingsServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(SettingsServiceImpl.prototype, "serviceName", { + get: function () { + return "SettingsService" /* SettingsService */; + }, + enumerable: true, + configurable: true + }); + SettingsServiceImpl.prototype.saveSettingsAsync = function (settings) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'saveSettingsAsync', + _a[api_internal_contract_js_1.ParameterId.SettingsValues] = settings, + _a); + return this.execute(api_internal_contract_js_1.VerbId.SaveExtensionSettings, parameters).then(function (value) { + var result = value.result; + if (!result || !result.settingsValues) { + throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, 'Unexpected error savings settings.'); + } + return result.settingsValues; + }); + }; + return SettingsServiceImpl; +}(api_shared_js_1.ServiceImplBase)); +exports.SettingsServiceImpl = SettingsServiceImpl; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Services/Impl/UIServiceImpl.js": +/*!**************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Services/Impl/UIServiceImpl.js ***! + \**************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var DEFAULT_DIALOG_HEIGHT = 400; // in pixels +var DEFAULT_DIALOG_WIDTH = 600; // in pixels +var DEFAULT_DIALOG_STYLE = api_external_contract_js_1.DialogStyle.Window; +var UIServiceImpl = /** @class */ (function (_super) { + __extends(UIServiceImpl, _super); + function UIServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(UIServiceImpl.prototype, "serviceName", { + get: function () { + return "UIService" /* UIService */; + }, + enumerable: true, + configurable: true + }); + UIServiceImpl.prototype.displayDialogAsync = function (url, payload, options) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'displayDialogAsync', + _a[api_internal_contract_js_1.ParameterId.ExtensionDialogUrl] = url, + _a[api_internal_contract_js_1.ParameterId.ExtensionDialogPayload] = payload, + _a); + var h = options && options.height ? options.height : DEFAULT_DIALOG_HEIGHT; + var w = options && options.width ? options.width : DEFAULT_DIALOG_WIDTH; + var dialogStyle = options && options.dialogStyle ? options.dialogStyle : DEFAULT_DIALOG_STYLE; + // On the platform side, we do something reasonable regardess of whether the passed + // height and width are too large or too small. But this likely indicates a developer error, + // so we throw an error here to help with debugging. + if (h <= 0 || w <= 0) { + throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'Size parameters for displayDialogAsync must be positive'); + } + parameters[api_internal_contract_js_1.ParameterId.ExtensionDialogH] = h; + parameters[api_internal_contract_js_1.ParameterId.ExtensionDialogW] = w; + api_shared_js_1.ErrorHelpers.verifyEnumValue(dialogStyle, api_external_contract_js_1.DialogStyle, 'DialogStyle'); + parameters[api_internal_contract_js_1.ParameterId.ExtensionDialogStyle] = api_shared_js_1.ExternalToInternalEnumMappings.dialogStyles.convert(dialogStyle); + return this.execute(api_internal_contract_js_1.VerbId.DisplayDialog, parameters).then(function (response) { + var dialogResult = response.result; + switch (dialogResult) { + case api_internal_contract_js_1.ExtensionDialogResult.DialogAlreadyOpen: + throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.DialogAlreadyOpen, 'There already exists an open dialog for this extension.'); + case api_internal_contract_js_1.ExtensionDialogResult.InvalidDomain: + throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidDomainDialog, 'The url of an extension dialog must match the domain of the parent extension.'); + default: + // Success case + return; + } + }); + }; + UIServiceImpl.prototype.closeDialog = function (payload) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'closeDialog', + _a); + if (payload) { + parameters[api_internal_contract_js_1.ParameterId.ExtensionDialogPayload] = payload; + } + return this.execute(api_internal_contract_js_1.VerbId.CloseDialog, parameters).then(function () { + return; + }); + }; + UIServiceImpl.prototype.setClickThroughAsync = function (clickThroughEnabled, extensionZoneId) { + var _a; + api_shared_js_1.ErrorHelpers.verifyParameterType(clickThroughEnabled, 'boolean', 'clickThroughEnabled'); + if (extensionZoneId === undefined || extensionZoneId <= 0) { + throw new api_shared_js_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, 'Extension Id is invalid.'); + } + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.ExtensionZoneId] = extensionZoneId, + _a[api_internal_contract_js_1.ParameterId.ClickThroughEnabled] = clickThroughEnabled, + _a); + return this.execute(api_internal_contract_js_1.VerbId.SetClickThrough, parameters).then(function () { + return; + }); + }; + return UIServiceImpl; +}(api_shared_js_1.ServiceImplBase)); +exports.UIServiceImpl = UIServiceImpl; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Services/RegisterAllExtensionsServices.js": +/*!*************************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Services/RegisterAllExtensionsServices.js ***! + \*************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +var InitializationServiceImpl_1 = __webpack_require__(/*! ./Impl/InitializationServiceImpl */ "./lib/src/ExtensionsApi/Services/Impl/InitializationServiceImpl.js"); +var SettingsServiceImpl_1 = __webpack_require__(/*! ./Impl/SettingsServiceImpl */ "./lib/src/ExtensionsApi/Services/Impl/SettingsServiceImpl.js"); +var UIServiceImpl_1 = __webpack_require__(/*! ./Impl/UIServiceImpl */ "./lib/src/ExtensionsApi/Services/Impl/UIServiceImpl.js"); +var ServiceRegistryUtil_1 = __webpack_require__(/*! ./ServiceRegistryUtil */ "./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js"); +function registerAllExtensionsServices(dispatcher) { + api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).registerService(new SettingsServiceImpl_1.SettingsServiceImpl(dispatcher, ServiceRegistryUtil_1.ExtensionsRegistryId)); + api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).registerService(new UIServiceImpl_1.UIServiceImpl(dispatcher, ServiceRegistryUtil_1.ExtensionsRegistryId)); +} +exports.registerAllExtensionsServices = registerAllExtensionsServices; +function registerInitializationExtensionsServices(dispatcher) { + api_shared_js_1.ApiServiceRegistry.get(ServiceRegistryUtil_1.ExtensionsRegistryId).registerService(new InitializationServiceImpl_1.InitializationServiceImpl(dispatcher, ServiceRegistryUtil_1.ExtensionsRegistryId)); +} +exports.registerInitializationExtensionsServices = registerInitializationExtensionsServices; + + +/***/ }), + +/***/ "./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js": +/*!***************************************************************!*\ + !*** ./lib/src/ExtensionsApi/Services/ServiceRegistryUtil.js ***! + \***************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.ExtensionsRegistryId = 0; + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/EmbeddingApiExternalContract.js": +/*!***************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/EmbeddingApiExternalContract.js ***! + \***************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +// This file re-exports everything which is part of the extensions api public interface +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", ({ value: true })); +__export(__webpack_require__(/*! ./ExternalContract/Embedding/AskDataInterfaces */ "../api-external-contract-js/lib/src/ExternalContract/Embedding/AskDataInterfaces.js")); +var Enums_1 = __webpack_require__(/*! ./ExternalContract/Embedding/Enums */ "../api-external-contract-js/lib/src/ExternalContract/Embedding/Enums.js"); +exports.ApiMenuType = Enums_1.ApiMenuType; +exports.CrosstabFileFormat = Enums_1.CrosstabFileFormat; +exports.DeviceType = Enums_1.DeviceType; +exports.EmbeddingErrorCodes = Enums_1.EmbeddingErrorCodes; +exports.EmbeddingTableauEventType = Enums_1.TableauEventType; +exports.FileFormats = Enums_1.FileFormats; +exports.PrintOrientation = Enums_1.PrintOrientation; +exports.PrintPageSize = Enums_1.PrintPageSize; +exports.PrintScaling = Enums_1.PrintScaling; +exports.PulseLayout = Enums_1.PulseLayout; +exports.SheetSizeBehavior = Enums_1.SheetSizeBehavior; +exports.TableauDialogType = Enums_1.TableauDialogType; +exports.Toolbar = Enums_1.Toolbar; +__export(__webpack_require__(/*! ./ExternalContract/Embedding/PulseInterfaces */ "../api-external-contract-js/lib/src/ExternalContract/Embedding/PulseInterfaces.js")); +__export(__webpack_require__(/*! ./ExternalContract/Embedding/VizInterfaces */ "../api-external-contract-js/lib/src/ExternalContract/Embedding/VizInterfaces.js")); +__export(__webpack_require__(/*! ./ExternalContract/Embedding/WebComponentInterfaces */ "../api-external-contract-js/lib/src/ExternalContract/Embedding/WebComponentInterfaces.js")); +__export(__webpack_require__(/*! ./SharedApiExternalContract */ "../api-external-contract-js/lib/src/SharedApiExternalContract.js")); + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/ExtensionsApiExternalContract.js": +/*!****************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/ExtensionsApiExternalContract.js ***! + \****************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +// This file re-exports everything which is part of the extensions api public interface +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Tableau_1 = __webpack_require__(/*! ./ExternalContract/Extensions/Namespaces/Tableau */ "../api-external-contract-js/lib/src/ExternalContract/Extensions/Namespaces/Tableau.js"); +exports.ErrorCodes = Tableau_1.ErrorCodes; +exports.ExtensionContext = Tableau_1.ExtensionContext; +exports.ExtensionMode = Tableau_1.ExtensionMode; +exports.TableauEventType = Tableau_1.TableauEventType; +exports.VizImageEncodingType = Tableau_1.VizImageEncodingType; +exports.VizImagePaletteType = Tableau_1.VizImagePaletteType; +exports.VizImageSizeSettingAlignmentType = Tableau_1.VizImageSizeSettingAlignmentType; +exports.VizImageSizeSettingType = Tableau_1.VizImageSizeSettingType; +exports.VizImageSortDirectionType = Tableau_1.VizImageSortDirectionType; +__export(__webpack_require__(/*! ./SharedApiExternalContract */ "../api-external-contract-js/lib/src/SharedApiExternalContract.js")); + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/ExternalContract.js": +/*!***************************************************************!*\ + !*** ../api-external-contract-js/lib/src/ExternalContract.js ***! + \***************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +/** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", ({ value: true })); +__export(__webpack_require__(/*! ./EmbeddingApiExternalContract */ "../api-external-contract-js/lib/src/EmbeddingApiExternalContract.js")); +__export(__webpack_require__(/*! ./ExtensionsApiExternalContract */ "../api-external-contract-js/lib/src/ExtensionsApiExternalContract.js")); + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/ExternalContract/Embedding/AskDataInterfaces.js": +/*!*******************************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/ExternalContract/Embedding/AskDataInterfaces.js ***! + \*******************************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * The names of the string constants you can use as HTML attributes for the web component. + * @ignore + * @deprecated + */ +var AskDataAttributes; +(function (AskDataAttributes) { + AskDataAttributes["Origin"] = "origin"; + AskDataAttributes["ShowEmbed"] = "show-embed"; + AskDataAttributes["ShowPin"] = "show-pin"; + AskDataAttributes["ShowSave"] = "show-save"; + AskDataAttributes["ShowShare"] = "show-share"; +})(AskDataAttributes = exports.AskDataAttributes || (exports.AskDataAttributes = {})); + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/ExternalContract/Embedding/Enums.js": +/*!*******************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/ExternalContract/Embedding/Enums.js ***! + \*******************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +// All enum values made available to Embedding developers. +// Enums should be kept in alphabetical order. +// Most of them should match an enum on the server defined at +// workgroup/vqlweb/scriptsharp/src/ApiShared/PublicEnums.cs#L398:17 +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Crosstab file formats available to use with {@link Viz.exportCrosstabAsync} + */ +var CrosstabFileFormat; +(function (CrosstabFileFormat) { + CrosstabFileFormat["CSV"] = "csv"; + CrosstabFileFormat["Excel"] = "xlsx"; +})(CrosstabFileFormat = exports.CrosstabFileFormat || (exports.CrosstabFileFormat = {})); +/** + * Device types available to use with {@link Viz.device} + */ +var DeviceType; +(function (DeviceType) { + DeviceType["Default"] = "default"; + DeviceType["Desktop"] = "desktop"; + DeviceType["Tablet"] = "tablet"; + DeviceType["Phone"] = "phone"; +})(DeviceType = exports.DeviceType || (exports.DeviceType = {})); +/** + * All error codes used by the Embedding API. + */ +var EmbeddingErrorCodes; +(function (EmbeddingErrorCodes) { + /** + * Raised when a request to the auth endpoint fails. + */ + EmbeddingErrorCodes["AuthFailed"] = "auth-failed"; + /** + * The browser is not capable of supporting the Tableau Embedding API + */ + EmbeddingErrorCodes["BrowserNotCapable"] = "browser-not-capable"; + /** + * The permissions on a workbook or a view do not allow downloading the workbook. + */ + EmbeddingErrorCodes["DownloadWorkbookNotAllowed"] = "download-workbook-not-allowed"; + /** + * Thrown when an error occurs while attempting to perform a filter operation. + */ + EmbeddingErrorCodes["FilterCannotBePerformed"] = "filter-cannot-be-performed"; + /** + * Thrown when attempting to switch to a sheet by index that does not exist in the workbook. + */ + EmbeddingErrorCodes["IndexOutOfRange"] = "index-out-of-range"; + /** + * Thrown when an error occurs within the Tableau Embedding API. Contact Tableau Support. + */ + EmbeddingErrorCodes["InternalError"] = "internal-error"; + /** + * An operation was attempted on a custom view that does not exist. + */ + EmbeddingErrorCodes["InvalidCustomViewName"] = "invalid-custom-view-name"; + /** + * An invalid date was specified in a method that required a date parameter. + */ + EmbeddingErrorCodes["InvalidDateParameter"] = "invalid-date-parameter"; + /** + * Either a filter operation was attempted on a field that does not exist in the data source, or the value supplied + * in the filter operation is the wrong data type or format. + */ + EmbeddingErrorCodes["invalidFilterFieldNameOrValue"] = "invalid-filter-field-name"; + /** + * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message + * field. + */ + EmbeddingErrorCodes["InvalidParameter"] = "invalid-parameter"; + /** + * A negative size was specified or the maxSize value is less than minSize in Sheet.changeSizeAsync(). + */ + EmbeddingErrorCodes["InvalidSize"] = "invalid-size"; + /** + * Attempted to get an authoring worksheet when the current sheet is not a worksheet. + * @ignore + */ + EmbeddingErrorCodes["InvalidSheetType"] = "invalid-sheet-type"; + /** + * A behavior value was found that is not included in the SheetSizeBehavior enum. + */ + EmbeddingErrorCodes["InvalidSizeBehavior"] = "invalid-size-behavior"; + /** + * A behavior other than SheetSizeBehavior.Automatic was specified in Sheet.changeSizeAsync() when the sheet is a + * Worksheet instance. + */ + EmbeddingErrorCodes["InvalidSizeBehaviorOnWorksheet"] = "invalid-size-behavior-on-worksheet"; + /** + * The URL specified in the Viz class constructor is not valid. + */ + EmbeddingErrorCodes["InvalidUrl"] = "invalid-url"; + /** + * The maxSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.AtMost. + */ + EmbeddingErrorCodes["MissingMaxSize"] = "missing-max-size"; + /** + * The minSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.AtLeast. + */ + EmbeddingErrorCodes["MissingMinSize"] = "missing-min-size"; + /** + * The minSize or maxSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.Range. + */ + EmbeddingErrorCodes["MissingMinMaxSize"] = "missing-min-max-size"; + /** + * Can occur if the embedding app interacts with a parameter that has been removed from the worksheet. + */ + EmbeddingErrorCodes["MissingParameter"] = "missing-parameter"; + /** + * The rangeN field is missing for a relative date filter of type LASTN or NEXTN. + */ + EmbeddingErrorCodes["MissingRangeNForRelativeDateFilters"] = "missing-range-n-for-relative-date-filters"; + /** + * An attempt was made to access Sheet.getUrl() on a hidden sheet. Hidden sheets do not have URLs. + */ + EmbeddingErrorCodes["NoUrlForHiddenWorksheet"] = "no-url-for-hidden-worksheet"; + /** + * One or both of the parentElement or the URL parameters is not specified in the Viz constructor. + */ + EmbeddingErrorCodes["NoUrlOrParentElementNotFound"] = "no-url-or-parent-element-not-found"; + /** + * An operation was attempted on a sheet that is not active or embedded within the active dashboard. + */ + EmbeddingErrorCodes["NotActiveSheet"] = "not-active-sheet"; + /** + * A required parameter was not specified, null, or an empty string/array. + */ + EmbeddingErrorCodes["NullOrEmptyParameter"] = "null-or-empty-parameter"; + /** + * An operation was attempted on a sheet that does not exist in the workbook. + */ + EmbeddingErrorCodes["SheetNotInWorkbook"] = "sheet-not-in-workbook"; + /** + * An operation is performed on a CustomView object that is no longer valid (it has been removed). + */ + EmbeddingErrorCodes["StaleDataReference"] = "stale-data-reference"; + /** + * Unknown error triggered during the auth flow. + */ + EmbeddingErrorCodes["UnknownAuthError"] = "unknown-auth-error"; + /** + * An unknown event name was specified in the call to Viz.addEventListener or Viz.removeEventListener. + */ + EmbeddingErrorCodes["UnsupportedEventName"] = "unsupported-event-name"; + /** + * A Viz object has already been created as a child of the parentElement specified in the Viz constructor. + */ + EmbeddingErrorCodes["VizAlreadyInManager"] = "viz-already-in-manager"; + /** + * Function is not supported in the embedding api. + */ + EmbeddingErrorCodes["ImplementationError"] = "wrong-implementation"; + /** + * @NotImplemented + */ + EmbeddingErrorCodes["NotImplemented"] = "not-implemented"; + /** + * Unknown error during event initialization + */ + EmbeddingErrorCodes["EventInitializationError"] = "event-initialization-error"; + /** + * Version of the embedding api not supported by the version of tableau + */ + EmbeddingErrorCodes["IncompatibleVersionError"] = "incompatible-version-error"; + /** + * Unknown {@link TableauDialogType} passed in to Viz.displayDialogAsync. + */ + EmbeddingErrorCodes["UnknownDialogType"] = "unknown-dialog-type"; + /** + * Can occur if the API interacts with a filter that has been removed from the worksheet. + * Can also occurs if a {@link FilterType} has not been implemented. + */ + EmbeddingErrorCodes["FilterMissingOrNotImplemented"] = "filter-missing-not-implemented"; + /** + * Can occur if story point ids no longer match. + */ + EmbeddingErrorCodes["StoryPointIdMismatch"] = "storypoint-id-mismatch"; +})(EmbeddingErrorCodes = exports.EmbeddingErrorCodes || (exports.EmbeddingErrorCodes = {})); +/** + * Formats available to use with displayStaticImage in @VizInterfaces + */ +var FileFormats; +(function (FileFormats) { + FileFormats["PDF"] = "pdf"; + FileFormats["PNG"] = "png"; +})(FileFormats = exports.FileFormats || (exports.FileFormats = {})); +var PrintOrientation; +(function (PrintOrientation) { + PrintOrientation["Portrait"] = "portrait"; + PrintOrientation["Landscape"] = "landscape"; +})(PrintOrientation = exports.PrintOrientation || (exports.PrintOrientation = {})); +var PrintPageSize; +(function (PrintPageSize) { + PrintPageSize["Letter"] = "letter"; + PrintPageSize["Legal"] = "legal"; + PrintPageSize["Note"] = "note"; + PrintPageSize["Folio"] = "folio"; + PrintPageSize["Tabloid"] = "tabloid"; + PrintPageSize["Ledger"] = "ledger"; + PrintPageSize["Statement"] = "statement"; + PrintPageSize["Executive"] = "executive"; + PrintPageSize["A3"] = "A3"; + PrintPageSize["A4"] = "A4"; + PrintPageSize["A5"] = "A5"; + PrintPageSize["B4"] = "B4"; + PrintPageSize["B5"] = "B5"; + PrintPageSize["Quarto"] = "quarto"; + PrintPageSize["Unspecified"] = "unspecified"; +})(PrintPageSize = exports.PrintPageSize || (exports.PrintPageSize = {})); +var PrintScaling; +(function (PrintScaling) { + PrintScaling["Automatic"] = "automatic"; + PrintScaling["Perc25"] = "25%"; + PrintScaling["Perc50"] = "50%"; + PrintScaling["Perc60"] = "60%"; + PrintScaling["Perc75"] = "75%"; + PrintScaling["Perc80"] = "80%"; + PrintScaling["Perc90"] = "90%"; + PrintScaling["Perc100"] = "100%"; + PrintScaling["Perc200"] = "200%"; + PrintScaling["Perc400"] = "400%"; + PrintScaling["AtMost1PageHigh"] = "at-most-1-page-high"; + PrintScaling["AtMost2PagesHigh"] = "at-most-2-pages-high"; + PrintScaling["AtMost1PageWide"] = "at-most-1-page-wide"; + PrintScaling["AtMost2PagesWide"] = "at-most-2-pages-wide"; +})(PrintScaling = exports.PrintScaling || (exports.PrintScaling = {})); +var RevertVizSelection; +(function (RevertVizSelection) { + RevertVizSelection["All"] = "all"; + RevertVizSelection["Axes"] = "axes"; + RevertVizSelection["Filters"] = "filters"; + RevertVizSelection["Sorts"] = "sorts"; + RevertVizSelection["Shelves"] = "shelves"; +})(RevertVizSelection = exports.RevertVizSelection || (exports.RevertVizSelection = {})); +var ToolbarButtons; +(function (ToolbarButtons) { + ToolbarButtons["Alerts"] = "alerts"; + ToolbarButtons["AskData"] = "askData"; + ToolbarButtons["CustomViews"] = "customViews"; + ToolbarButtons["DataDetails"] = "dataDetails"; + ToolbarButtons["Share"] = "share"; + ToolbarButtons["Subscribe"] = "subscribe"; +})(ToolbarButtons = exports.ToolbarButtons || (exports.ToolbarButtons = {})); +var Toolbar; +(function (Toolbar) { + Toolbar["Top"] = "top"; + Toolbar["Bottom"] = "bottom"; + Toolbar["Hidden"] = "hidden"; +})(Toolbar = exports.Toolbar || (exports.Toolbar = {})); +var SheetSizeBehavior; +(function (SheetSizeBehavior) { + SheetSizeBehavior["Automatic"] = "automatic"; + SheetSizeBehavior["Exactly"] = "exactly"; + SheetSizeBehavior["Range"] = "range"; + SheetSizeBehavior["AtLeast"] = "atleast"; + SheetSizeBehavior["AtMost"] = "atmost"; +})(SheetSizeBehavior = exports.SheetSizeBehavior || (exports.SheetSizeBehavior = {})); +var PulseLayout; +(function (PulseLayout) { + PulseLayout["Default"] = "default"; + PulseLayout["Card"] = "card"; + PulseLayout["Ban"] = "ban"; +})(PulseLayout = exports.PulseLayout || (exports.PulseLayout = {})); +/** + * Be careful when adding new event types. Extensions and embedding follow two different patterns on how events are named. + * Events should be all lower case and without hyphens or underscores. + */ +/** + * Represents the type of tableau embedding event that can be listened for. + */ +var TableauEventType; +(function (TableauEventType) { + /** + * Raised when a custom view has finished loading. This event is raised after the callback function for {@link FirstInteractive} (if any) has been called. + * + * @category Viewing + */ + TableauEventType["CustomViewLoaded"] = "customviewloaded"; + /** + * Raised when a custom view has been removed. + * + * @category Viewing + */ + TableauEventType["CustomViewRemoved"] = "customviewremoved"; + /** + * Raised when a custom view has been saved (newly created or updated). + * + * @category Viewing + */ + TableauEventType["CustomViewSaved"] = "customviewsaved"; + /** + * Raised when a custom view has been set as the default view for a workbook. + * + * @category Viewing + */ + TableauEventType["CustomViewSetDefault"] = "customviewsetdefault"; + /** Raised when the user clicks on the Edit Button. + * + * @category Viewing + */ + TableauEventType["EditButtonClicked"] = "editbuttonclicked"; + /** Raised when the user clicks on the Edit In Desktop Button. + * + * @category Authoring, Viewing + */ + TableauEventType["EditInDesktopButtonClicked"] = "editindesktopbuttonclicked"; + /** Raised when any filter has changed state. You can use this event type with TableauViz objects. + * + * @category Viewing + */ + TableauEventType["FilterChanged"] = "filterchanged"; + /** Fired when viz size is known + * + * @category Authoring, Viewing + */ + TableauEventType["FirstVizSizeKnown"] = "firstvizsizeknown"; + /** Fired when a viz first becomes interactive + * + * @category Authoring, Viewing + */ + TableauEventType["FirstInteractive"] = "firstinteractive"; + /** Raised when a custom mark context menu is clicked. + * + * @category Viewing + */ + TableauEventType["CustomMarkContextMenuEvent"] = "custommarkcontextmenu"; + /** The selected marks on a visualization have changed. You can use this event type with TableauViz objects. + * + * @category Viewing + */ + TableauEventType["MarkSelectionChanged"] = "markselectionchanged"; + /** A parameter has had its value modified. You can use this event type with [[Parameter]] objects. + * + * @category Viewing + */ + TableauEventType["ParameterChanged"] = "parameterchanged"; + /** Raised when a toolbar button or control becomes available or becomes unavailable. + * + * @category Viewing + */ + TableauEventType["ToolbarStateChanged"] = "toolbarstatechanged"; + /** Raised when the workbook is ready to close. This notification is sent when using embedded web authoring functionality. + * + * @category Authoring + */ + TableauEventType["WorkbookReadyToClose"] = "workbookreadytoclose"; + /** Raised when the workbook has been published. This notification is sent when using embedded web authoring functionality. + * + * @category Authoring + */ + TableauEventType["WorkbookPublished"] = "workbookpublished"; + /** Raised when "publish as" is successful. This notification is sent when using embedded web authoring functionality. + * + * @category Authoring + */ + TableauEventType["WorkbookPublishedAs"] = "workbookpublishedas"; + /** + * Raised when a URL action occurs. See the {@link UrlActionEvent} class. + * + * @category Viewing + */ + TableauEventType["UrlAction"] = "urlaction"; + /** + * Raised after a tab switch occurs (the active sheet has changed). Guarantees the viz object will be interactive after this. + * + * @category Viewing + */ + TableauEventType["TabSwitched"] = "tabswitched"; + /** + * + * Raised after a new story point becomes active. + * + * @category Viewing + */ + TableauEventType["StoryPointSwitched"] = "storypointswitched"; + /** + * + * Raised when an error occurs while loading the contents of the webcomponent. + * + * @category Authoring, Viewing, AskData + */ + TableauEventType["VizLoadError"] = "vizloaderror"; + /** + * Raised after the iframe src attribute has been updated + * + * @category Authoring, Viewing, AskData + */ + TableauEventType["IframeSrcUpdated"] = "iframesrcupdated"; + /** + * Raised when changes are made to summary data. + * + * @category Viewing + */ + TableauEventType["SummaryDataChanged"] = "summarydatachanged"; + /** + * Raised when tableau (viz-client) is ready to receive an auth token. + * Used for authentication in salesforce native mode. + * + * @hidden + * @category Authoring, Viewing, + */ + TableauEventType["ReadyToReceiveAuthToken"] = "readytoreceiveauthtoken"; +})(TableauEventType = exports.TableauEventType || (exports.TableauEventType = {})); +/** + * Represents the location of a context menu where users can add external menu items. + */ +var ApiMenuType; +(function (ApiMenuType) { + /** External menu item will be injected in ubertip dialog */ + ApiMenuType["Ubertip"] = "ubertip"; +})(ApiMenuType = exports.ApiMenuType || (exports.ApiMenuType = {})); +/** You can use this type with a {@link Viz} object. */ +var TableauDialogType; +(function (TableauDialogType) { + /** + * Used to display the download PDF dialog. + */ + TableauDialogType["ExportPDF"] = "export-pdf"; + /** + * Used to display the download PowerPoint dialog. + */ + TableauDialogType["ExportPowerPoint"] = "export-powerpoint"; + /** + * Used to display the download Data dialog. + */ + TableauDialogType["ExportData"] = "export-data"; + /** + * Used to display the download CrossTab dialog. + */ + TableauDialogType["ExportCrossTab"] = "export-cross-tab"; + /** + * Used to display the download Workbook dialog. + */ + TableauDialogType["ExportWorkbook"] = "export-workbook"; + /** + * Used to display the Share dialog. + */ + TableauDialogType["Share"] = "share"; +})(TableauDialogType = exports.TableauDialogType || (exports.TableauDialogType = {})); + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/ExternalContract/Embedding/PulseInterfaces.js": +/*!*****************************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/ExternalContract/Embedding/PulseInterfaces.js ***! + \*****************************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * The names of the string constants you can use as HTML attributes for the web component. + * @ignore + */ +var PulseAttributes; +(function (PulseAttributes) { + PulseAttributes["DisableExploreFilter"] = "disable-explore-filter"; + PulseAttributes["Layout"] = "layout"; +})(PulseAttributes = exports.PulseAttributes || (exports.PulseAttributes = {})); + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/ExternalContract/Embedding/VizInterfaces.js": +/*!***************************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/ExternalContract/Embedding/VizInterfaces.js ***! + \***************************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * The shared string constants you can use as HTML attributes for the and web component. + * @ignore + */ +var VizSharedAttributes; +(function (VizSharedAttributes) { + VizSharedAttributes["TouchOptimize"] = "touch-optimize"; + VizSharedAttributes["HideEditInDesktopButton"] = "hide-edit-in-desktop-button"; + VizSharedAttributes["SuppressDefaultEditBehavior"] = "suppress-default-edit-behavior"; + VizSharedAttributes["DisableVersionCheck"] = "disable-version-check"; + VizSharedAttributes["OnEditInDesktopButtonClicked"] = "onEditInDesktopButtonClicked"; + VizSharedAttributes["OnFirstVizSizeKnown"] = "onFirstVizSizeKnown"; + VizSharedAttributes["OnFirstInteractive"] = "onFirstInteractive"; +})(VizSharedAttributes = exports.VizSharedAttributes || (exports.VizSharedAttributes = {})); +/** + * The names of the string constants you can use as HTML attributes for the web component. + * @ignore + */ +var VizAttributes; +(function (VizAttributes) { + VizAttributes["DisableUrlActionsPopups"] = "disable-url-actions"; + VizAttributes["HideTabs"] = "hide-tabs"; + VizAttributes["Toolbar"] = "toolbar"; + VizAttributes["InstanceIdToClone"] = "instance-id-to-clone"; + VizAttributes["Device"] = "device"; + VizAttributes["HideEditButton"] = "hide-edit-button"; + VizAttributes["OnEditButtonClicked"] = "onEditButtonClicked"; + VizAttributes["OnFilterChanged"] = "onFilterChanged"; + VizAttributes["OnCustomMarkContextMenuEvent"] = "onCustomMarkContextMenuEvent"; + VizAttributes["OnMarkSelectionChanged"] = "onMarkSelectionChanged"; + VizAttributes["OnParameterChanged"] = "onParameterChanged"; + VizAttributes["OnToolbarStateChanged"] = "onToolbarStateChanged"; + VizAttributes["OnUrlAction"] = "onUrlAction"; + VizAttributes["OnTabSwitched"] = "onTabSwitched"; + VizAttributes["OnCustomViewLoaded"] = "onCustomViewLoaded"; + VizAttributes["OnCustomViewRemoved"] = "onCustomViewRemoved"; + VizAttributes["OnCustomViewSaved"] = "onCustomViewSaved"; + VizAttributes["OnCustomViewSetDefault"] = "onCustomViewSetDefault"; + VizAttributes["OnStoryPointSwitched"] = "onStoryPointSwitched"; + VizAttributes["OnSummaryDataChanged"] = "onSummaryDataChanged"; + VizAttributes["OnReadyToReceiveAuthToken"] = "onReadyToReceiveAuthToken"; +})(VizAttributes = exports.VizAttributes || (exports.VizAttributes = {})); +/** + * The names of the string constants you can use as HTML attributes for the web component. + * @ignore + */ +var VizAuthoringAttributes; +(function (VizAuthoringAttributes) { + VizAuthoringAttributes["OnWorkbookPublished"] = "onWorkbookPublished"; + VizAuthoringAttributes["OnWorkbookPublishedAs"] = "onWorkbookPublishedAs"; + VizAuthoringAttributes["OnWorkbookReadyToClose"] = "onWorkbookReadyToClose"; + VizAuthoringAttributes["HideCloseButton"] = "hide-close-button"; +})(VizAuthoringAttributes = exports.VizAuthoringAttributes || (exports.VizAuthoringAttributes = {})); +/** + * The names of the string constants you can use as child tags for TableauViz and TableauAuthoringViz custom elements. + */ +var VizChildElements; +(function (VizChildElements) { + /** + * Contains a list of filter parameters. Available only in viewing mode. + */ + VizChildElements["VizFilter"] = "viz-filter"; + /** + * Contains a name and value for a parameter. Available only in viewing mode. + */ + VizChildElements["VizParameter"] = "viz-parameter"; + /** + * Contains a list of custom parameters. Available in both viewing and authoring modes. + */ + VizChildElements["CustomParameter"] = "custom-parameter"; +})(VizChildElements = exports.VizChildElements || (exports.VizChildElements = {})); +var VizChildElementAttributes; +(function (VizChildElementAttributes) { + VizChildElementAttributes["Field"] = "field"; + VizChildElementAttributes["Value"] = "value"; + VizChildElementAttributes["Name"] = "name"; +})(VizChildElementAttributes = exports.VizChildElementAttributes || (exports.VizChildElementAttributes = {})); + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/ExternalContract/Embedding/WebComponentInterfaces.js": +/*!************************************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/ExternalContract/Embedding/WebComponentInterfaces.js ***! + \************************************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * The names of the common string constants you can use as HTML attributes for the tableau web component. + * @ignore + */ +var WebComponentAttributes; +(function (WebComponentAttributes) { + WebComponentAttributes["Src"] = "src"; + WebComponentAttributes["Width"] = "width"; + WebComponentAttributes["Height"] = "height"; + WebComponentAttributes["Token"] = "token"; + WebComponentAttributes["Debug"] = "debug"; + WebComponentAttributes["IframeAuth"] = "iframe-auth"; + WebComponentAttributes["OnVizLoadError"] = "onvizloaderror"; + WebComponentAttributes["ForceTokenSync"] = "force-token-sync"; +})(WebComponentAttributes = exports.WebComponentAttributes || (exports.WebComponentAttributes = {})); +/** + * The names of the string constants you can use as child tags for TableauViz, TableauAuthoringViz and TableauAskData custom elements. + * @ignore + */ +var WebComponentChildElements; +(function (WebComponentChildElements) { + /** + * Contains a list of custom parameters. Available in viz viewing, viz authoring and askdata. + */ + WebComponentChildElements["CustomParameter"] = "custom-parameter"; +})(WebComponentChildElements = exports.WebComponentChildElements || (exports.WebComponentChildElements = {})); +var WebComponentChildElementAttributes; +(function (WebComponentChildElementAttributes) { + WebComponentChildElementAttributes["Field"] = "field"; + WebComponentChildElementAttributes["Value"] = "value"; + WebComponentChildElementAttributes["Name"] = "name"; +})(WebComponentChildElementAttributes = exports.WebComponentChildElementAttributes || (exports.WebComponentChildElementAttributes = {})); + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/ExternalContract/Extensions/Namespaces/Tableau.js": +/*!*********************************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/ExternalContract/Extensions/Namespaces/Tableau.js ***! + \*********************************************************************************************/ +/***/ ((module) => { + +"use strict"; + +// All enum values made available to Extensions developers. +// Enums should be kept in alphabetical order. +var Tableau; +(function (Tableau) { + /** + * All error codes used by the Extensions API. + */ + var ErrorCodes; + (function (ErrorCodes) { + /** + * Thrown when caller attempts to execute command before initialization has completed. + */ + ErrorCodes["APINotInitialized"] = "api-not-initialized"; + /** + * Thrown when caller attempts to execute command while extension is not visible. + */ + ErrorCodes["VisibilityError"] = "visibility-error"; + /** + * Only one dialog can be opened at time with the UI namespace functionality. + */ + ErrorCodes["DialogAlreadyOpen"] = "dialog-already-open"; + /** + * The open dialog was closed by the user. + */ + ErrorCodes["DialogClosedByUser"] = "dialog-closed-by-user"; + /** + * An error occurred within the Tableau Extensions API. Contact Tableau Support. + */ + ErrorCodes["InternalError"] = "internal-error"; + /** + * A dialog must start on the same domain as the parent extenion. + */ + ErrorCodes["InvalidDomainDialog"] = "invalid-dialog-domain"; + /** + * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field. + */ + ErrorCodes["InvalidParameter"] = "invalid-parameter"; + /** + * Can occur if the extension interacts with a filter that has been removed from the worksheet. + */ + ErrorCodes["MissingFilter"] = "missing-filter"; + /** + * Can occur if the extension interacts with a parameter that has been removed from the worksheet. + */ + ErrorCodes["MissingParameter"] = "missing-parameter"; + /** + * Internal Server Error + */ + ErrorCodes["ServerError"] = "server-error"; + /** + * Developer cannot save settings while another save is still in progress. + */ + ErrorCodes["SettingSaveInProgress"] = "setting-save-in-progress"; + /** + * An unknown event name was specified in the call to `addEventListener` or `removeEventListener`. + */ + ErrorCodes["UnsupportedEventName"] = "unsupported-event-name"; + /** + * A method was used for a type of data source that doesn't support that method (see getActiveTablesAsync for an example) + */ + ErrorCodes["UnsupportedMethodForDataSourceType"] = "unsupported-method-for-data-source-type"; + })(ErrorCodes = Tableau.ErrorCodes || (Tableau.ErrorCodes = {})); + /** + * The context in which the Extensions is currently running. + */ + var ExtensionContext; + (function (ExtensionContext) { + ExtensionContext["Desktop"] = "desktop"; + ExtensionContext["Server"] = "server"; + })(ExtensionContext = Tableau.ExtensionContext || (Tableau.ExtensionContext = {})); + /** + * The mode in which the Extensions is currently running. + */ + var ExtensionMode; + (function (ExtensionMode) { + ExtensionMode["Authoring"] = "authoring"; + ExtensionMode["Viewing"] = "viewing"; + })(ExtensionMode = Tableau.ExtensionMode || (Tableau.ExtensionMode = {})); + /** + * Represents the type of event that can be listened for. + */ + var TableauEventType; + (function (TableauEventType) { + /** Raised when any filter has changed state. You can use this event type with [Worksheet](../interfaces/worksheet.html) objects.*/ + TableauEventType["FilterChanged"] = "filter-changed"; + /** The selected marks on a visualization has changed. + * You can use this event type with [Worksheet](../interfaces/worksheet.html) objects. */ + TableauEventType["MarkSelectionChanged"] = "mark-selection-changed"; + /** The summary data backing a worksheet has changed + * You can use this event type with [Worksheet](../interfaces/worksheet.html) objects.*/ + TableauEventType["SummaryDataChanged"] = "summary-data-changed"; + /** A parameter has had its value modified. You can use this event type with [[Parameter]] objects. */ + TableauEventType["ParameterChanged"] = "parameter-changed"; + /** Settings have been changed for this extension. You can use this event type with [[Settings]] objects. */ + TableauEventType["SettingsChanged"] = "settings-changed"; + /** The dashboard layout has changed + * @category Dashboard Extensions + */ + TableauEventType["DashboardLayoutChanged"] = "dashboard-layout-changed"; + /** The workbook formatting has changed + * @category Dashboard Extensions + */ + TableauEventType["WorkbookFormattingChanged"] = "workbook-formatting-changed"; + })(TableauEventType = Tableau.TableauEventType || (Tableau.TableauEventType = {})); + /** + * Enum that represents the data type of encodings for createVizImageAsync. + * @since 1.6.0 + */ + var VizImageEncodingType; + (function (VizImageEncodingType) { + VizImageEncodingType["Discrete"] = "discrete"; + VizImageEncodingType["Continuous"] = "continuous"; + })(VizImageEncodingType = Tableau.VizImageEncodingType || (Tableau.VizImageEncodingType = {})); + /** + * Enum that represents the sort direction for createVizImageAsync. + * @since 1.8.0 and Tableau 2021.4 + */ + var VizImageSortDirectionType; + (function (VizImageSortDirectionType) { + VizImageSortDirectionType["Ascending"] = "ascending"; + VizImageSortDirectionType["Descending"] = "descending"; + })(VizImageSortDirectionType = Tableau.VizImageSortDirectionType || (Tableau.VizImageSortDirectionType = {})); + /** + * Enum that represents the palette type for createVizImageAsync. + * @since 1.8.0 and Tableau 2021.4 + */ + var VizImagePaletteType; + (function (VizImagePaletteType) { + VizImagePaletteType["CustomDiverging"] = "custom-diverging"; + VizImagePaletteType["CustomSequential"] = "custom-sequential"; + })(VizImagePaletteType = Tableau.VizImagePaletteType || (Tableau.VizImagePaletteType = {})); + /** + * Enum that represents the Size Setting type for createVizImageAsync. + * @since 1.8.0 and Tableau 2021.4 + */ + var VizImageSizeSettingType; + (function (VizImageSizeSettingType) { + VizImageSizeSettingType["Fixed"] = "fixed"; + VizImageSizeSettingType["Manual"] = "manual"; + })(VizImageSizeSettingType = Tableau.VizImageSizeSettingType || (Tableau.VizImageSizeSettingType = {})); + /** + * Enum that represents the Size Setting alignment type for createVizImageAsync. + * @since 1.8.0 and Tableau 2021.4 + */ + var VizImageSizeSettingAlignmentType; + (function (VizImageSizeSettingAlignmentType) { + VizImageSizeSettingAlignmentType["Right"] = "right"; + VizImageSizeSettingAlignmentType["Left"] = "left"; + VizImageSizeSettingAlignmentType["Center"] = "center"; + })(VizImageSizeSettingAlignmentType = Tableau.VizImageSizeSettingAlignmentType || (Tableau.VizImageSizeSettingAlignmentType = {})); +})(Tableau || (Tableau = {})); +module.exports = Tableau; + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/ExternalContract/Shared/Enums.js": +/*!****************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/ExternalContract/Shared/Enums.js ***! + \****************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var SharedErrorCodes; +(function (SharedErrorCodes) { + /** + * A CSV or Excel file failed to be created in Viz.exportCrosstabAsync(). + */ + SharedErrorCodes["CrosstabCreationError"] = "crosstab-creation-error"; + /** + * A CSV file failed to be created in Viz.exportDataAsync(). + */ + SharedErrorCodes["DataCreationError"] = "data-creation-error"; + /** + * An invalid aggregation was specified for the filter, such as setting a range filter to "SUM(Sales)" instead of + * "Sales". + */ + SharedErrorCodes["InvalidAggregationFieldName"] = "invalid-aggregation-field-name"; + /** + * A filter operation was attempted on a field that does not exist in the data source. + */ + SharedErrorCodes["InvalidFilterFieldName"] = "invalid-filter-name"; + /** + * A filter operation was attempted using a value that is the wrong data type or format. + */ + SharedErrorCodes["InvalidFilterFieldValue"] = "invalid-filter-fieldValue"; + /** + * An invalid date value was specified in a Sheet.selectMarksAsync() call for a date field. + */ + SharedErrorCodes["InvalidSelectionDate"] = "invalid-selection-date"; + /** + * A field was specified in a Sheet.selectMarksAsync() call that does not exist in the data source. + */ + SharedErrorCodes["InvalidSelectionFieldName"] = "invalid-selection-fieldName"; + /** + * An invalid value was specified in a Sheet.selectMarksAsync() call. + */ + SharedErrorCodes["InvalidSelectionValue"] = "invalid-selection-value"; + /** + * A parameter did not include a valid sheet selection for exporting. + */ + SharedErrorCodes["InvalidSelectionSheet"] = "invalid-selection-sheet"; + /** + * An error occurred within the Tableau API. Contact Tableau Support. + */ + SharedErrorCodes["InternalError"] = "internal-error"; + /** + * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field. + */ + SharedErrorCodes["InvalidParameter"] = "invalid-parameter"; + /** + * A PDF file failed to be created in Viz.exportPDFAsync(). + */ + SharedErrorCodes["PDFCreationError"] = "pdf-creation-error"; + /** + * A PowerPoint file failed to be created in Viz.exportPowerPointAsync(). + */ + SharedErrorCodes["PowerPointCreationError"] = "powerpoint-creation-error"; + /** + * An operation was attempted on a sheet that is not active or embedded within the active dashboard. + */ + SharedErrorCodes["NotActiveSheet"] = "not-active-sheet"; + /** + * Property or Function is not supported within the Tableau API. + */ + SharedErrorCodes["ImplementationError"] = "wrong-implementation"; + /** + * Can occur when two incompatible calls are triggered together. + */ + SharedErrorCodes["ApiExecutionError"] = "api-execution-error"; + /** + * A general-purpose server error occurred. Details are contained in the Error object. + */ + SharedErrorCodes["ServerError"] = "server-error"; + /** + * Can occur when an api call times out. + */ + SharedErrorCodes["Timeout"] = "timeout"; +})(SharedErrorCodes = exports.SharedErrorCodes || (exports.SharedErrorCodes = {})); + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/ExternalContract/Shared/Namespaces/Tableau.js": +/*!*****************************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/ExternalContract/Shared/Namespaces/Tableau.js ***! + \*****************************************************************************************/ +/***/ (function(module) { + +"use strict"; + +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +/** + * The tableau namespace exists for organization and to avoid polluting + * the global namespace. It contains no constructs other than sub-namespaces and the Tableau enumerations. + */ +var Tableau; +(function (Tableau) { + var AnalyticsObjectType; + (function (AnalyticsObjectType) { + AnalyticsObjectType["Cluster"] = "cluster"; + AnalyticsObjectType["Forecast"] = "forecast"; + AnalyticsObjectType["TrendLine"] = "trend-line"; + })(AnalyticsObjectType = Tableau.AnalyticsObjectType || (Tableau.AnalyticsObjectType = {})); + var AnnotationType; + (function (AnnotationType) { + AnnotationType["Mark"] = "mark"; + AnnotationType["Point"] = "point"; + AnnotationType["Area"] = "area"; + })(AnnotationType = Tableau.AnnotationType || (Tableau.AnnotationType = {})); + var ColumnType; + (function (ColumnType) { + ColumnType["Discrete"] = "discrete"; + ColumnType["Continuous"] = "continuous"; + ColumnType["Unknown"] = "unknown"; + })(ColumnType = Tableau.ColumnType || (Tableau.ColumnType = {})); + var ClassNameKey; + (function (ClassNameKey) { + ClassNameKey["WorksheetTitle"] = "tableau-worksheet-title"; + ClassNameKey["Worksheet"] = "tableau-worksheet"; + ClassNameKey["Tooltip"] = "tableau-tooltip"; + ClassNameKey["StoryTitle"] = "tableau-story-title"; + ClassNameKey["DashboardTitle"] = "tableau-dashboard-title"; + })(ClassNameKey = Tableau.ClassNameKey || (Tableau.ClassNameKey = {})); + /** + * What the object represents in a dashboard. + */ + var DashboardObjectType; + (function (DashboardObjectType) { + DashboardObjectType["Blank"] = "blank"; + DashboardObjectType["Worksheet"] = "worksheet"; + DashboardObjectType["QuickFilter"] = "quick-filter"; + DashboardObjectType["ParameterControl"] = "parameter-control"; + DashboardObjectType["PageFilter"] = "page-filter"; + DashboardObjectType["Legend"] = "legend"; + DashboardObjectType["Title"] = "title"; + DashboardObjectType["Text"] = "text"; + DashboardObjectType["Image"] = "image"; + DashboardObjectType["WebPage"] = "web-page"; + DashboardObjectType["Extension"] = "extension"; + })(DashboardObjectType = Tableau.DashboardObjectType || (Tableau.DashboardObjectType = {})); + /** + * Enum that represents the visibility state of a dashboard object. + * @since 1.7.0 + */ + var DashboardObjectVisibilityType; + (function (DashboardObjectVisibilityType) { + /** Used for turning on the visibility of a dashboard object.*/ + DashboardObjectVisibilityType["Show"] = "show"; + /** Used for turning off the visibility of a dashboard object.*/ + DashboardObjectVisibilityType["Hide"] = "hide"; + })(DashboardObjectVisibilityType = Tableau.DashboardObjectVisibilityType || (Tableau.DashboardObjectVisibilityType = {})); + /** + * The different types of data a value can have + */ + var DataType; + (function (DataType) { + DataType["String"] = "string"; + DataType["Int"] = "int"; + DataType["Float"] = "float"; + DataType["Bool"] = "bool"; + DataType["Date"] = "date"; + DataType["DateTime"] = "date-time"; + DataType["Spatial"] = "spatial"; + DataType["Unknown"] = "unknown"; + })(DataType = Tableau.DataType || (Tableau.DataType = {})); + /** + * Enum that represents the changes that occur to a dashboard object. + */ + var DashboardLayoutChange; + (function (DashboardLayoutChange) { + /** A dashboard object was added */ + DashboardLayoutChange["Added"] = "added"; + /** A dashboard object was removed */ + DashboardLayoutChange["Removed"] = "removed"; + /** A dashboard object's floating state changed */ + DashboardLayoutChange["IsFloatingChanged"] = "is-floating-changed"; + /** A dashboard object's visibility changed */ + DashboardLayoutChange["IsVisibleChanged"] = "is-visible-changed"; + /** A dashboard object's position changed */ + DashboardLayoutChange["PositionChanged"] = "position-changed"; + /** A dashboard object's size changed */ + DashboardLayoutChange["SizeChanged"] = "size-changed"; + /** A dashboard object was renamed */ + DashboardLayoutChange["NameChanged"] = "name-changed"; + /** A dashboard object is selected */ + DashboardLayoutChange["Selected"] = "selected"; + /** A dashboard object is deselected */ + DashboardLayoutChange["Deselected"] = "deselected"; + /** Navigate to another dashboard */ + DashboardLayoutChange["DashboardChanged"] = "dashboard-changed"; + })(DashboardLayoutChange = Tableau.DashboardLayoutChange || (Tableau.DashboardLayoutChange = {})); + /** + * Valid date ranges for a relative date filter. + */ + var DateRangeType; + (function (DateRangeType) { + DateRangeType["Last"] = "last"; + DateRangeType["LastN"] = "last-n"; + DateRangeType["Next"] = "next"; + DateRangeType["NextN"] = "next-n"; + DateRangeType["Current"] = "current"; + DateRangeType["ToDate"] = "to-date"; + })(DateRangeType = Tableau.DateRangeType || (Tableau.DateRangeType = {})); + /** + * Enum that represents the types of dialog popup styles. + */ + var DialogStyle; + (function (DialogStyle) { + DialogStyle["Window"] = "window"; + DialogStyle["Modal"] = "modal"; + DialogStyle["Modeless"] = "modeless"; + })(DialogStyle = Tableau.DialogStyle || (Tableau.DialogStyle = {})); + var EncodingType; + (function (EncodingType) { + EncodingType["Column"] = "column"; + EncodingType["Row"] = "row"; + EncodingType["Page"] = "page"; + EncodingType["Filter"] = "filter"; + EncodingType["MarksType"] = "marks-type"; + EncodingType["MeasureValues"] = "measure-values"; + EncodingType["Color"] = "color"; + EncodingType["Size"] = "size"; + EncodingType["Label"] = "label"; + EncodingType["Detail"] = "detail"; + EncodingType["Tooltip"] = "tooltip"; + EncodingType["Shape"] = "shape"; + EncodingType["Path"] = "path"; + EncodingType["Angle"] = "angle"; + EncodingType["Geometry"] = "geometry"; + EncodingType["Custom"] = "custom"; + })(EncodingType = Tableau.EncodingType || (Tableau.EncodingType = {})); + /** + * Type of aggregation on a field. + */ + var FieldAggregationType; + (function (FieldAggregationType) { + FieldAggregationType["Sum"] = "sum"; + FieldAggregationType["Avg"] = "avg"; + FieldAggregationType["Min"] = "min"; + FieldAggregationType["Max"] = "max"; + FieldAggregationType["Stdev"] = "stdev"; + FieldAggregationType["Stdevp"] = "stdevp"; + FieldAggregationType["Var"] = "var"; + FieldAggregationType["Varp"] = "varp"; + FieldAggregationType["Collect"] = "collect"; + FieldAggregationType["Count"] = "count"; + FieldAggregationType["Countd"] = "countd"; + FieldAggregationType["Median"] = "median"; + FieldAggregationType["Attr"] = "attr"; + FieldAggregationType["None"] = "none"; + FieldAggregationType["Year"] = "year"; + FieldAggregationType["Qtr"] = "qtr"; + FieldAggregationType["Month"] = "month"; + FieldAggregationType["Day"] = "day"; + FieldAggregationType["Hour"] = "hour"; + FieldAggregationType["Minute"] = "minute"; + FieldAggregationType["Second"] = "second"; + FieldAggregationType["Week"] = "week"; + FieldAggregationType["Weekday"] = "weekday"; + FieldAggregationType["MonthYear"] = "month-year"; + FieldAggregationType["Mdy"] = "mdy"; + FieldAggregationType["End"] = "end"; + FieldAggregationType["TruncYear"] = "trunc-year"; + FieldAggregationType["TruncQtr"] = "trunc-qtr"; + FieldAggregationType["TruncMonth"] = "trunc-month"; + FieldAggregationType["TruncWeek"] = "trunc-week"; + FieldAggregationType["TruncDay"] = "trunc-day"; + FieldAggregationType["TruncHour"] = "trunc-hour"; + FieldAggregationType["TruncMinute"] = "trunc-minute"; + FieldAggregationType["TruncSecond"] = "trunc-second"; + FieldAggregationType["Quart1"] = "quart1"; + FieldAggregationType["Quart3"] = "quart3"; + FieldAggregationType["Skewness"] = "skewness"; + FieldAggregationType["Kurtosis"] = "kurtosis"; + FieldAggregationType["InOut"] = "in-out"; + FieldAggregationType["User"] = "user"; + })(FieldAggregationType = Tableau.FieldAggregationType || (Tableau.FieldAggregationType = {})); + /** + * Role of a field. + */ + var FieldRoleType; + (function (FieldRoleType) { + FieldRoleType["Dimension"] = "dimension"; + FieldRoleType["Measure"] = "measure"; + FieldRoleType["Unknown"] = "unknown"; + })(FieldRoleType = Tableau.FieldRoleType || (Tableau.FieldRoleType = {})); + /** + * An enumeration of the valid types of filters that can be applied. + */ + var FilterType; + (function (FilterType) { + FilterType["Categorical"] = "categorical"; + FilterType["Range"] = "range"; + FilterType["Hierarchical"] = "hierarchical"; + FilterType["RelativeDate"] = "relative-date"; + })(FilterType = Tableau.FilterType || (Tableau.FilterType = {})); + /** + * The different update types for applying filter + */ + var FilterUpdateType; + (function (FilterUpdateType) { + FilterUpdateType["Add"] = "add"; + FilterUpdateType["All"] = "all"; + FilterUpdateType["Replace"] = "replace"; + FilterUpdateType["Remove"] = "remove"; + })(FilterUpdateType = Tableau.FilterUpdateType || (Tableau.FilterUpdateType = {})); + /** + * The domain type for a filter + */ + var FilterDomainType; + (function (FilterDomainType) { + /** + * The domain values that are relevant to the specified filter + * i.e. the domain is restricted by a previous filter + */ + FilterDomainType["Relevant"] = "relevant"; + /** + * list of all possible domain values from database + */ + FilterDomainType["Database"] = "database"; + })(FilterDomainType = Tableau.FilterDomainType || (Tableau.FilterDomainType = {})); + /** + * The option for specifying which values to include for filtering + * Indicates what to do with null values for a given filter or mark selection call. + */ + var FilterNullOption; + (function (FilterNullOption) { + FilterNullOption["NullValues"] = "null-values"; + FilterNullOption["NonNullValues"] = "non-null-values"; + FilterNullOption["AllValues"] = "all-values"; + })(FilterNullOption = Tableau.FilterNullOption || (Tableau.FilterNullOption = {})); + /** + * Enum that serves as a filter on the DataValues returned from `getSummaryDataReaderAsync`, + * `getUnderlyingTableDataReaderAsync` and `getLogicalTableDataReaderAsync`. + * This is an optimization of returned data values only. Tableau versions prior to 2021.2 + * will pass the data across and populate the DataValue properties. + * Please note that all properties not requested will be `undefined` in the DataValue results. + * @since 1.5.0 + */ + var IncludeDataValuesOption; + (function (IncludeDataValuesOption) { + /** DataValues will include all properties.*/ + IncludeDataValuesOption["AllValues"] = "all-values"; + /** DataValues will only include value and nativeValue properties.*/ + IncludeDataValuesOption["OnlyNativeValues"] = "only-native-values"; + /** DataValues will only include formattedValue properties. */ + IncludeDataValuesOption["OnlyFormattedValues"] = "only-formatted-values"; + })(IncludeDataValuesOption = Tableau.IncludeDataValuesOption || (Tableau.IncludeDataValuesOption = {})); + /** + * Type of mark for a given marks card in a viz. + */ + var MarkType; + (function (MarkType) { + MarkType["Bar"] = "bar"; + MarkType["Line"] = "line"; + MarkType["Area"] = "area"; + MarkType["Square"] = "square"; + MarkType["Circle"] = "circle"; + MarkType["Shape"] = "shape"; + MarkType["Text"] = "text"; + MarkType["Map"] = "map"; + MarkType["Pie"] = "pie"; + MarkType["GanttBar"] = "gantt-bar"; + MarkType["Polygon"] = "polygon"; + MarkType["Heatmap"] = "heatmap"; + MarkType["VizExtension"] = "viz-extension"; + })(MarkType = Tableau.MarkType || (Tableau.MarkType = {})); + /** + * An enumeration describing the different types of allowable values. + * This is used for restricting the domain of a parameter + */ + var ParameterValueType; + (function (ParameterValueType) { + ParameterValueType["All"] = "all"; + ParameterValueType["List"] = "list"; + ParameterValueType["Range"] = "range"; + })(ParameterValueType = Tableau.ParameterValueType || (Tableau.ParameterValueType = {})); + /** + * Date period used in filters and in parameters. + */ + var PeriodType; + (function (PeriodType) { + PeriodType["Years"] = "years"; + PeriodType["Quarters"] = "quarters"; + PeriodType["Months"] = "months"; + PeriodType["Weeks"] = "weeks"; + PeriodType["Days"] = "days"; + PeriodType["Hours"] = "hours"; + PeriodType["Minutes"] = "minutes"; + PeriodType["Seconds"] = "seconds"; + })(PeriodType = Tableau.PeriodType || (Tableau.PeriodType = {})); + var QuickTableCalcType; + (function (QuickTableCalcType) { + QuickTableCalcType["RunningTotal"] = "running-total"; + QuickTableCalcType["Difference"] = "difference"; + QuickTableCalcType["PercentDifference"] = "percent-difference"; + QuickTableCalcType["PercentOfTotal"] = "percent-of-total"; + QuickTableCalcType["Rank"] = "rank"; + QuickTableCalcType["Percentile"] = "percentile"; + QuickTableCalcType["MovingAverage"] = "moving-average"; + QuickTableCalcType["YTDTotal"] = "ytd-total"; + QuickTableCalcType["CompoundGrowthRate"] = "compound-growth-rate"; + QuickTableCalcType["YearOverYearGrowth"] = "year-over-year-growth"; + QuickTableCalcType["YTDGrowth"] = "ytd-growth"; + QuickTableCalcType["Undefined"] = "undefined"; + })(QuickTableCalcType = Tableau.QuickTableCalcType || (Tableau.QuickTableCalcType = {})); + /** + * Enum for specifying the selection type for select marks api. + */ + var SelectionUpdateType; + (function (SelectionUpdateType) { + SelectionUpdateType["Replace"] = "select-replace"; + SelectionUpdateType["Add"] = "select-add"; + SelectionUpdateType["Remove"] = "select-remove"; + })(SelectionUpdateType = Tableau.SelectionUpdateType || (Tableau.SelectionUpdateType = {})); + /** + * Enum for specifying the select option for the `extensions.Worksheet.selectTuplesAsync` method. + */ + var SelectOptions; + (function (SelectOptions) { + /** + * Clears existing selection before selecting the tuples specified + */ + SelectOptions["Simple"] = "select-options-simple"; + /** + * Adds specified tuples to the existing selection + */ + SelectOptions["Toggle"] = "select-options-toggle"; + })(SelectOptions = Tableau.SelectOptions || (Tableau.SelectOptions = {})); + /** + * The type of sheet a [[Sheet]] object represents + */ + var SheetType; + (function (SheetType) { + SheetType["Dashboard"] = "dashboard"; + SheetType["Story"] = "story"; + SheetType["Worksheet"] = "worksheet"; + })(SheetType = Tableau.SheetType || (Tableau.SheetType = {})); + var SortDirection; + (function (SortDirection) { + SortDirection["Increasing"] = "increasing"; + SortDirection["Decreasing"] = "decreasing"; + })(SortDirection = Tableau.SortDirection || (Tableau.SortDirection = {})); + var TrendLineModelType; + (function (TrendLineModelType) { + TrendLineModelType["Linear"] = "linear"; + TrendLineModelType["Logarithmic"] = "logarithmic"; + TrendLineModelType["Exponential"] = "exponential"; + TrendLineModelType["Polynomial"] = "polynomial"; + })(TrendLineModelType = Tableau.TrendLineModelType || (Tableau.TrendLineModelType = {})); + /** + * Enum that represents the replay speed of an animation. + * @since 1.7.0 + */ + var ReplaySpeedType; + (function (ReplaySpeedType) { + /** Used for setting the replay speed of an animation to 0.5x.*/ + ReplaySpeedType["Slow"] = "slow"; + /** Used for setting the replay speed of an animation to 1.0x.*/ + ReplaySpeedType["Normal"] = "normal"; + /** Used for setting the replay speed of an animation to 2.0x.*/ + ReplaySpeedType["Fast"] = "fast"; + })(ReplaySpeedType = Tableau.ReplaySpeedType || (Tableau.ReplaySpeedType = {})); + /** + * Enum that represents the selection state of a level in a hierarchical filter + * @since Extensions 1.10.0 + */ + var HierarchicalLevelSelectionState; + (function (HierarchicalLevelSelectionState) { + HierarchicalLevelSelectionState["AllSelected"] = "all-selected"; + HierarchicalLevelSelectionState["NoneSelected"] = "none-selected"; + HierarchicalLevelSelectionState["SomeSelected"] = "some-selected"; + HierarchicalLevelSelectionState["UnknownSelected"] = "unknown-selected"; + })(HierarchicalLevelSelectionState = Tableau.HierarchicalLevelSelectionState || (Tableau.HierarchicalLevelSelectionState = {})); + Tableau.ZoneVisibilityType = __assign({}, DashboardObjectVisibilityType); +})(Tableau || (Tableau = {})); +module.exports = Tableau; + + +/***/ }), + +/***/ "../api-external-contract-js/lib/src/SharedApiExternalContract.js": +/*!************************************************************************!*\ + !*** ../api-external-contract-js/lib/src/SharedApiExternalContract.js ***! + \************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +// This file re-exports everything which is part of the shared api public interface +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", ({ value: true })); +__export(__webpack_require__(/*! ./ExternalContract/Shared/Enums */ "../api-external-contract-js/lib/src/ExternalContract/Shared/Enums.js")); +var Tableau_1 = __webpack_require__(/*! ./ExternalContract/Shared/Namespaces/Tableau */ "../api-external-contract-js/lib/src/ExternalContract/Shared/Namespaces/Tableau.js"); +exports.AnalyticsObjectType = Tableau_1.AnalyticsObjectType; +exports.AnnotationType = Tableau_1.AnnotationType; +exports.ClassNameKey = Tableau_1.ClassNameKey; +exports.ColumnType = Tableau_1.ColumnType; +exports.DashboardLayoutChange = Tableau_1.DashboardLayoutChange; +exports.DashboardObjectType = Tableau_1.DashboardObjectType; +exports.DashboardObjectVisibilityType = Tableau_1.DashboardObjectVisibilityType; +exports.DataType = Tableau_1.DataType; +exports.DateRangeType = Tableau_1.DateRangeType; +exports.DialogStyle = Tableau_1.DialogStyle; +exports.EncodingType = Tableau_1.EncodingType; +exports.FieldAggregationType = Tableau_1.FieldAggregationType; +exports.FieldRoleType = Tableau_1.FieldRoleType; +exports.FilterDomainType = Tableau_1.FilterDomainType; +exports.FilterNullOption = Tableau_1.FilterNullOption; +exports.FilterType = Tableau_1.FilterType; +exports.FilterUpdateType = Tableau_1.FilterUpdateType; +exports.HierarchicalLevelSelectionState = Tableau_1.HierarchicalLevelSelectionState; +exports.IncludeDataValuesOption = Tableau_1.IncludeDataValuesOption; +exports.MarkType = Tableau_1.MarkType; +exports.ParameterValueType = Tableau_1.ParameterValueType; +exports.PeriodType = Tableau_1.PeriodType; +exports.QuickTableCalcType = Tableau_1.QuickTableCalcType; +exports.ReplaySpeedType = Tableau_1.ReplaySpeedType; +exports.SelectOptions = Tableau_1.SelectOptions; +exports.SelectionUpdateType = Tableau_1.SelectionUpdateType; +exports.SheetType = Tableau_1.SheetType; +exports.SortDirection = Tableau_1.SortDirection; +exports.TrendLineModelType = Tableau_1.TrendLineModelType; +exports.ZoneVisibilityType = Tableau_1.ZoneVisibilityType; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/JsApiInternalContract.js": +/*!********************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/JsApiInternalContract.js ***! + \********************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +/** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", ({ value: true })); +// The following polyfills are needed for IE11 +__webpack_require__(/*! core-js/es/number/is-integer */ "../../node_modules/core-js/es/number/is-integer.js"); +__webpack_require__(/*! core-js/es/number/is-nan */ "../../node_modules/core-js/es/number/is-nan.js"); +__webpack_require__(/*! core-js/es/object/assign */ "../../node_modules/core-js/es/object/assign.js"); +// Export the version of the internal contract to be available at runtime +// This file is generated by yarn publish:bump via scripts/publish-check.ts +// updateInternalContractRuntimeVersion in the monorepo root. +var internalContractVersion = __webpack_require__(/*! ../internal-contract-version.json */ "../api-internal-contract-js/lib/internal-contract-version.json"); +exports.INTERNAL_CONTRACT_VERSION = internalContractVersion; +__export(__webpack_require__(/*! ./contract/DataTypeConverter */ "../api-internal-contract-js/lib/src/contract/DataTypeConverter.js")); +__export(__webpack_require__(/*! ./contract/Enums */ "../api-internal-contract-js/lib/src/contract/Enums.js")); +__export(__webpack_require__(/*! ./contract/Notifications */ "../api-internal-contract-js/lib/src/contract/Notifications.js")); +__export(__webpack_require__(/*! ./contract/Parameters */ "../api-internal-contract-js/lib/src/contract/Parameters.js")); +__export(__webpack_require__(/*! ./contract/Verbs */ "../api-internal-contract-js/lib/src/contract/Verbs.js")); +__export(__webpack_require__(/*! ./interface/AskDataInterface */ "../api-internal-contract-js/lib/src/interface/AskDataInterface.js")); +__export(__webpack_require__(/*! ./interface/PulseInterface */ "../api-internal-contract-js/lib/src/interface/PulseInterface.js")); +__export(__webpack_require__(/*! ./interface/VqlInterface */ "../api-internal-contract-js/lib/src/interface/VqlInterface.js")); +__export(__webpack_require__(/*! ./messaging/CrossFrameMessenger */ "../api-internal-contract-js/lib/src/messaging/CrossFrameMessenger.js")); +__export(__webpack_require__(/*! ./messaging/interface/MessageTypes */ "../api-internal-contract-js/lib/src/messaging/interface/MessageTypes.js")); +__export(__webpack_require__(/*! ./versioning/VersionConverterFactory */ "../api-internal-contract-js/lib/src/versioning/VersionConverterFactory.js")); +__export(__webpack_require__(/*! ./versioning/external/ExternalIdentityVersionConverter */ "../api-internal-contract-js/lib/src/versioning/external/ExternalIdentityVersionConverter.js")); +__export(__webpack_require__(/*! ./versioning/external/ExternalVersionConverterFactory */ "../api-internal-contract-js/lib/src/versioning/external/ExternalVersionConverterFactory.js")); +// Export the version number of messaging for consumers to use. +// Be very careful making any updates to this contract which break version compatibility. +exports.MESSAGING_VERSION = { + major: 1, + minor: 0, + fix: 0, +}; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/contract/DataTypeConverter.js": +/*!*************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/contract/DataTypeConverter.js ***! + \*************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Enums_1 = __webpack_require__(/*! ./Enums */ "../api-internal-contract-js/lib/src/contract/Enums.js"); +var DataTypeConverter = /** @class */ (function () { + function DataTypeConverter() { + } + DataTypeConverter.isSpecial = function (valueAsString) { + // Prior to ShowDataTablePresModel, special values come to us as + // '%null%', '%all%', '%wildcard%', '%missing%'... + // While this function will never return true for ShowDataTablePresModel conversion, + // it is as cheap as passing around a version and checking that. + // (See DataValueFormatter.cpp) + if (valueAsString.length > 2 && valueAsString[0] === '%' && valueAsString[valueAsString.length - 1] === '%') { + return true; + } + return false; + }; + // tslint:disable-next-line:no-any + DataTypeConverter.parseBoolean = function (booleanString) { + // boolean values come to us as 'true'|'false' + var normalizedBoolean = booleanString.toLowerCase(); + return normalizedBoolean !== 'true' && normalizedBoolean !== 'false' ? this.specialValueIndicator : normalizedBoolean === 'true'; + }; + // tslint:disable-next-line:no-any + DataTypeConverter.parseNumber = function (valueAsString) { + var value = Number(valueAsString); + return isNaN(value) ? this.specialValueIndicator : value; + }; + DataTypeConverter.parseDate = function (dateAsString) { + // Note that without a time, the date is assumed to be UTC + // Input of 2020-03-25 is printed as: Mar 24 2020 17:00:00 GMT-0700 + // This matches style used in existing convertFilterValuePresModel + var value = new Date(dateAsString); + return Number.isNaN(value.getTime()) ? null : value; + }; + DataTypeConverter.parseDateTime = function (dateAsString) { + // With a time, the date is assumed to be UTC. + // Our date format is always: yyyy-mm-dd hh:mm:ss + // Unfortunately, IE11 can't parse that format so we add a T between the day and time. + // We also add a Z so that it is UTC. (Without the Z, some browsers assume local, and others UTC) + var formattedDateString = dateAsString.replace(' ', 'T').concat('Z'); + var value = new Date(formattedDateString); + return Number.isNaN(value.getTime()) ? null : value; + }; + // It would be nice to merge this and the method FilterConverter::convertFilterValuePresModel in api-platform-js + DataTypeConverter.convertValueAsStringToValue = function (valueAsString, type) { + // This is both DataDictionary and ShowDataTablePresModel compatible. + // In the DataDictionary, valueAsString can be '%null%' or '%missing%', while in + // ShowDataTablePresModel, we can get 'null' or 'missing', or '%null%' for string special values. + // For either of these cases, we return specialValueIndicator (or the original special string). + // To maintain backwards compatibilty, this converter: + // 1. returns a string for any special values + // 2. returns a string for any date + // Parameter min/max values can be undefined, so result is also undefined + if (valueAsString === undefined || valueAsString === null) { + return undefined; + } + if (this.isSpecial(valueAsString)) { + return valueAsString; + } + switch (type) { + case Enums_1.DataType.Bool: + return this.parseBoolean(valueAsString); + case Enums_1.DataType.Int: + case Enums_1.DataType.Float: + // Return special value '%null%' for any failure in parsing. + // We need to do that because ShowDataTablePresModel will give us strings like 'null' + // for special values. + return this.parseNumber(valueAsString); + case Enums_1.DataType.Date: + // For ShowDataTablePresModel, special values will be "null" which will fail to parse. + // In that case, we return '%null%'. + return this.parseDate(valueAsString) === null ? this.specialValueIndicator : valueAsString; + case Enums_1.DataType.DateTime: + // For ShowDataTablePresModel, special values will be "null" which will fail to parse. + // In that case, we return '%null%' + return this.parseDateTime(valueAsString) === null ? this.specialValueIndicator : valueAsString; + case Enums_1.DataType.Spatial: + case Enums_1.DataType.String: + default: + return valueAsString; + } + }; + // tslint:disable-next-line:no-any + DataTypeConverter.convertValueToNativeValue = function (value, type) { + // This converts from our 1.2 API that returns strings for specials, and dates as strings. + // It takes the special case of '%null%' and returns a null. + // For dates, it returns a Date object rather than a string. + // convertValueToNativeValue should be used to build a DataValue.nativeValue field. + // Parameter min/max can be undefined. If that is the case, nativeValue is treated like a special + if (value === undefined || value === null) { + return null; + } + switch (type) { + case Enums_1.DataType.Bool: + return typeof value === 'string' ? null : value; + case Enums_1.DataType.Int: + case Enums_1.DataType.Float: + return typeof value === 'string' ? null : value; + case Enums_1.DataType.Date: + // Convert the string to Date object (or null if parsing fails ... we assume special) + return this.parseDate(value); + case Enums_1.DataType.DateTime: + // Convert the string to Date object (or null if parsing fails ... we assume special) + return this.parseDateTime(value); + case Enums_1.DataType.String: + return this.isSpecial(value) ? null : value; + case Enums_1.DataType.Spatial: + default: + return value; + } + }; + // tslint:disable-next-line:no-any + DataTypeConverter.convertStringValueToNativeValue = function (value, type) { + // This handles the conversion from string directly to native value for all types + return this.convertValueToNativeValue(this.convertValueAsStringToValue(value, type), type); + }; + DataTypeConverter.specialValueIndicator = '%null%'; + return DataTypeConverter; +}()); +exports.DataTypeConverter = DataTypeConverter; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/contract/Enums.js": +/*!*************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/contract/Enums.js ***! + \*************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var ExtensionContext; +(function (ExtensionContext) { + ExtensionContext["Desktop"] = "desktop"; + ExtensionContext["Server"] = "server"; + ExtensionContext["Unknown"] = "unknown"; +})(ExtensionContext = exports.ExtensionContext || (exports.ExtensionContext = {})); +var ExtensionMode; +(function (ExtensionMode) { + ExtensionMode["Authoring"] = "authoring"; + ExtensionMode["Viewing"] = "viewing"; + ExtensionMode["Unknown"] = "unknown"; +})(ExtensionMode = exports.ExtensionMode || (exports.ExtensionMode = {})); +var AnnotateEnum; +(function (AnnotateEnum) { + AnnotateEnum["Mark"] = "mark"; + AnnotateEnum["Point"] = "point"; + AnnotateEnum["Area"] = "area"; +})(AnnotateEnum = exports.AnnotateEnum || (exports.AnnotateEnum = {})); +var ColumnType; +(function (ColumnType) { + ColumnType["Discrete"] = "discrete"; + ColumnType["Continuous"] = "continuous"; + ColumnType["Unknown"] = "unknown"; +})(ColumnType = exports.ColumnType || (exports.ColumnType = {})); +var DashboardObjectType; +(function (DashboardObjectType) { + DashboardObjectType["Blank"] = "blank"; + DashboardObjectType["Worksheet"] = "worksheet"; + DashboardObjectType["QuickFilter"] = "quick-filter"; + DashboardObjectType["ParameterControl"] = "parameter-control"; + DashboardObjectType["PageFilter"] = "page-filter"; + DashboardObjectType["Legend"] = "legend"; + DashboardObjectType["Title"] = "title"; + DashboardObjectType["Text"] = "text"; + DashboardObjectType["Image"] = "image"; + DashboardObjectType["WebPage"] = "web-page"; + DashboardObjectType["Extension"] = "extension"; +})(DashboardObjectType = exports.DashboardObjectType || (exports.DashboardObjectType = {})); +var DataType; +(function (DataType) { + DataType["String"] = "string"; + DataType["Int"] = "int"; + DataType["Float"] = "float"; + DataType["Bool"] = "bool"; + DataType["Date"] = "date"; + DataType["DateTime"] = "date-time"; + DataType["Spatial"] = "spatial"; + DataType["Unknown"] = "unknown"; +})(DataType = exports.DataType || (exports.DataType = {})); +var DialogStyle; +(function (DialogStyle) { + DialogStyle["Window"] = "window"; + DialogStyle["Modal"] = "modal"; + DialogStyle["Modeless"] = "modeless"; +})(DialogStyle = exports.DialogStyle || (exports.DialogStyle = {})); +var EncodedDataType; +(function (EncodedDataType) { + EncodedDataType["Number"] = "number"; + EncodedDataType["String"] = "string"; + EncodedDataType["Date"] = "date"; + EncodedDataType["Boolean"] = "boolean"; +})(EncodedDataType = exports.EncodedDataType || (exports.EncodedDataType = {})); +var ErrorCodes; +(function (ErrorCodes) { + ErrorCodes["INITIALIZATION_ERROR"] = "initialization-error"; + ErrorCodes["INTERNAL_ERROR"] = "internal-error"; + ErrorCodes["MISSING_ENUM_MAPPING"] = "missing-enum-mapping"; + ErrorCodes["MISSING_PARAMETER"] = "missing-parameter"; + ErrorCodes["PERMISSION_DENIED"] = "permission-denied"; + ErrorCodes["PRES_MODEL_PARSING_ERROR"] = "pres-model-parsing-error"; + ErrorCodes["VERSION_NOT_CONFIGURED"] = "version-not-configured"; + ErrorCodes["VISIBILITY_ERROR"] = "visibility-error"; + ErrorCodes["UNKNOWN_VERB_ID"] = "unknown-verb-id"; +})(ErrorCodes = exports.ErrorCodes || (exports.ErrorCodes = {})); +var FieldAggregationType; +(function (FieldAggregationType) { + FieldAggregationType["Sum"] = "sum"; + FieldAggregationType["Avg"] = "avg"; + FieldAggregationType["Min"] = "min"; + FieldAggregationType["Max"] = "max"; + FieldAggregationType["Stdev"] = "stdev"; + FieldAggregationType["Stdevp"] = "stdevp"; + FieldAggregationType["Var"] = "var"; + FieldAggregationType["Varp"] = "varp"; + FieldAggregationType["Collect"] = "collect"; + FieldAggregationType["Count"] = "count"; + FieldAggregationType["Countd"] = "countd"; + FieldAggregationType["Median"] = "median"; + FieldAggregationType["Attr"] = "attr"; + FieldAggregationType["None"] = "none"; + FieldAggregationType["Year"] = "year"; + FieldAggregationType["Qtr"] = "qtr"; + FieldAggregationType["Month"] = "month"; + FieldAggregationType["Day"] = "day"; + FieldAggregationType["Hour"] = "hour"; + FieldAggregationType["Minute"] = "minute"; + FieldAggregationType["Second"] = "second"; + FieldAggregationType["Week"] = "week"; + FieldAggregationType["Weekday"] = "weekday"; + FieldAggregationType["MonthYear"] = "month-year"; + FieldAggregationType["Mdy"] = "mdy"; + FieldAggregationType["End"] = "end"; + FieldAggregationType["TruncYear"] = "trunc-year"; + FieldAggregationType["TruncQtr"] = "trunc-qtr"; + FieldAggregationType["TruncMonth"] = "trunc-month"; + FieldAggregationType["TruncWeek"] = "trunc-week"; + FieldAggregationType["TruncDay"] = "trunc-day"; + FieldAggregationType["TruncHour"] = "trunc-hour"; + FieldAggregationType["TruncMinute"] = "trunc-minute"; + FieldAggregationType["TruncSecond"] = "trunc-second"; + FieldAggregationType["Quart1"] = "quart1"; + FieldAggregationType["Quart3"] = "quart3"; + FieldAggregationType["Skewness"] = "skewness"; + FieldAggregationType["Kurtosis"] = "kurtosis"; + FieldAggregationType["InOut"] = "in-out"; + FieldAggregationType["User"] = "user"; +})(FieldAggregationType = exports.FieldAggregationType || (exports.FieldAggregationType = {})); +var FieldRoleType; +(function (FieldRoleType) { + FieldRoleType["Dimension"] = "dimension"; + FieldRoleType["Measure"] = "measure"; + FieldRoleType["Unknown"] = "unknown"; +})(FieldRoleType = exports.FieldRoleType || (exports.FieldRoleType = {})); +/** + * The different update types for applying filter. + */ +var FilterUpdateType; +(function (FilterUpdateType) { + FilterUpdateType["Add"] = "add"; + FilterUpdateType["All"] = "all"; + FilterUpdateType["Replace"] = "replace"; + FilterUpdateType["Remove"] = "remove"; +})(FilterUpdateType = exports.FilterUpdateType || (exports.FilterUpdateType = {})); +var SheetType; +(function (SheetType) { + SheetType["Dashboard"] = "dashboard"; + SheetType["Story"] = "story"; + SheetType["Worksheet"] = "worksheet"; +})(SheetType = exports.SheetType || (exports.SheetType = {})); +var DomainRestrictionType; +(function (DomainRestrictionType) { + DomainRestrictionType["All"] = "all"; + DomainRestrictionType["List"] = "list"; + DomainRestrictionType["Range"] = "range"; +})(DomainRestrictionType = exports.DomainRestrictionType || (exports.DomainRestrictionType = {})); +var DateStepPeriod; +(function (DateStepPeriod) { + DateStepPeriod["Years"] = "years"; + DateStepPeriod["Quarters"] = "quarters"; + DateStepPeriod["Months"] = "months"; + DateStepPeriod["Weeks"] = "weeks"; + DateStepPeriod["Days"] = "days"; + DateStepPeriod["Hours"] = "hours"; + DateStepPeriod["Minutes"] = "minutes"; + DateStepPeriod["Seconds"] = "seconds"; +})(DateStepPeriod = exports.DateStepPeriod || (exports.DateStepPeriod = {})); +/** + * The option for specifying which values to include for filtering. + */ +var FilterNullOption; +(function (FilterNullOption) { + FilterNullOption["NullValues"] = "nullvalues"; + FilterNullOption["NonNullValues"] = "nonnullvalues"; + FilterNullOption["AllValues"] = "allvalues"; +})(FilterNullOption = exports.FilterNullOption || (exports.FilterNullOption = {})); +/** + * The type of filter domain + */ +var FilterDomainType; +(function (FilterDomainType) { + FilterDomainType["Relevant"] = "relevant"; + FilterDomainType["Database"] = "database"; +})(FilterDomainType = exports.FilterDomainType || (exports.FilterDomainType = {})); +/** + * Internal enum for specifying the selection type for select marks api. + */ +var SelectionUpdateType; +(function (SelectionUpdateType) { + SelectionUpdateType["Replace"] = "select-replace"; + SelectionUpdateType["Add"] = "select-add"; + SelectionUpdateType["Remove"] = "select-remove"; +})(SelectionUpdateType = exports.SelectionUpdateType || (exports.SelectionUpdateType = {})); +/** + * Internal enum for specifying the select option for the select tuples api. + */ +var SelectOptions; +(function (SelectOptions) { + SelectOptions["Simple"] = "select-options-simple"; + SelectOptions["Toggle"] = "select-options-toggle"; + SelectOptions["Menu"] = "select-options-menu"; + SelectOptions["Range"] = "select-options-range"; + SelectOptions["Search"] = "select-options-search"; +})(SelectOptions = exports.SelectOptions || (exports.SelectOptions = {})); +/** + * Internal enum for specifying the included values type for range selection. + */ +var QuantitativeIncludedValues; +(function (QuantitativeIncludedValues) { + QuantitativeIncludedValues["IncludeNull"] = "include-null"; + QuantitativeIncludedValues["IncludeNonNull"] = "include-non-null"; + QuantitativeIncludedValues["IncludeAll"] = "include-all"; +})(QuantitativeIncludedValues = exports.QuantitativeIncludedValues || (exports.QuantitativeIncludedValues = {})); +/** + * Internal enum for specifying a hierarchical level selection state. + */ +var HierarchicalLevelSelectionState; +(function (HierarchicalLevelSelectionState) { + HierarchicalLevelSelectionState["AllSelected"] = "all-selected"; + HierarchicalLevelSelectionState["NoneSelected"] = "none-selected"; + HierarchicalLevelSelectionState["SomeSelected"] = "some-selected"; + HierarchicalLevelSelectionState["UnknownSelected"] = "unknown-selected"; +})(HierarchicalLevelSelectionState = exports.HierarchicalLevelSelectionState || (exports.HierarchicalLevelSelectionState = {})); +/** + * Type of mark for a given marks card in a viz. + */ +var MarkType; +(function (MarkType) { + MarkType["Bar"] = "bar"; + MarkType["Line"] = "line"; + MarkType["Area"] = "area"; + MarkType["Square"] = "square"; + MarkType["Circle"] = "circle"; + MarkType["Shape"] = "shape"; + MarkType["Text"] = "text"; + MarkType["Map"] = "map"; + MarkType["Pie"] = "pie"; + MarkType["GanttBar"] = "gantt-bar"; + MarkType["Polygon"] = "polygon"; + MarkType["Heatmap"] = "heatmap"; + MarkType["VizExtension"] = "viz-extension"; +})(MarkType = exports.MarkType || (exports.MarkType = {})); +/** + * Internal enum for specifying the type of filter + */ +var FilterType; +(function (FilterType) { + FilterType["Categorical"] = "categorical"; + FilterType["Range"] = "range"; + FilterType["RelativeDate"] = "relativeDate"; + FilterType["Hierarchical"] = "hierarchical"; +})(FilterType = exports.FilterType || (exports.FilterType = {})); +/** + * Internal enum for specifying the DateRangeType of a relative date filter + */ +var DateRangeType; +(function (DateRangeType) { + /** + * Refers to the last day, week, month, etc. of the date period. + */ + DateRangeType["Last"] = "last"; + /** + * Refers to the last N days, weeks, months, etc. of the date period. + */ + DateRangeType["LastN"] = "lastN"; + /** + * Refers to the next day, week, month, etc. of the date period. + */ + DateRangeType["Next"] = "next"; + /** + * Refers to the next N days, weeks, months, etc. of the date period. + */ + DateRangeType["NextN"] = "nextN"; + /** + * Refers to the current day, week, month, etc. of the date period. + */ + DateRangeType["Current"] = "current"; + /** + * Refers to everything up to and including the current day, week, month, etc. of the date period. + */ + DateRangeType["ToDate"] = "toDate"; +})(DateRangeType = exports.DateRangeType || (exports.DateRangeType = {})); +/** + * Used to determine if the launching of an extension dialog succeeded or failed. + */ +var ExtensionDialogResult; +(function (ExtensionDialogResult) { + ExtensionDialogResult["DialogAlreadyOpen"] = "dialog-already-open"; + ExtensionDialogResult["InvalidDomain"] = "invalid-domain"; + ExtensionDialogResult["Success"] = "success"; +})(ExtensionDialogResult = exports.ExtensionDialogResult || (exports.ExtensionDialogResult = {})); +// Enumeration for ApiShowData table id sentinels. +var ApiShowDataTableSentinel; +(function (ApiShowDataTableSentinel) { + // find the one logical table - used in version compatibility check for getUnderlyingDataTable and getLogicalDataTable commands + ApiShowDataTableSentinel["SingleTableId"] = "single-table-id-sentinel"; + ApiShowDataTableSentinel["SingleTableCaption"] = "Single table id sentinel"; +})(ApiShowDataTableSentinel = exports.ApiShowDataTableSentinel || (exports.ApiShowDataTableSentinel = {})); +/** + * Used to optimize the getSummaryData/getUnderlyingTableData results + * Mapped from external IncludeDataValuesOption + */ +var ApiShowDataTableFormat; +(function (ApiShowDataTableFormat) { + ApiShowDataTableFormat["NativeValuesOnly"] = "native-values-only"; + ApiShowDataTableFormat["FormattedValuesOnly"] = "formatted-values-only"; + ApiShowDataTableFormat["NativeAndFormattedValues"] = "native-and-formatted-values"; +})(ApiShowDataTableFormat = exports.ApiShowDataTableFormat || (exports.ApiShowDataTableFormat = {})); +/** + * Used to set page size for export layout options. + */ +var PageSizeOption; +(function (PageSizeOption) { + PageSizeOption["Letter"] = "letter"; + PageSizeOption["Legal"] = "legal"; + PageSizeOption["Note"] = "note"; + PageSizeOption["Folio"] = "folio"; + PageSizeOption["Tabloid"] = "tabloid"; + PageSizeOption["Ledger"] = "ledger"; + PageSizeOption["Statement"] = "statement"; + PageSizeOption["Executive"] = "executive"; + PageSizeOption["A3"] = "a3"; + PageSizeOption["A4"] = "a4"; + PageSizeOption["A5"] = "a5"; + PageSizeOption["B4"] = "b4"; + PageSizeOption["B5"] = "b5"; + PageSizeOption["Quarto"] = "quarto"; + PageSizeOption["Unspecified"] = "unspecified"; +})(PageSizeOption = exports.PageSizeOption || (exports.PageSizeOption = {})); +/** + * Used to set the page orientation mode for export layout options. + */ +var PageOrientation; +(function (PageOrientation) { + PageOrientation["Printer"] = "printer"; + PageOrientation["Portrait"] = "portrait"; + PageOrientation["Landscape"] = "landscape"; +})(PageOrientation = exports.PageOrientation || (exports.PageOrientation = {})); +/** + * Used to set scale mode for export layout options. + */ +var ScaleMode; +(function (ScaleMode) { + ScaleMode["ScaleAuto"] = "auto"; + ScaleMode["ScalePercentage"] = "percent"; + ScaleMode["ScaleFitPages"] = "fit-pages"; +})(ScaleMode = exports.ScaleMode || (exports.ScaleMode = {})); +/** + * Used by setFitAndScaleValues to scale percent values + */ +var PageScalingOption; +(function (PageScalingOption) { + PageScalingOption["ScalePctAuto"] = "auto"; + PageScalingOption["ScalePct400"] = "pct400"; + PageScalingOption["ScalePct200"] = "pct200"; + PageScalingOption["ScalePct100"] = "pct100"; + PageScalingOption["ScalePct90"] = "pct90"; + PageScalingOption["ScalePct80"] = "pct80"; + PageScalingOption["ScalePct75"] = "pct75"; + PageScalingOption["ScalePct60"] = "pct60"; + PageScalingOption["ScalePct50"] = "pct50"; + PageScalingOption["ScalePct25"] = "pct25"; +})(PageScalingOption = exports.PageScalingOption || (exports.PageScalingOption = {})); +/** + * Used by setFitAndScaleValues to scale fit page values + */ +var FitPages; +(function (FitPages) { + FitPages["FitOneHigh"] = "fit0x1"; + FitPages["FitTwoHigh"] = "fit0x2"; + FitPages["FitOneWide"] = "fit1x0"; + FitPages["FitTwoWide"] = "fit2x0"; +})(FitPages = exports.FitPages || (exports.FitPages = {})); +/** + * Used by getVisualSpecificationAsync + */ +var EncodingType; +(function (EncodingType) { + EncodingType["Color"] = "color"; + EncodingType["Size"] = "size"; + EncodingType["Label"] = "label"; + EncodingType["Detail"] = "detail"; + EncodingType["Tooltip"] = "tooltip"; + EncodingType["Shape"] = "shape"; + EncodingType["Path"] = "path"; + EncodingType["Angle"] = "angle"; + EncodingType["Geometry"] = "geometry"; + EncodingType["Custom"] = "custom"; +})(EncodingType = exports.EncodingType || (exports.EncodingType = {})); + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/contract/Notifications.js": +/*!*********************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/contract/Notifications.js ***! + \*********************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var NotificationId; +(function (NotificationId) { + NotificationId["CustomMarkContextMenuClicked"] = "custom-mark-context-menu-clicked"; + NotificationId["ContextMenuClick"] = "context-menu-click"; + NotificationId["CustomViewRemoved"] = "custom-view-removed"; + NotificationId["CustomViewSaved"] = "custom-view-saved"; + NotificationId["CustomViewSetDefault"] = "custom-view-set-default"; + NotificationId["CustomViewsLoaded"] = "custom-views-loaded"; + NotificationId["DashboardLayoutChanged"] = "dashboard-layout-changed"; + NotificationId["EditButtonClicked"] = "edit-button-clicked"; + NotificationId["EditInDesktopButtonClicked"] = "edit-in-desktop-button-clicked"; + NotificationId["ExtensionDialogUpdate"] = "extension-dialog-update"; + NotificationId["FilterChanged"] = "filter-changed"; + NotificationId["FirstVizSizeKnown"] = "first-viz-size-known"; + NotificationId["ParameterChanged"] = "parameter-changed"; + NotificationId["SelectedMarksChanged"] = "selected-marks-changed"; + NotificationId["SettingsChanged"] = "settings-changed"; + NotificationId["SummaryDataChanged"] = "summary-data-changed"; + NotificationId["TestConversionNotification"] = "test-conversion-notification"; + NotificationId["ToolbarStateChanged"] = "toolbar-state-changed"; + NotificationId["VizInteractive"] = "viz-interactive"; + NotificationId["AskDataInteractive"] = "ask-data-interactive"; + NotificationId["WorkbookReadyToClose"] = "workbook-ready-to-close"; + NotificationId["WorkbookFormattingChanged"] = "workbook-formatting-changed"; + NotificationId["WorkbookPublished"] = "workbook-published"; + NotificationId["WorkbookPublishedAs"] = "workbook-published-as"; + NotificationId["UrlAction"] = "url-action"; + NotificationId["TabSwitched"] = "tab-switched"; + NotificationId["StoryPointSwitched"] = "story-point-switched"; + NotificationId["ReadyToReceiveAuthToken"] = "ready-to-receive-auth-token"; +})(NotificationId = exports.NotificationId || (exports.NotificationId = {})); + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/contract/Parameters.js": +/*!******************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/contract/Parameters.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +// PLEASE KEEP IN ALPHABETICAL ORDER. This helps with visually finding entries, knowing where to put +// new ones, and merge conflicts. +var ParameterId; +(function (ParameterId) { + ParameterId["ActiveTablesInfo"] = "active-tables-info"; + ParameterId["AnchorDate"] = "anchor-date"; + ParameterId["AnnotateEnum"] = "annotate-enum"; + ParameterId["AnnotationList"] = "annotation-list"; + ParameterId["CategoricalDomain"] = "categorical-domain"; + ParameterId["ClickThroughEnabled"] = "click-through-enabled"; + ParameterId["ColumnsToInclude"] = "columns-to-include"; + ParameterId["ColumnsToIncludeById"] = "columns-to-include-by-id"; + ParameterId["ConnectionDescriptionSummaries"] = "connection-description-summaries"; + ParameterId["CurrentSheetType"] = "current-sheet-type"; + ParameterId["CustomView"] = "custom-view"; + ParameterId["CustomViewIsDefault"] = "custom-view-is-default"; + ParameterId["CustomViewIsPublic"] = "custom-view-is-public"; + ParameterId["CustomViewLuid"] = "custom-view-luid"; + ParameterId["CustomViewName"] = "custom-view-name"; + ParameterId["CustomViews"] = "custom-views"; + ParameterId["Dashboard"] = "dashboard"; + ParameterId["DashboardFilters"] = "dashboard-filters"; + ParameterId["DashboardName"] = "dashboard"; + ParameterId["DashboardObjectPositionAndSizeUpdate"] = "dashboard-object-position-and-size-update"; + ParameterId["DashboardObjectPositionAndSizeUpdateList"] = "dashboard-object-position-and-size-update-list"; + ParameterId["DataRowIndex"] = "data-row-index"; + ParameterId["DataSchema"] = "data-schema"; + ParameterId["DataSource"] = "data-source"; + ParameterId["DataSourceDataTable"] = "data-source-data-table"; + ParameterId["DataSourceId"] = "data-source-id"; + ParameterId["DataSourceName"] = "data-source-name"; + ParameterId["DataTable"] = "data-table"; + ParameterId["DataTableReader"] = "data-table-reader"; + ParameterId["DateRangeType"] = "date-range-type"; + ParameterId["DeltaTimeMs"] = "delta-time-ms"; + ParameterId["DimValSelectionModels"] = "dimensionValueSelectionModels"; + ParameterId["DomainType"] = "domain-type"; + ParameterId["EmbeddingAbstractQuery"] = "embedding-abstract-query"; + ParameterId["EmbeddingBootstrapInfo"] = "embedding-bootstrap-info"; + ParameterId["ExportCrosstabSheetMap"] = "export-crosstab-sheet-map"; + ParameterId["ExportFile"] = "export-file"; + ParameterId["ExportOriginUrl"] = "export-origin-url"; + ParameterId["ExportPdfOptions"] = "export-pdf-options"; + ParameterId["ExtensionBootstrapInfo"] = "extension-bootstrap-info"; + ParameterId["ExtensionContextMenuIds"] = "extension-context-menu-ids"; + ParameterId["ExtensionDialogH"] = "extension-dialog-height"; + ParameterId["ExtensionDialogPayload"] = "extension-dialog-payload"; + ParameterId["ExtensionDialogResult"] = "extension-dialog-result"; + ParameterId["ExtensionDialogStyle"] = "extension-dialog-style"; + ParameterId["ExtensionDialogUrl"] = "extension-dialog-url"; + ParameterId["ExtensionDialogW"] = "extension-dialog-width"; + ParameterId["ExtensionLocator"] = "extension-locator"; + ParameterId["ExtensionSettingsInfo"] = "extension-settings-info"; + ParameterId["ExtensionZoneId"] = "extension-zone-id"; + ParameterId["ExternalMenuDescription"] = "external-menu-description"; + ParameterId["ExternalMenuHeader"] = "external-menu-header"; + ParameterId["ExternalMenuItemDisplayName"] = "external-menu-item-display-name"; + ParameterId["ExternalMenuItemId"] = "external-menu-item-id"; + ParameterId["Field"] = "field"; + ParameterId["FieldId"] = "field-id"; + ParameterId["FieldName"] = "field-name"; + ParameterId["FilterLevels"] = "filter-levels"; + ParameterId["FilterRangeMax"] = "filter-range-max"; + ParameterId["FilterRangeMin"] = "filter-range-min"; + ParameterId["FilterRangeNullOption"] = "filter-range-null-option"; + ParameterId["FilterUpdateType"] = "filter-update-type"; + ParameterId["FilterValues"] = "filter-values"; + ParameterId["FontNameListItems"] = "font-name-list-items"; + ParameterId["FormattedText"] = "formatted-text"; + ParameterId["FunctionName"] = "function-name"; + ParameterId["HierValSelectionModels"] = "hierarchicalValueSelectionModels"; + ParameterId["HighlightedData"] = "highlighted-data"; + ParameterId["HoverTupleInteraction"] = "hover-tuple-interaction"; + ParameterId["IgnoreAliases"] = "ignore-aliases"; + ParameterId["IgnoreSelection"] = "ignore-selection"; + ParameterId["IncludeAllColumns"] = "include-all-columns"; + ParameterId["InvalidAggFieldName"] = "invalid-agg-field-name"; + ParameterId["InvalidDates"] = "invalid-dates"; + ParameterId["InvalidFieldCaption"] = "invalid-field-caption"; + ParameterId["InvalidFields"] = "invalid-fields"; + ParameterId["InvalidValues"] = "invalid-values"; + ParameterId["IsExcludeMode"] = "is-exclude"; + ParameterId["IsExtensionDialog"] = "is-extension-dialog"; + ParameterId["JoinDescription"] = "join-description"; + ParameterId["LogicalTableId"] = "logical-table-id"; + ParameterId["LogicalTableInfoList"] = "logical-table-info-list"; + ParameterId["MaxHeight"] = "max-height"; + ParameterId["MaxRows"] = "max-rows"; + ParameterId["MaxWidth"] = "max-width"; + ParameterId["MinHeight"] = "min-height"; + ParameterId["MinWidth"] = "min-width"; + ParameterId["PageRowCount"] = "page-row-count"; + ParameterId["ParameterCaption"] = "paremeter-caption"; + ParameterId["ParameterError"] = "parameter-error"; + ParameterId["ParameterFieldName"] = "parameter-field-name"; + ParameterId["ParameterInfo"] = "parameter-info"; + ParameterId["ParameterInfos"] = "parameter-infos"; + ParameterId["ParameterValue"] = "parameter-value"; + ParameterId["PeriodType"] = "period-type"; + ParameterId["QuantitativeDomain"] = "quantitative-dmain"; + ParameterId["QuantRangeSelectionModels"] = "quantativeRangeSelectionModels"; + ParameterId["RangeN"] = "range-n"; + ParameterId["ReplaySpeed"] = "replay-speed"; + ParameterId["SelectedData"] = "selected-data"; + ParameterId["SelectedSheetNames"] = "selected-sheet-names"; + ParameterId["Selection"] = "selection"; + ParameterId["SelectionList"] = "selection-list"; + ParameterId["SelectionUpdateType"] = "selectionUpdateType"; + ParameterId["SelectTuplesInteraction"] = "select-tuples-interaction"; + ParameterId["SendNotifications"] = "send-notifications"; + ParameterId["SettingsValues"] = "settings-values"; + ParameterId["SharedFilterSheets"] = "shared-filter-sheets"; + ParameterId["SharedFiltersInfo"] = "shared-filters-info"; + ParameterId["SheetIdentifier"] = "sheet-identifier"; + ParameterId["SheetName"] = "sheet-name"; + ParameterId["SheetPath"] = "sheet-path"; + ParameterId["ShouldRefreshDS"] = "should-refresh-ds"; + ParameterId["ShowDataTableFormat"] = "show-data-table-format"; + ParameterId["State"] = "state"; + ParameterId["StoryPointIndex"] = "story-point-index"; + ParameterId["StoryPointInfo"] = "story-point-info"; + ParameterId["SwitchToSheetName"] = "switch-to-sheet-name"; + ParameterId["TargetPoint"] = "target-point"; + ParameterId["TestConversionParameter"] = "test-conversion-parameter"; + ParameterId["Text"] = "formatted-text"; + ParameterId["TooltipContext"] = "tooltip-context"; + ParameterId["TooltipTextRequest"] = "tooltip-text-request"; + ParameterId["TooltipText"] = "tooltip-text"; + ParameterId["UnderlyingDataTable"] = "underlying-data-table"; + ParameterId["UnderlyingSummaryDataTable"] = "underlying-summary-data-table"; + ParameterId["Url"] = "url"; + ParameterId["UseTabDelimiters"] = "use-tab-delimiters"; + ParameterId["ViewDataTableCacheId"] = "view-data-table-cache-id"; + ParameterId["ViewDataTableId"] = "view-data-table-id"; + ParameterId["VisualId"] = "visual-id"; + ParameterId["VisualSpecification"] = "visual-specification"; + ParameterId["VizAPIInputJson"] = "vizapi-input-json"; + ParameterId["VizAPIStateWithDataModel"] = "vizapi-state-with-data-model"; + ParameterId["VizAPIStateWarningMsg"] = "vizapi-state-warning-msg"; + ParameterId["VizAPISVG"] = "vizapi-svg"; + ParameterId["WorksheetName"] = "worksheet-name"; + ParameterId["WorksheetFilters"] = "worksheet-filters"; + ParameterId["ZoneIdsVisibilityMap"] = "zone-ids-visibility-map"; +})(ParameterId = exports.ParameterId || (exports.ParameterId = {})); + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/contract/Verbs.js": +/*!*************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/contract/Verbs.js ***! + \*************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +// Declare this key type and export the NotificationId to make this behave like a string enum. +// +// PLEASE KEEP IN ALPHABETICAL ORDER. This helps with visually finding entries, knowing where to put +// new ones, and merge conflicts. +var VerbId; +(function (VerbId) { + VerbId["ActivateNextStoryPoint"] = "activate-next-story-point"; + VerbId["ActivatePreviousStoryPoint"] = "activate-previous-story-point"; + VerbId["ActivateSheet"] = "activateSheet"; + VerbId["ActivateStoryPoint"] = "activate-story-point"; + VerbId["AppendExternalMenuItem"] = "append-external-menu-item"; + VerbId["ApplyCategoricalFilter"] = "categorical-filter"; + VerbId["ApplyRangeFilter"] = "range-filter"; + VerbId["ApplyRelativeDateFilter"] = "apply-relative-date-Filter"; + VerbId["Authenticate"] = "authenticate"; + VerbId["BlockExtension"] = "block-extension"; + VerbId["ChangeParameterValue"] = "change-parameter-value"; + VerbId["ChangeSharedFilter"] = "change-shared-filter"; + VerbId["ClearFilter"] = "clear-filter"; + VerbId["ClearSelectedMarks"] = "clear-selected-marks"; + VerbId["CloseDialog"] = "close-dialog"; + VerbId["CreateAnnotation"] = "create-annotation"; + VerbId["DashboardCategoricalFilter"] = "dashboard-categorical-filter"; + VerbId["DisplayDialog"] = "display-dialog"; + VerbId["DownloadWorkbook"] = "download-workbook"; + VerbId["ExecuteExternalMenuItem"] = "execute-external-menu-item"; + VerbId["ExportCrosstab"] = "export-crosstab"; + VerbId["ExportCrosstabCsvDownload"] = "export-crosstab-csv-download"; + VerbId["ExportCrosstabExcelDownload"] = "export-crosstab-excel-download"; + VerbId["ExportData"] = "export-data"; + VerbId["ExportDataDownload"] = "export-data-download"; + VerbId["ExportImage"] = "export-image"; + VerbId["ExportPdf"] = "export-pdf"; + VerbId["ExportPdfDownload"] = "export-pdf-download"; + VerbId["ExportPowerpoint"] = "export-powerpoint"; + VerbId["ExportPowerpointDownload"] = "export-powerpoint-download"; + VerbId["FindParameter"] = "find-parameter"; + VerbId["GetActiveTables"] = "get-active-tables"; + VerbId["GetAllDataSources"] = "get-all-data-sources"; + VerbId["GetAnnotations"] = "get-annotations"; + VerbId["GetCategoricalDomain"] = "get-categorical-domain"; + VerbId["GetConnectionDescriptionSummaries"] = "get-connection-description-summaries"; + VerbId["GetCurrentSrc"] = "get-current-src"; + VerbId["GetCustomViews"] = "get-custom-views"; + VerbId["GetDashboardFilters"] = "get-dashboard-filters"; + VerbId["GetDataSource"] = "get-datasource"; + VerbId["GetDataSourceData"] = "get-datasource-data"; + VerbId["GetDataSources"] = "get-data-sources"; + VerbId["GetDataSummaryData"] = "get-summary-data"; + VerbId["GetDataSummaryDataReader"] = "get-summary-data-reader"; + VerbId["GetDataTableReaderPage"] = "get-data-table-reader-page"; + VerbId["GetEmbeddingAbstractQueryWithDataModel"] = "get-embedding-abstract-query-with-data-model"; + VerbId["GetEmbeddingClientInfo"] = "get-embedding-client-info"; + VerbId["GetVizStateWithDataModel"] = "get-viz-state-with-data-model"; + VerbId["GetExportCrosstabSheetMap"] = "get-export-crosstab-sheet-map"; + VerbId["GetExportPdfOptions"] = "get-export-pdf-options"; + VerbId["GetField"] = "get-field"; + VerbId["GetFieldAndDataSource"] = "get-field-and-datasource"; + VerbId["GetVisualSpecification"] = "get-visual-specification"; + VerbId["GetFilters"] = "get-filters"; + VerbId["GetFonts"] = "get-fonts"; + VerbId["GetHighlightedMarks"] = "get-highlighted-marks"; + VerbId["GetJoinDescription"] = "get-join-description"; + VerbId["GetLogicalTableData"] = "get-logical-table-data"; + VerbId["GetLogicalTableDataReader"] = "get-logical-table-data-reader"; + VerbId["GetLogicalTables"] = "get-logical-tables"; + VerbId["GetParametersForSheet"] = "get-parameters-for-sheet"; + VerbId["GetRangeDomain"] = "get-range-domain"; + VerbId["GetSelectedMarks"] = "get-selected-marks"; + VerbId["GetSharedFilter"] = "get-shared-filter"; + VerbId["GetTooltipText"] = "get-tooltip-text"; + VerbId["GetUnderlyingData"] = "get-underlying-data"; + VerbId["GetUnderlyingTableData"] = "get-underlying-table-data"; + VerbId["GetUnderlyingTableDataReader"] = "get-underlying-table-data-reader"; + VerbId["GetUnderlyingTables"] = "get-underlying-tables"; + VerbId["HierarchicalFilter"] = "hierachical-filter"; + VerbId["InitializeExtension"] = "initialize-extension"; + VerbId["MoveAndResizeZones"] = "move-and-resize-zones"; + VerbId["RaiseLeaveMarkNavNotification"] = "raise-leave-mark-nav-notification"; + VerbId["RaiseHoverTupleNotification"] = "raise-hover-tuple-notification"; + VerbId["RaiseSelectTuplesNotification"] = "raise-select-tuples-notification"; + VerbId["Redo"] = "redo"; + VerbId["RefreshDataSource"] = "refresh-data-source"; + VerbId["ReleaseDataTableReader"] = "release-data-table-reader"; + VerbId["RemoveAnnotation"] = "remove-annotation"; + VerbId["RemoveCustomView"] = "remove-custom-view"; + VerbId["RemoveExternalMenuItem"] = "remove-external-menu-item"; + VerbId["RenameExternalMenu"] = "rename-external-menu"; + VerbId["ReplayAnimation"] = "replay-animation"; + VerbId["RevertStoryPoint"] = "revert-story-point"; + VerbId["RevertWorkbook"] = "revert-workbook"; + VerbId["SaveExtensionSettings"] = "save-extension-settings"; + VerbId["SaveWorkbookAsCustomView"] = "save-workbook-as-custom-view"; + VerbId["SelectByValue"] = "select-by-value"; + VerbId["SetActiveCustomViewAsDefault"] = "set-active-custom-view-as-default"; + VerbId["SetAutoUpdate"] = "set-auto-update"; + VerbId["SetClickThrough"] = "set-click-through"; + VerbId["SetVizStateWithDataModel"] = "set-viz-state-with-data-model"; + VerbId["SetSheetSize"] = "set-sheet-size"; + VerbId["SetZoneVisibility"] = "set-zone-visibility"; + VerbId["Share"] = "share"; + VerbId["ShowCustomView"] = "show-custom-view"; + VerbId["TestConversionVerb"] = "test-conversion-verb"; + VerbId["Undo"] = "undo"; + VerbId["UpdateCustomView"] = "update-custom-view"; + VerbId["VizAPI"] = "viz-api"; +})(VerbId = exports.VerbId || (exports.VerbId = {})); + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/interface/AskDataInterface.js": +/*!*************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/interface/AskDataInterface.js ***! + \*************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var AskDataOptionNames; +(function (AskDataOptionNames) { + AskDataOptionNames["token"] = "token"; + AskDataOptionNames["origin"] = "origin"; + AskDataOptionNames["showEmbed"] = "showEmbed"; + AskDataOptionNames["showPin"] = "showPin"; + AskDataOptionNames["showSave"] = "showSave"; + AskDataOptionNames["showShare"] = "showShare"; + AskDataOptionNames["debug"] = ":jsdebug"; + AskDataOptionNames["ApiID"] = ":apiID"; + AskDataOptionNames["ApiExternalVersion"] = ":apiExternalVersion"; + AskDataOptionNames["ApiInternalVersion"] = ":apiInternalVersion"; + AskDataOptionNames["AskDataWebComponent"] = ":askDataWebComponent"; +})(AskDataOptionNames = exports.AskDataOptionNames || (exports.AskDataOptionNames = {})); + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/interface/PulseInterface.js": +/*!***********************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/interface/PulseInterface.js ***! + \***********************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var PulseOptionNames; +(function (PulseOptionNames) { + PulseOptionNames["embed"] = "embed"; + PulseOptionNames["token"] = "token"; + PulseOptionNames["disableExploreFilter"] = "disableExploreFilter"; + PulseOptionNames["layout"] = "embed_layout"; + PulseOptionNames["ApiExternalVersion"] = ":apiExternalVersion"; + PulseOptionNames["ApiInternalVersion"] = ":apiInternalVersion"; + PulseOptionNames["PulseWebComponent"] = ":pulseWebComponent"; +})(PulseOptionNames = exports.PulseOptionNames || (exports.PulseOptionNames = {})); + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/interface/VqlInterface.js": +/*!*********************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/interface/VqlInterface.js ***! + \*********************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * These strings were *manually copied* from the server, + * workgroup/src/silos/tableau-server/libraries/tab-controller-vizql/src/com/tableausoftware/ + * controller/vizql/constants/ParameterKeys.java#L9 + * should be exported instead + * parameters that vizql will accept in an embedding URL + **/ +var VqlParameterNames; +(function (VqlParameterNames) { + VqlParameterNames["ONE"] = "1"; + VqlParameterNames["ALERTS"] = ":alerts"; + VqlParameterNames["ALIAS"] = "alias"; + VqlParameterNames["ALLOW_DEFERRED_BOOTSTRAP"] = ":allowDeferredBootstrap"; + VqlParameterNames["ALLOW_AUTOGEN_WORKSHEET_PHONE_LAYOUTS"] = "allowAutogenWorksheetPhoneLayouts"; + VqlParameterNames["API_ID"] = ":apiID"; + VqlParameterNames["APP"] = ":app"; + VqlParameterNames["ATTACHMENT"] = "attachment"; + VqlParameterNames["IS_IPAD_APP"] = "app"; + VqlParameterNames["ANIMATE_TRANSITION"] = ":animate_transition"; + VqlParameterNames["ASCENDING"] = "ascending"; + VqlParameterNames["AUTHENTICATION"] = "authentication"; + VqlParameterNames["ATTRIBUTES"] = "attributes"; + VqlParameterNames["AUTHORING_SHEET"] = ":authSheet"; + VqlParameterNames["AXIS"] = "axis"; + VqlParameterNames["BOOTSTRAP_WHEN_NOTIFIED"] = ":bootstrapWhenNotified"; + VqlParameterNames["BROWSER_BACK_BUTTON_UNDO"] = ":browserBackButtonUndo"; + VqlParameterNames["BROWSER_RENDERING_ON"] = "isBrowserRendering"; + VqlParameterNames["BROWSER_RENDERING_THRESHOLD"] = "browserRenderingThreshold"; + VqlParameterNames["CHARSET"] = "charset"; + VqlParameterNames["CLIENT_DIMENSION"] = "clientDimension"; + VqlParameterNames["CLIENT_IP"] = "client_ip"; + VqlParameterNames["CLIENT_NUM"] = "clientNum"; + VqlParameterNames["COLON_EMBEDDED"] = ":embedded"; + VqlParameterNames["COLON_MOBILE"] = ":mobile"; + VqlParameterNames["COLON_DEEP_LINKING_DISABLED"] = ":deepLinkingDisabled"; + VqlParameterNames["COLON_WATERMARK"] = ":watermark"; + VqlParameterNames["COMMENTS"] = ":comments"; + VqlParameterNames["COMMENTING_ENABLED"] = ":commentingEnabled"; + VqlParameterNames["COMMENTING_MENTIONS_ENABLED"] = ":commentingMentions"; + VqlParameterNames["CONNECTION"] = "connection"; + VqlParameterNames["CREATED_BY_FEATURE"] = "createdByFeature"; + VqlParameterNames["CRYPTED_PASSWORD"] = "crypted"; + VqlParameterNames["CSSDEBUG"] = ":cssdebug"; + VqlParameterNames["CSV"] = "csv"; + VqlParameterNames["CUSTOM_VIEWS"] = ":customViews"; + VqlParameterNames["CV"] = ":cv"; + VqlParameterNames["CV_ID"] = "cvId"; + VqlParameterNames["DASHBOARD_PORT_SIZE"] = "dashboardPortSize"; + VqlParameterNames["DATA_DETAILS"] = ":dataDetails"; + VqlParameterNames["DATASOURCE"] = "datasource"; + VqlParameterNames["DEBUG"] = ":debug"; + VqlParameterNames["DELAY"] = ":delay"; + VqlParameterNames["DEPTH"] = "depth"; + VqlParameterNames["DEVICE_TYPE"] = ":device"; + VqlParameterNames["DEVICE_PIXEL_RATIO"] = "devicePixelRatio"; + VqlParameterNames["DEVICE_PREVIEW_MODE"] = ":devicepreviewmode"; + VqlParameterNames["DIMENSIONS"] = ":dimensions"; + VqlParameterNames["DISABLE_SHARED_SESSIONS"] = ":disable_shared_sessions"; + VqlParameterNames["DISABLE_URL_ACTIONS_POPUPS"] = ":disableUrlActionsPopups"; + VqlParameterNames["DIRECTION"] = "direction"; + VqlParameterNames["DISPLAY_OVERLAY"] = ":display_overlay"; + VqlParameterNames["DISPLAY_SHARE"] = ":display_share"; + VqlParameterNames["DISPLAY_SPINNER"] = ":display_spinner"; + VqlParameterNames["DISPLAY_STATIC_IMAGE"] = ":display_static_image"; + VqlParameterNames["DISPLAY_TABS"] = "display_tabs"; + VqlParameterNames["DISPLAY_VIEW_COUNT"] = ":display_count"; + VqlParameterNames["IGNORE_STICKY_SESSION"] = ":ignore_sticky_session"; + VqlParameterNames["INCREMENT_VIEW_COUNT"] = ":increment_view_count"; + VqlParameterNames["DOCMODE"] = "docmode"; + VqlParameterNames["DOMAIN"] = "domain"; + VqlParameterNames["DO_WORK"] = "do_work"; + VqlParameterNames["DX"] = "dx"; + VqlParameterNames["DY"] = "dy"; + VqlParameterNames["EDIT_DATA_ALERT"] = ":editDataAlert"; + VqlParameterNames["EMBED"] = ":embed"; + VqlParameterNames["EMBEDDED"] = "embedded"; + VqlParameterNames["ENCRYPTED"] = "encrypted"; + VqlParameterNames["API_EXTERNAL_VERSION"] = ":apiExternalVersion"; + VqlParameterNames["API_INTERNAL_VERSION"] = ":apiInternalVersion"; + VqlParameterNames["EXCLUDE"] = "exclude"; + VqlParameterNames["EXPORT_FORMAT"] = ":export_format"; + VqlParameterNames["FIELDNAME"] = "fieldname"; + VqlParameterNames["FIELD_NAME"] = "field_name"; + VqlParameterNames["FIELD_SEP"] = "field_sep"; + VqlParameterNames["FILE"] = "file"; + VqlParameterNames["FILTER_TILE_SIZE"] = "filterTileSize"; + VqlParameterNames["FN"] = "fn"; + VqlParameterNames["FOCUS"] = "focus"; + VqlParameterNames["FORCE_CACHE"] = "force_cache"; + VqlParameterNames["FORMAT"] = "format"; + VqlParameterNames["FORMAT_DATA_VALUE_LOCALLY"] = "formatDataValueLocally"; + VqlParameterNames["FROM_WG"] = ":from_wg"; + VqlParameterNames["GRAPHQL_DATABASE_ID"] = ":graphQLDatabaseId"; + VqlParameterNames["GRAPHQL_TABLE_ID"] = ":graphQLTableId"; + VqlParameterNames["GUID"] = ":guid"; + VqlParameterNames["H"] = "h"; + VqlParameterNames["HIDDEN"] = "hidden"; + VqlParameterNames["HIDE_CLOSE_BUTTON"] = ":hideCloseButton"; + VqlParameterNames["HIDE_EDIT_BUTTON"] = ":hideEditButton"; + VqlParameterNames["HIDE_EDIT_IN_DESKTOP_BUTTON"] = ":hideEditInDesktopButton"; + VqlParameterNames["HIGH_DPI"] = ":highdpi"; + VqlParameterNames["IMAGE_SIZE_LIMIT"] = "imageSizeLimit"; + VqlParameterNames["TRANSPARENT_LINE_MARKS_LIMIT"] = "transparentLineMarkLimit"; + VqlParameterNames["CLIENT_RENDER_PIXEL_LIMIT"] = "clientRenderPixelLimit"; + VqlParameterNames["IN"] = "in"; + VqlParameterNames["INSTANCE_ID"] = ":iid"; + VqlParameterNames["IS_GUEST_REDIRECT_FROM_VIZPORTAL"] = ":isGuestRedirectFromVizportal"; + VqlParameterNames["IS_MARK_ANIMATION_ENABLED"] = "isMarkAnimationEnabled"; + VqlParameterNames["IS_VIZPORTAL"] = ":isVizPortal"; + VqlParameterNames["INPUT_"] = "input_string"; + VqlParameterNames["JSDEBUG"] = ":jsdebug"; + VqlParameterNames["JSON"] = "json"; + VqlParameterNames["JSON_ONLY"] = ":jsonOnly"; + VqlParameterNames["KEEPFILE"] = "keepfile"; + VqlParameterNames["KEY"] = "key"; + VqlParameterNames["LANGUAGE"] = "language"; + VqlParameterNames["LANGUAGE_REQUESTED"] = ":language"; + VqlParameterNames["LINKTARGET"] = ":linktarget"; + VqlParameterNames["LOAD_ORDER_ID"] = ":loadOrderID"; + VqlParameterNames["LOAD_NEWEST_REVISION"] = ":loadNewestRevision"; + VqlParameterNames["LOCAL_PATHS"] = ":localPaths"; + VqlParameterNames["LOCALE"] = "locale"; + VqlParameterNames["LOCATION_ID"] = "locationid"; + VqlParameterNames["LOCATION_TYPE"] = "locationtype"; + VqlParameterNames["WORKBOOK_LOCALE"] = "workbookLocale"; + VqlParameterNames["MAXROWS"] = "maxrows"; + VqlParameterNames["MAX_AGE"] = "maxAge"; + VqlParameterNames["MAX_ROWS"] = "maxRows"; + VqlParameterNames["METHOD"] = "method"; + VqlParameterNames["MOBILE"] = "mobile"; + VqlParameterNames["MODIFIER"] = "modifier"; + VqlParameterNames["NAME"] = "name"; + VqlParameterNames["NAV_TYPE"] = "navType"; + VqlParameterNames["NAV_SRC"] = "navSrc"; + VqlParameterNames["NOATTACHMENT"] = "no-attachment"; + VqlParameterNames["NO_OVERWRITE"] = "no_overwrite"; + VqlParameterNames["OPEN_AUTHORING_IN_TOP_WINDOW"] = ":openAuthoringInTopWindow"; + VqlParameterNames["OPENID_HD"] = ":openid_hd"; + VqlParameterNames["OPENID_LOGIN_HINT"] = ":openid_login_hint"; + VqlParameterNames["OAUTHREQUEST"] = "oauthrequest"; + VqlParameterNames["OAUTH_CREDENTIAL_IDS"] = "oauth_credential_ids"; + VqlParameterNames["OFFLINE_MODE"] = ":offlinemode"; + VqlParameterNames["ORIGIN"] = ":origin"; + VqlParameterNames["OVERLAY"] = ":overlay"; + VqlParameterNames["P"] = "p"; + VqlParameterNames["PATH"] = "path"; + VqlParameterNames["PANE_RESOLVER_X"] = "paneResolverX"; + VqlParameterNames["PANE_RESOLVER_Y"] = "paneResolverY"; + VqlParameterNames["PARAM"] = "param"; + VqlParameterNames["PARENT_ID"] = "parent_id"; + VqlParameterNames["PASSWORD"] = "password"; + VqlParameterNames["PATTERN"] = "pattern"; + VqlParameterNames["PIXEL_RATIO"] = ":pixelratio"; + VqlParameterNames["PREFIX"] = ":prefix"; + VqlParameterNames["PREVIEW"] = ":preview"; + VqlParameterNames["PRIMARY_CONTENT_URL"] = "primary_content_url"; + VqlParameterNames["PROJECT"] = "project"; + VqlParameterNames["PROTOCOL"] = "protocol"; + VqlParameterNames["PSEUDO"] = ":pseudo"; + VqlParameterNames["QUERY"] = "query"; + VqlParameterNames["R"] = "r"; + VqlParameterNames["RANGE_TYPE"] = "range_type"; + VqlParameterNames["RECORD_SEP"] = "record_sep"; + VqlParameterNames["RECORD_CLIENT_PERFORMANCE"] = ":record_client_performance"; + VqlParameterNames["RECORD_PERFORMANCE"] = ":record_performance"; + VqlParameterNames["RECOVER_OLD_SESSION_ID"] = ":recover_old_session_id"; + VqlParameterNames["RECOVER_SESSION_STATE_TICKETS"] = ":recover_session_state_tickets"; + VqlParameterNames["REFRESH"] = ":refresh"; + VqlParameterNames["REFRESHUNMODIFIED"] = ":refreshunmodified"; + VqlParameterNames["REGION"] = "region"; + VqlParameterNames["RELOAD_ON_CUSTOM_VIEW_SAVE"] = ":reloadOnCustomViewSave"; + VqlParameterNames["RENDER"] = ":render"; + VqlParameterNames["RENDER_MAPS_CLIENT_SIDE"] = "renderMapsClientSide"; + VqlParameterNames["RETRY"] = ":retry"; + VqlParameterNames["REUSE"] = "reuse"; + VqlParameterNames["REUSE_FOREVER"] = "reuse_forever"; + VqlParameterNames["REVERT"] = ":revert"; + VqlParameterNames["SAVE_DB_PASSWORDS"] = "save_db_passwords"; + VqlParameterNames["SELECT_X"] = "select_x"; + VqlParameterNames["SELECT_Y"] = "select_y"; + VqlParameterNames["SESSION_FEATURE_PREFIX"] = ":ff_"; + VqlParameterNames["SESSION_FLAGS"] = ":session_feature_flags"; + VqlParameterNames["SHARE_BUTTON"] = "share_button"; + VqlParameterNames["SHEET_ID"] = "sheet_id"; + VqlParameterNames["SHARED"] = "shared"; + VqlParameterNames["SHOWALL"] = "showall"; + VqlParameterNames["SHOW_APP_BANNER"] = ":showAppBanner"; + VqlParameterNames["SHOW_ASK_DATA"] = ":showAskData"; + VqlParameterNames["SHOW_PARAMS"] = "showParams"; + VqlParameterNames["SHOW_SHARE_OPTIONS"] = ":showShareOptions"; + VqlParameterNames["SIZE"] = ":size"; + VqlParameterNames["SOURCE"] = "source"; + VqlParameterNames["STATE"] = "state"; + VqlParameterNames["STICKY_SESSION_KEY"] = "stickySessionKey"; + VqlParameterNames["SUBSCRIPTIONS"] = ":subscriptions"; + VqlParameterNames["SUMMARY"] = "summary"; + VqlParameterNames["SUPPRESS_DEFAULT_EDIT_BEHAVIOR"] = ":suppressDefaultEditBehavior"; + VqlParameterNames["SYNC_SESSION"] = ":sync_session"; + VqlParameterNames["SYNC_SESSION_STATE"] = "sync_session_state"; + VqlParameterNames["TABS"] = ":tabs"; + VqlParameterNames["TARGET"] = "target"; + VqlParameterNames["TARGET_SITE"] = "target_site"; + VqlParameterNames["TOOLBAR"] = ":toolbar"; + VqlParameterNames["TOOLTIP"] = ":tooltip"; + VqlParameterNames["TS"] = "ts"; + VqlParameterNames["UNDERLYING_TABLE_ID"] = "underlying_table_id"; + VqlParameterNames["UNDERLYING_TABLE_CAPTION"] = "underlying_table_caption"; + VqlParameterNames["UPDATE_TYPE"] = "update_type"; + VqlParameterNames["USE_GUEST"] = ":useGuest"; + VqlParameterNames["USE_INLINE_IMAGES"] = "use_inline_images"; + VqlParameterNames["USERAGENT"] = "useragent"; + VqlParameterNames["USERNAME"] = "username"; + VqlParameterNames["VALUE"] = "value"; + VqlParameterNames["VERBOSE_MODE"] = "verboseMode"; + VqlParameterNames["VIEW_ID"] = "views_id"; + VqlParameterNames["VIZ_SNAPSHOT_ID"] = "viz_snapshot_id"; + VqlParameterNames["VW"] = ":vw"; + VqlParameterNames["W"] = "w"; + VqlParameterNames["WORKSHEET_PORT_SIZE"] = "worksheetPortSize"; + VqlParameterNames["WATERMARK"] = "watermark"; + VqlParameterNames["WATERMARK_MARGIN"] = ":watermark_margin"; + VqlParameterNames["WB"] = ":wb"; + VqlParameterNames["WHICH"] = "which"; + VqlParameterNames["X"] = "x"; + VqlParameterNames["Y"] = "y"; + VqlParameterNames["ZID"] = "zid"; + VqlParameterNames["ZONE_ID"] = "zone_id"; + VqlParameterNames["KEYCHAIN_VERSION"] = "keychain_version"; + VqlParameterNames["DATASOURCE_ID"] = "datasource_id"; + VqlParameterNames["DATASOURCE_NAME"] = "datasource_name"; + VqlParameterNames["LENS_ID"] = "lens_id"; + VqlParameterNames["WIDTH"] = "width"; + VqlParameterNames["HEIGHT"] = "height"; + // Default Layout params + VqlParameterNames["LAYOUT_VIEWS"] = "views"; + VqlParameterNames["LAYOUT_MENUS"] = "menus"; + VqlParameterNames["LAYOUT_GEOMETRY"] = "geometry"; + VqlParameterNames["LAYOUT_PAGES"] = "pages"; + VqlParameterNames["LAYOUT_CACHEURL"] = "cacheurl"; + VqlParameterNames["LAYOUT_SHEET"] = "sheet"; + VqlParameterNames["LAYOUT_DEPTH"] = "depth"; +})(VqlParameterNames || (VqlParameterNames = {})); +/** + * parameters that are only relevant when working with Tableau Public + * maybe not really necessry to split them out + */ +var PublicParameterNames; +(function (PublicParameterNames) { + PublicParameterNames["SHOW_VIZ_HOME"] = ":showVizHome"; + // display view count +})(PublicParameterNames || (PublicParameterNames = {})); +/** + * Map the parameter names as used in the url to what we call them publicly in the embedding library. + * The only parameters listed here should be the ones that get sent to vizql + * - this should match the interface at external-contract:VizInterfaces:VizSettings + */ +var VizOptionNames; +(function (VizOptionNames) { + // publicName = internalStringValue + VizOptionNames["Size"] = ":size"; + VizOptionNames["Embed"] = ":embed"; + VizOptionNames["ApiInternalVersion"] = ":apiInternalVersion"; + VizOptionNames["ApiExternalVersion"] = ":apiExternalVersion"; + VizOptionNames["ShowVizHome"] = ":showVizHome"; + VizOptionNames["Jsdebug"] = ":jsdebug"; + VizOptionNames["BootstrapWhenNotified"] = ":bootstrapWhenNotified"; + VizOptionNames["NavType"] = "navType"; + VizOptionNames["NavSrc"] = "navSrc"; + VizOptionNames["debug"] = ":jsdebug"; + VizOptionNames["ApiID"] = ":apiID"; + VizOptionNames["disableUrlActionsPopups"] = ":disableUrlActionsPopups"; + VizOptionNames["hideTabs"] = ":tabs"; + VizOptionNames["toolbar"] = ":toolbar"; + VizOptionNames["device"] = ":device"; + VizOptionNames["instanceIdToClone"] = ":iid"; + VizOptionNames["touchOptimize"] = "mobile"; + VizOptionNames["hideEditButton"] = ":hideEditButton"; + VizOptionNames["hideEditInDesktopButton"] = ":hideEditInDesktopButton"; + VizOptionNames["suppressDefaultEditBehavior"] = ":suppressDefaultEditBehavior"; + VizOptionNames["hideCloseButton"] = ":hideCloseButton"; +})(VizOptionNames = exports.VizOptionNames || (exports.VizOptionNames = {})); + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/messaging/CrossFrameMessenger.js": +/*!****************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/messaging/CrossFrameMessenger.js ***! + \****************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var guid = __webpack_require__(/*! guid */ "../../node_modules/guid/guid.js"); +var JsApiInternalContract_1 = __webpack_require__(/*! ../JsApiInternalContract */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var CrossFramePreparedMessage_1 = __webpack_require__(/*! ./CrossFramePreparedMessage */ "../api-internal-contract-js/lib/src/messaging/CrossFramePreparedMessage.js"); +var MessageTypeChecks_1 = __webpack_require__(/*! ./MessageTypeChecks */ "../api-internal-contract-js/lib/src/messaging/MessageTypeChecks.js"); +var MessageTypes_1 = __webpack_require__(/*! ./interface/MessageTypes */ "../api-internal-contract-js/lib/src/messaging/interface/MessageTypes.js"); +/** + * The CrossFrameMessenger is the primary export from the api-messaging module. An instance of + * this class can be instantiated on both sides of a frame boundary to facilitate communication + * in both directions between the frames. This class implements both the dispatcher and the listener + * portions, but doesn't require callers to care about both. + */ +var CrossFrameMessenger = /** @class */ (function () { + /** + * Creates an instance of CrossFrameMessenger. If you would like to use the CrossFrameMessenger as a MessageListener, + * be sure to call StartListening and register message handlers. + * @param thisWindow The window object which the CrossFrameMessenger lives. An onMessage listener will be added here. + * @param [otherWindow] Optional otherWindow which messages will be posted to. + * If defined, incoming messages must originate from otherWindow to be passed on + * @param [otherWindowOrigin] The target origin which otherWindow must have in order to receive dispatched messages. + * This value will be sent as the targetOrigin of a postMessage + * (https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage) + */ + function CrossFrameMessenger(thisWindow, otherWindow, otherWindowOrigin) { + this.thisWindow = thisWindow; + this.otherWindow = otherWindow; + this.otherWindowOrigin = otherWindowOrigin; + // Make sure to call StartListening + } + ///// MessageListener Implementation + CrossFrameMessenger.prototype.startListening = function () { + var _this = this; + // Check if we already are listening, if not, hook up a message listener + if (!this.unregisterFunction) { + var boundHandler_1 = this.onMessageReceived.bind(this); + this.thisWindow.addEventListener('message', boundHandler_1, true); + this.unregisterFunction = function () { return _this.thisWindow.removeEventListener('message', boundHandler_1, true); }; + } + }; + CrossFrameMessenger.prototype.stopListening = function () { + // Stop listening if we have started listening + if (this.unregisterFunction) { + this.unregisterFunction(); + this.unregisterFunction = undefined; + } + }; + CrossFrameMessenger.prototype.setInitializeMessageHandler = function (handler) { + this.initializeMessageHandler = handler; + }; + CrossFrameMessenger.prototype.setCommandResponseMessageHandler = function (handler) { + this.commandResponseMessageHandler = handler; + }; + CrossFrameMessenger.prototype.setCommandMessageHandler = function (handler) { + this.commandMessageHandler = handler; + }; + CrossFrameMessenger.prototype.setNotificationMessageHandler = function (handler) { + this.notificationMessageHandler = handler; + }; + CrossFrameMessenger.prototype.setHandshakeMessageHandler = function (handler) { + this.handshakeMessageHandler = handler; + }; + ///// MessageDispatcher Implementation + /** + * @param apiVersion api-internal-contract-js version (exported in JsApiInternalConntract) + * @param crossFrameVersion crossframe messaging version (exported in JsApiInternalConntract) + * @param options additional options that can be passed at initialization (information about the version of + * external being used for example) + */ + CrossFrameMessenger.prototype.prepareInitializationMessage = function (apiVersion, crossFrameVersion, options) { + var message = { + msgGuid: guid.raw(), + msgType: MessageTypes_1.MessageType.Initialize, + crossFrameVersion: crossFrameVersion, + apiVersion: apiVersion, + options: options, + }; + return this.prepareMessage(message); + }; + CrossFrameMessenger.prototype.prepareCommandMessage = function (verbId, parameters) { + var message = { + msgGuid: guid.raw(), + msgType: MessageTypes_1.MessageType.Command, + verbId: verbId, + parameters: parameters, + }; + return this.prepareMessage(message); + }; + CrossFrameMessenger.prototype.prepareCommandResponseMessage = function (commandGuid, data, error) { + var message = { + msgGuid: guid.raw(), + msgType: MessageTypes_1.MessageType.CommandResponse, + commandGuid: commandGuid, + data: data, + error: error, + }; + if (error) { + // stringify error object to remove unserializable fields like functions and prevent serialization errors + message.error = JSON.parse(JSON.stringify(error)); + } + return this.prepareMessage(message); + }; + CrossFrameMessenger.prototype.prepareNotificationMessage = function (notificationId, data) { + var message = { + msgGuid: guid.raw(), + msgType: MessageTypes_1.MessageType.Notification, + notificationId: notificationId, + data: data, + }; + return this.prepareMessage(message); + }; + CrossFrameMessenger.prototype.prepareAckMessage = function () { + var message = { + msgGuid: guid.raw(), + msgType: MessageTypes_1.MessageType.Ack, + platformVersion: JsApiInternalContract_1.INTERNAL_CONTRACT_VERSION, + }; + return this.prepareMessage(message); + }; + /** + * Prepares a pending message for sending and returns the prepared message + * + * @param msg The message to be sent to this.otherWindow + * @returns The prepared message + */ + CrossFrameMessenger.prototype.prepareMessage = function (msg) { + if (!this.otherWindow || !this.otherWindowOrigin) { + throw 'Other window not initialized, cannot dispatch messages'; + } + var preparedMessage = new CrossFramePreparedMessage_1.CrossFramePreparedMessage(msg, this.otherWindow, this.otherWindowOrigin); + return preparedMessage; + }; + /** + * Called when a message is received. Does some validation of the message, and then + * calls an appropriate message handler if one is defined + * + * @param event The incoming MessageEvent + */ + CrossFrameMessenger.prototype.onMessageReceived = function (event) { + // If we have an otherWindow defined, make sure the message is coming from there + if (this.otherWindow && event.source !== this.otherWindow) { + return; + } + // Do some validation on event.data to make sure that we have received a real message + if (!event.data) { + return; + } + var message = event.data; + if (!MessageTypeChecks_1.isMessage(message)) { + return; + } + // Check the declared message type, validate the message, and call an appropriate hander if one exists + switch (message.msgType) { + case MessageTypes_1.MessageType.Initialize: { + if (!MessageTypeChecks_1.isInitMessage(message) || !this.initializeMessageHandler) { + return; + } + this.initializeMessageHandler(message, event.source); + break; + } + case MessageTypes_1.MessageType.CommandResponse: { + if (!MessageTypeChecks_1.isCommandResponseMessage(message) || !this.commandResponseMessageHandler) { + return; + } + this.commandResponseMessageHandler(message, event.source); + break; + } + case MessageTypes_1.MessageType.Command: { + if (!MessageTypeChecks_1.isCommandMessage(message) || !this.commandMessageHandler) { + return; + } + this.commandMessageHandler(message, event.source); + break; + } + case MessageTypes_1.MessageType.Notification: { + if (!MessageTypeChecks_1.isNotificationMessage(message) || !this.notificationMessageHandler) { + return; + } + this.notificationMessageHandler(message, event.source); + break; + } + case MessageTypes_1.MessageType.Handshake: { + if (!MessageTypeChecks_1.isHandshakeMessage(message) || !this.handshakeMessageHandler) { + return; + } + this.handshakeMessageHandler(message, event.source); + break; + } + default: + // Just ignore this since we don't know how to handle the message type + } + }; + CrossFrameMessenger.prototype.setOtherWindow = function (otherWindow) { + this.otherWindow = otherWindow; + }; + CrossFrameMessenger.prototype.setOtherWindowOrigin = function (origin) { + this.otherWindowOrigin = origin; + }; + return CrossFrameMessenger; +}()); +exports.CrossFrameMessenger = CrossFrameMessenger; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/messaging/CrossFramePreparedMessage.js": +/*!**********************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/messaging/CrossFramePreparedMessage.js ***! + \**********************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Implementation of the PreparedMessage interface used to post messages between + * two frames using window.postMessage + */ +var CrossFramePreparedMessage = /** @class */ (function () { + /** + * Creates an instance of CrossFramePreparedMessage. + * @param _message The message to be sent + * @param _target The target window where the message will be sent + * @param _origin The targetOrigin where this message can be received + */ + function CrossFramePreparedMessage(_message, _target, _origin) { + this._message = _message; + this._target = _target; + this._origin = _origin; + } + Object.defineProperty(CrossFramePreparedMessage.prototype, "messageGuid", { + get: function () { + return this._message.msgGuid; + }, + enumerable: true, + configurable: true + }); + CrossFramePreparedMessage.prototype.send = function () { + this._target.postMessage(this._message, this._origin); + return this; + }; + return CrossFramePreparedMessage; +}()); +exports.CrossFramePreparedMessage = CrossFramePreparedMessage; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/messaging/MessageTypeChecks.js": +/*!**************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/messaging/MessageTypeChecks.js ***! + \**************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var guid = __webpack_require__(/*! guid */ "../../node_modules/guid/guid.js"); +var Notifications_1 = __webpack_require__(/*! ../contract/Notifications */ "../api-internal-contract-js/lib/src/contract/Notifications.js"); +var MessageTypes_1 = __webpack_require__(/*! ./interface/MessageTypes */ "../api-internal-contract-js/lib/src/messaging/interface/MessageTypes.js"); +var expectedEmptyNotifications = new Set([ + Notifications_1.NotificationId.EditButtonClicked, + Notifications_1.NotificationId.EditInDesktopButtonClicked, + Notifications_1.NotificationId.WorkbookPublished, + Notifications_1.NotificationId.WorkbookReadyToClose, + Notifications_1.NotificationId.ReadyToReceiveAuthToken, +]); +/* tslint:disable no-any */ +function isMessage(data) { + if (!data) { + return false; + } + var message = data; + if (!message || !message.msgGuid || !message.msgType) { + return false; + } + if (!guid.isGuid(message.msgGuid)) { + return false; + } + if (typeof message.msgType !== 'string') { + return false; + } + var messageTypes = [ + MessageTypes_1.MessageType.Command, + MessageTypes_1.MessageType.CommandResponse, + MessageTypes_1.MessageType.Initialize, + MessageTypes_1.MessageType.Notification, + MessageTypes_1.MessageType.Handshake, + ]; + if (messageTypes.indexOf(message.msgType) < 0) { + return false; + } + return true; +} +exports.isMessage = isMessage; +function isVersion(versionNumber) { + if (!versionNumber) { + return false; + } + var v = versionNumber; + if (typeof v !== 'object') { + return false; + } + if (typeof v.fix !== 'number' || typeof v.minor !== 'number' || typeof v.major !== 'number') { + return false; + } + return true; +} +exports.isVersion = isVersion; +function isInitMessage(message) { + if (!isMessage(message)) { + return false; + } + var initMessage = message; + if (initMessage.msgType !== MessageTypes_1.MessageType.Initialize) { + return false; + } + if (!initMessage.apiVersion || !isVersion(initMessage.apiVersion)) { + return false; + } + if (!initMessage.crossFrameVersion || !isVersion(initMessage.crossFrameVersion)) { + return false; + } + return true; +} +exports.isInitMessage = isInitMessage; +function isCommandResponseMessage(message) { + if (!isMessage(message)) { + return false; + } + var crMessage = message; + if (crMessage.msgType !== MessageTypes_1.MessageType.CommandResponse) { + return false; + } + if (!guid.isGuid(crMessage.commandGuid)) { + return false; + } + if (!crMessage.data && !crMessage.error) { + return false; + } + return true; +} +exports.isCommandResponseMessage = isCommandResponseMessage; +function isCommandMessage(message) { + if (!isMessage(message)) { + return false; + } + var commandMessage = message; + if (commandMessage.msgType !== MessageTypes_1.MessageType.Command) { + return false; + } + if (!commandMessage.parameters || typeof commandMessage.parameters !== 'object') { + return false; + } + if (!commandMessage.verbId || typeof commandMessage.verbId !== 'string') { + return false; + } + return true; +} +exports.isCommandMessage = isCommandMessage; +function isNotificationMessage(message) { + if (!isMessage(message)) { + return false; + } + var notificationMessage = message; + if (notificationMessage.msgType !== MessageTypes_1.MessageType.Notification) { + return false; + } + if (!notificationMessage.data && !expectedEmptyNotifications.has(notificationMessage.notificationId)) { + return false; + } + if (!notificationMessage.notificationId || typeof notificationMessage.notificationId !== 'string') { + return false; + } + return true; +} +exports.isNotificationMessage = isNotificationMessage; +function isHandshakeMessage(message) { + if (!isMessage(message)) { + return false; + } + var handshakeMessage = message; + if (handshakeMessage.msgType !== MessageTypes_1.MessageType.Handshake) { + return false; + } + return true; +} +exports.isHandshakeMessage = isHandshakeMessage; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/messaging/interface/MessageTypes.js": +/*!*******************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/messaging/interface/MessageTypes.js ***! + \*******************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Enum defining the 4 different types of messages we have defined + */ +var MessageType; +(function (MessageType) { + MessageType["Initialize"] = "initialize"; + MessageType["Notification"] = "notification"; + MessageType["Command"] = "command"; + MessageType["CommandResponse"] = "command-response"; + MessageType["Handshake"] = "v-handshake"; + MessageType["Ack"] = "v-ack"; +})(MessageType = exports.MessageType || (exports.MessageType = {})); + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/versioning/IdentityVersionConverter.js": +/*!**********************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/versioning/IdentityVersionConverter.js ***! + \**********************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +// tslint:disable:no-any +/** + * This version converter doesn't actually do anything but is useful for testing or when we have + * a matching platform and internal version number + */ +var IdentityVersionConverter = /** @class */ (function () { + function IdentityVersionConverter() { + } + IdentityVersionConverter.prototype.upgradeExecuteCall = function (verb, parameters) { + return { + verb: verb, + parameters: parameters, + }; + }; + IdentityVersionConverter.prototype.downgradeExecuteReturn = function (executeResponse) { + return executeResponse; + }; + IdentityVersionConverter.prototype.downgradeNotification = function (notification) { + return notification; + }; + return IdentityVersionConverter; +}()); +exports.IdentityVersionConverter = IdentityVersionConverter; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/versioning/StackingVersionConverter.js": +/*!**********************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/versioning/StackingVersionConverter.js ***! + \**********************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +// tslint:disable:no-any +/** + * The version converter is designed to allow the platform and external modules + * to seemlessly communicate over two different versions of the internal API. The only + * mode it supports is external's version <= platform's version. When executing + * commands, it is used to upgrade the external representation to what platform knows on the way in + * and downgrade the representations on the way out. Similarly for notifications, it can + * downgrade those on the way from platform to external. + */ +var StackingVersionConverter = /** @class */ (function () { + /** + * Creates a new instance of the StackingVersionConverter + * + * @param _externalMajorVersion The major version of the internal contract api-external-js is using + * @param _platformMajorVersion The major version of the internal contract the api-platform-js is using + * @param _upgradeExecuteTranslations Ordered list of the translations to perform when upgrading cmd parameters + * @param _downgradeExecuteTranslations Ordered list of downgrade translations to perform after a cmd + * @param _downgradeNotificationTranslations Ordered list of downgrade translations to perform on a notification + */ + function StackingVersionConverter(_externalMajorVersion, _platformMajorVersion, _upgradeExecuteTranslations, _downgradeExecuteTranslations, _downgradeNotificationTranslations) { + this._externalMajorVersion = _externalMajorVersion; + this._platformMajorVersion = _platformMajorVersion; + this._upgradeExecuteTranslations = _upgradeExecuteTranslations; + this._downgradeExecuteTranslations = _downgradeExecuteTranslations; + this._downgradeNotificationTranslations = _downgradeNotificationTranslations; + if (this._externalMajorVersion > this._platformMajorVersion) { + throw new Error("Cannot convert between external version " + this._externalMajorVersion + " and " + this._platformMajorVersion); + } + } + /** + * Creates a new instance of the StackingVersionConverter + * + * @param _externalVersion The version of the internal contract api-external-js is using + * @param _platformVersion The version of the internal contract the api-platform-js is using + * @param _upgradeExecuteTranslations Ordered list of the translations to perform when upgrading cmd parameters + * @param _downgradeExecuteTranslations Ordered list of downgrade translations to perform after a cmd + * @param _downgradeNotificationTranslations Ordered list of downgrade translations to perform on a notification + */ + StackingVersionConverter.fromData = function (externalVersion, platformVersion, upgradeExecuteTranslations, downgradeExecuteTranslations, downgradeNotificationTranslations) { + return new this(externalVersion.major, platformVersion.major, upgradeExecuteTranslations, downgradeExecuteTranslations, downgradeNotificationTranslations); + }; + StackingVersionConverter.prototype.upgradeExecuteCall = function (verb, parameters) { + // Perform the upgrade of the verb and parameters to the level that platform is using + var upgraded = { verb: verb, parameters: parameters }; + for (var _i = 0, _a = this._upgradeExecuteTranslations; _i < _a.length; _i++) { + var upgradeTranslation = _a[_i]; + upgraded = upgradeTranslation(upgraded.verb, upgraded.parameters); + } + return upgraded; + }; + StackingVersionConverter.prototype.downgradeExecuteReturn = function (executeResponse) { + // Downgrade the response to what the external module is expecting + var downgraded = executeResponse; + for (var _i = 0, _a = this._downgradeExecuteTranslations; _i < _a.length; _i++) { + var downgradeTranslation = _a[_i]; + downgraded = downgradeTranslation(downgraded); + } + return downgraded; + }; + StackingVersionConverter.prototype.downgradeNotification = function (notification) { + // Downgrade the notification to what the external module is expecting + var downgraded = notification; + for (var _i = 0, _a = this._downgradeNotificationTranslations; _i < _a.length; _i++) { + var downgradeTranslation = _a[_i]; + downgraded = downgradeTranslation(downgraded); + } + return downgraded; + }; + return StackingVersionConverter; +}()); +exports.StackingVersionConverter = StackingVersionConverter; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/versioning/VersionConverterFactory.js": +/*!*********************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/versioning/VersionConverterFactory.js ***! + \*********************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var IdentityVersionConverter_1 = __webpack_require__(/*! ./IdentityVersionConverter */ "../api-internal-contract-js/lib/src/versioning/IdentityVersionConverter.js"); +var StackingVersionConverter_1 = __webpack_require__(/*! ./StackingVersionConverter */ "../api-internal-contract-js/lib/src/versioning/StackingVersionConverter.js"); +var VersionTranslations_1 = __webpack_require__(/*! ./VersionTranslations */ "../api-internal-contract-js/lib/src/versioning/VersionTranslations.js"); +/** + * @returns true if lhs < rhs (ignoring fix number) + * @param lhs + * @param rhs + */ +function VersionLessThan(lhs, rhs) { + if (lhs.major > rhs.major) { + return false; + } + if (lhs.major < rhs.major) { + return true; + } + return lhs.minor < rhs.minor; +} +exports.VersionLessThan = VersionLessThan; +/** + * @returns true if lhs == rhs (ignoring fix number) + * @param lhs + * @param rhs + */ +function VersionEqualTo(lhs, rhs) { + return lhs.major === rhs.major && lhs.minor === rhs.minor; +} +exports.VersionEqualTo = VersionEqualTo; +// A mapping from an older client version of internal-contract to the current platform version of this contract. +// Each version bump can have an array of translations to perform in order. Notice that this is +// different than the major upgrades/downgrades above because it handles both major and minor version changes. +// Also please note: downgradeExecuteCall is handled on the client/external side rather than platform side. +// When updating the major or minor version of our internal-contract, you will need to update these data structures. +// * If there are translations to add, add them to the version to "upgrade from" or "downgrade to". +exports.ExecuteMinorUpgrades = { + 1: { + 9: [], + }, +}; +exports.ExecuteMinorDowngrades = { + 1: { + 5: [VersionTranslations_1.DowngradeWorksheetNames], + 9: [], + }, +}; +exports.NotificationMinorDowngrades = { + 1: { + 9: [], + 10: [VersionTranslations_1.DowngradeFlipboardZoneID], + }, +}; +/** + * Creates a new InternalContractVersionConverter which has the ability to upgrade and downgrade the contract + * between the two versions, which are specified. If externalMajorVersion is greater than platformMajorVersion, + * an error will be thrown because we won't know how to do those conversions. + * This converter can handle both major and minor updates when the platform version is greater than external version. + * + * @param externalVersion VersionNumber of the internal api which the external module is using + * @param platformVersion VersionNumber of the internal api which the platform is using + */ +function CreateVersionConverter(externalVersion, platformVersion) { + return CreateVersionConverterWithTranslators(externalVersion, platformVersion, exports.ExecuteMinorUpgrades, exports.ExecuteMinorDowngrades, exports.NotificationMinorDowngrades); +} +exports.CreateVersionConverter = CreateVersionConverter; +/** + * Implementation of CreateVersionConverter. This function takes the upgrade, downgrade, and + * notification arrays so that all the logic can be tested. + * + * @param externalVersion VersionNumber of the internal api which the external module is using + * @param platformVersion VersionNumber of the internal api which the platform is using + * @param upgrades MajorMinorTranslators for upgrades + * @param downgrades MajorMinorTranslators for downgrades + * @param notificationDowngrades MajorMinorTranslators for notification downgrades + */ +function CreateVersionConverterWithTranslators(externalVersion, platformVersion, upgrades, downgrades, notificationDowngrades) { + var externalMajorVersion = externalVersion.major; + var externalMinorVersion = externalVersion.minor; + var platformMajorVersion = platformVersion.major; + if (externalMajorVersion > platformMajorVersion) { + throw new Error("External version must be less than or equal to platform version.\n externalMajorVersion=" + externalMajorVersion + " platformMajorVersion=" + platformMajorVersion); + } + // If we are using the exact same versions (major.minor), just use the identity converter + if (VersionEqualTo(externalVersion, platformVersion)) { + return new IdentityVersionConverter_1.IdentityVersionConverter(); + } + // Walk the span between the versions we have here and collect the upgrade and downgrades necessary + var neededExecuteUpgrades = GetNeededTranslations(externalMajorVersion, platformMajorVersion, externalMinorVersion, upgrades); + var neededExecuteDowngrades = GetNeededTranslations(externalMajorVersion, platformMajorVersion, externalMinorVersion, downgrades); + var neededNotificationDowngrades = GetNeededTranslations(externalMajorVersion, platformMajorVersion, externalMinorVersion, notificationDowngrades); + // We want to apply the downgrades in reverse order in case of dependencies between them + neededExecuteDowngrades.reverse(); + neededNotificationDowngrades.reverse(); + return StackingVersionConverter_1.StackingVersionConverter.fromData(externalVersion, platformVersion, neededExecuteUpgrades, neededExecuteDowngrades, neededNotificationDowngrades); +} +exports.CreateVersionConverterWithTranslators = CreateVersionConverterWithTranslators; +function GetNeededTranslations(externalMajorVersion, platformMajorVersion, externalMinorVersion, majorMinorTranslators) { + var neededTranslations = []; + for (var major = externalMajorVersion; major <= platformMajorVersion; major++) { + if (major in majorMinorTranslators) { + var start = major === externalMajorVersion ? externalMinorVersion : 0; + var maximumMinorVersion = GetMaximumMinorIndex(Object.keys(majorMinorTranslators[major])); + for (var minor = start; minor <= maximumMinorVersion; minor++) { + if (minor in majorMinorTranslators[major]) { + neededTranslations.push.apply(neededTranslations, majorMinorTranslators[major][minor]); + } + } + } + } + return neededTranslations; +} +function GetMaximumMinorIndex(minorVersions) { + return minorVersions.map(function (a) { return Number(a); }).reduce(function (a, b) { return (a > b ? a : b); }); +} +exports.GetMaximumMinorIndex = GetMaximumMinorIndex; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/versioning/VersionTranslations.js": +/*!*****************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/versioning/VersionTranslations.js ***! + \*****************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Notifications_1 = __webpack_require__(/*! ../contract/Notifications */ "../api-internal-contract-js/lib/src/contract/Notifications.js"); +// This is where we will start to define some of these translations. +// When modifying existing models, add the requisite conversion functions here, then use them +// in the VersionConverterFactory implementation. Import old versions as you would any other module +// 0 <-> Translations +// Uncomment this line to import from the V0 definition of the API +// import * as V0 from '@tableau-api-internal-contract-js_v0'; +// 1 <-> 2 Translations +// Uncomment this line to import from the V1 definition of the API +// import * as V1 from '@tableau-api-internal-contract-js_v1'; +function DowngradeWorksheetNames(executeResponse) { + // Fix the dashboard friendly name issue. The structures are compatible, + // so we still return the original reply, but we copy the SheetInfo.name + // into the DashboardZone.name, where v1 wants to find it. + var bootstrapInfo = executeResponse.result; + if (bootstrapInfo.extensionDashboardInfo !== undefined) { + bootstrapInfo.extensionDashboardInfo.zones.forEach(function (zone) { + if (zone.sheetInfo) { + zone.name = zone.sheetInfo.name; + } + }); + } + return executeResponse; +} +exports.DowngradeWorksheetNames = DowngradeWorksheetNames; +function DowngradeFlipboardZoneID(notification) { + // Fix the FlipboardZoneId issue. Older external versions still check for flipboardZoneIDs. + // When running against a newer server, if flipboardZoneId is absent, set it to default(0). + if (notification.notificationId === Notifications_1.NotificationId.SelectedMarksChanged) { + var visualModel = notification.data; + if (visualModel.flipboardZoneID === undefined) { + visualModel.flipboardZoneID = 0; + } + } + return notification; +} +exports.DowngradeFlipboardZoneID = DowngradeFlipboardZoneID; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/versioning/external/ExternalIdentityVersionConverter.js": +/*!***************************************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/versioning/external/ExternalIdentityVersionConverter.js ***! + \***************************************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +// tslint:disable:no-any +/** + * This version converter doesn't actually do anything but is useful for testing or when we have + * a matching platform and external version number + */ +var ExternalIdentityVersionConverter = /** @class */ (function () { + function ExternalIdentityVersionConverter() { + } + ExternalIdentityVersionConverter.prototype.downgradeExecuteCall = function (verb, parameters) { + return { + verb: verb, + parameters: parameters, + }; + }; + ExternalIdentityVersionConverter.prototype.upgradeExecuteReturn = function (executeResponse, verb, parameters) { + return executeResponse; + }; + ExternalIdentityVersionConverter.prototype.upgradeNotification = function (notification) { + return notification; + }; + return ExternalIdentityVersionConverter; +}()); +exports.ExternalIdentityVersionConverter = ExternalIdentityVersionConverter; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/versioning/external/ExternalStackingVersionConverter.js": +/*!***************************************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/versioning/external/ExternalStackingVersionConverter.js ***! + \***************************************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +// tslint:disable:no-any +/** + * The version converter is designed to allow the platform and external modules + * to seemlessly communicate over two different versions of the internal API. This converter + * supports external's version(minor) >= platform's version(minor). When executing + * commands, it is used to downgrade the external representation to what platform knows on the way in + * and upgrade the representations on the way out. + */ +var ExternalStackingVersionConverter = /** @class */ (function () { + /** + * Creates a new instance of the StackingVersionConverter + * + * @param _externalVersion The version of the internal contract api-external-js is using + * @param _platformVersion The version of the internal contract the api-platform-js is using + * @param _downgradeExecuteCallTranslations Ordered list of the translations to perform when downgrading cmd parameters + * @param _upgradeExecuteReturnTranslations Ordered list of upgrade translations to perform after a cmd is executed + * @param _upgradeNotificationTranslations Ordered list of upgrade notfications to perform on events + */ + function ExternalStackingVersionConverter(_externalVersion, _platformVersion, _downgradeExecuteCallTranslations, _upgradeExecuteReturnTranslations, _upgradeNotificationTranslations) { + this._externalVersion = _externalVersion; + this._platformVersion = _platformVersion; + this._downgradeExecuteCallTranslations = _downgradeExecuteCallTranslations; + this._upgradeExecuteReturnTranslations = _upgradeExecuteReturnTranslations; + this._upgradeNotificationTranslations = _upgradeNotificationTranslations; + if (this._externalVersion.major > this._platformVersion.major) { + throw new Error("Cannot convert between external version " + this._externalVersion.major + "\n and " + this._platformVersion.major); + } + } + ExternalStackingVersionConverter.prototype.downgradeExecuteCall = function (verb, parameters) { + // Perform the downgrade of the verb and parameters to the level that platform is using + var downgraded = { verb: verb, parameters: parameters }; + for (var _i = 0, _a = this._downgradeExecuteCallTranslations; _i < _a.length; _i++) { + var downgradeTranslation = _a[_i]; + downgraded = downgradeTranslation(downgraded.verb, downgraded.parameters); + } + return downgraded; + }; + ExternalStackingVersionConverter.prototype.upgradeExecuteReturn = function (executeResponse, verb, parameters) { + // Perform the upgrade of the response to what the external module is expecting + var upgraded = executeResponse; + for (var _i = 0, _a = this._upgradeExecuteReturnTranslations; _i < _a.length; _i++) { + var upgradeTranslation = _a[_i]; + upgraded = upgradeTranslation(upgraded, verb, parameters); + } + return upgraded; + }; + ExternalStackingVersionConverter.prototype.upgradeNotification = function (notification) { + // Perform the upgrade of notification to what the external module is expecting + var upgraded = notification; + for (var _i = 0, _a = this._upgradeNotificationTranslations; _i < _a.length; _i++) { + var upgradeNotification = _a[_i]; + upgraded = upgradeNotification(upgraded); + } + return upgraded; + }; + return ExternalStackingVersionConverter; +}()); +exports.ExternalStackingVersionConverter = ExternalStackingVersionConverter; + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/versioning/external/ExternalVersionConverterFactory.js": +/*!**************************************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/versioning/external/ExternalVersionConverterFactory.js ***! + \**************************************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var VersionConverterFactory_1 = __webpack_require__(/*! ../VersionConverterFactory */ "../api-internal-contract-js/lib/src/versioning/VersionConverterFactory.js"); +var ExternalIdentityVersionConverter_1 = __webpack_require__(/*! ./ExternalIdentityVersionConverter */ "../api-internal-contract-js/lib/src/versioning/external/ExternalIdentityVersionConverter.js"); +var ExternalStackingVersionConverter_1 = __webpack_require__(/*! ./ExternalStackingVersionConverter */ "../api-internal-contract-js/lib/src/versioning/external/ExternalStackingVersionConverter.js"); +var ExternalVersionTranslations_1 = __webpack_require__(/*! ./ExternalVersionTranslations */ "../api-internal-contract-js/lib/src/versioning/external/ExternalVersionTranslations.js"); +// A mapping from the current client version of internal-contract to an older platform version of the contract. +// Each version bump can have an array of translations to perform in order. +// These translations handle downgradeExecuteCall and upgradeExecuteReturn and are meant to be called on the +// client/external side. +// When updating the major or minor version of our internal-contract, you will need to update these data structures. +// * If there are translations to add, add them to the version to 'upgrade from' or 'downgrade to'. +exports.ExecuteMinorDowngradeCallExternal = { + 1: { + 9: [], + 13: [ExternalVersionTranslations_1.DowngradeUnderlyingTableDataAsync, ExternalVersionTranslations_1.DowngradeLogicalTableDataAsync], + }, +}; +exports.ExecuteMinorUpgradeReturnExternal = { + 1: { + 9: [ExternalVersionTranslations_1.UpgradeDataTableTypes], + 29: [ExternalVersionTranslations_1.UpgradeDataTableRowsAndColumns], + }, +}; +exports.ExecuteMinorUpgradeNotification = { + 1: { + 9: [], + }, +}; +/** + * Creates a new ExternalContractVersionConverter which has the ability to upgrade and downgrade + * the contract between the two versions which are specified. If externalMajorVersion is less than + * platformMajorVersion, an ExternalIdentityVersionConverter will be returned. + * Handles upgrade/downgrade for both major and minor updates. + * + * @param externalVersion VersionNumber of the internal api which the external module is using + * @param platformVersion VersionNumber of the internal api which the platform is using + */ +function CreateExternalCompatibleVersionConverter(externalVersion, platformVersion) { + return CreateExternalCompatibleVersionConverterWithTranslators(externalVersion, platformVersion, exports.ExecuteMinorDowngradeCallExternal, exports.ExecuteMinorUpgradeReturnExternal, exports.ExecuteMinorUpgradeNotification); +} +exports.CreateExternalCompatibleVersionConverter = CreateExternalCompatibleVersionConverter; +/** + * Implementation of CreateExternalCompatibleVersionConverterWithTranslators. + * This function takes the upgrade, downgrade arrays so that all the logic can be tested. + * + * @param externalVersion VersionNumber of the internal contract which the external module is using + * @param platformVersion VersionNumber of the internal contract which the platform is using + * @param upgrades MajorMinorTranslators for response upgrades + * @param downgrades MajorMinorTranslators for execute call downgrades + */ +function CreateExternalCompatibleVersionConverterWithTranslators(externalVersion, platformVersion, downgrades, upgrades, upgradeNotifications) { + var externalMajorVersion = externalVersion.major; + var platformMajorVersion = platformVersion.major; + var platformMinorVersion = platformVersion.minor; + // This check is present in VersionConverterFactory. We throw the same error here as well. + // Hence we only need to check the minor versions for translations. + if (externalMajorVersion > platformMajorVersion) { + throw new Error("External version must be less than or equal to platform version.\n externalMajorVersion=" + externalMajorVersion + " platformMajorVersion=" + platformMajorVersion); + } + if (externalMajorVersion < platformMajorVersion || VersionConverterFactory_1.VersionEqualTo(externalVersion, platformVersion)) { + return new ExternalIdentityVersionConverter_1.ExternalIdentityVersionConverter(); + } + // Walk the span between the versions we have here and collect the upgrade and downgrades necessary + var neededExecuteCallDowngrade = GetNeededExternalTranslations(platformMajorVersion, platformMinorVersion, downgrades); + var neededExecuteReturnUpgrades = GetNeededExternalTranslations(platformMajorVersion, platformMinorVersion, upgrades); + var neededNotificationUpgrades = GetNeededExternalTranslations(platformMajorVersion, platformMinorVersion, upgradeNotifications); + // Reverse the downgrade calls, so that we start the downgrade from the external version to the platform version + neededExecuteCallDowngrade.reverse(); + return new ExternalStackingVersionConverter_1.ExternalStackingVersionConverter(externalVersion, platformVersion, neededExecuteCallDowngrade, neededExecuteReturnUpgrades, neededNotificationUpgrades); +} +exports.CreateExternalCompatibleVersionConverterWithTranslators = CreateExternalCompatibleVersionConverterWithTranslators; +function GetNeededExternalTranslations(platformMajorVersion, platformMinorVersion, majorMinorTranslators) { + var neededTranslations = []; + if (platformMajorVersion in majorMinorTranslators) { + var start = platformMinorVersion; + var maximumMinorVersion = VersionConverterFactory_1.GetMaximumMinorIndex(Object.keys(majorMinorTranslators[platformMajorVersion])); + for (var minor = start; minor <= maximumMinorVersion; minor++) { + if (minor in majorMinorTranslators[platformMajorVersion]) { + neededTranslations.push.apply(neededTranslations, majorMinorTranslators[platformMajorVersion][minor]); + } + } + } + return neededTranslations; +} + + +/***/ }), + +/***/ "../api-internal-contract-js/lib/src/versioning/external/ExternalVersionTranslations.js": +/*!**********************************************************************************************!*\ + !*** ../api-internal-contract-js/lib/src/versioning/external/ExternalVersionTranslations.js ***! + \**********************************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var JsApiInternalContract_1 = __webpack_require__(/*! ../../JsApiInternalContract */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +// 1.2 -> 1.0 Translations +// Uncomment this line to import from the V1 definition of the API +// import * as V1 from '@tableau-api-internal-contract-js_v1'; +/** + * Prior to 2019.2 (internal-contract v1.9), DataValue.value were all strings. + * Go through all DataValue objects. If we have a string, but the type should not be a string, + * convert it to the correct type. The type of DataValue.value is 'any' in the contract, so + * this change doesn't need any updates to classes or types. + */ +function UpgradeDataTableTypes(executeResponse, verb, parameters) { + if (!executeResponse) { + return executeResponse; + } + var oldUnderlyingDataTable = executeResponse.result; + if (oldUnderlyingDataTable.data !== undefined && oldUnderlyingDataTable.isSummary !== undefined) { + convertDataValues(oldUnderlyingDataTable.data); + return executeResponse; + } + var oldSelectedMarksTable = executeResponse.result; + if (oldSelectedMarksTable.data !== undefined && Array.isArray(oldSelectedMarksTable.data)) { + oldSelectedMarksTable.data.forEach(function (marksTable) { + convertDataValues(marksTable); + }); + return executeResponse; + } + return executeResponse; +} +exports.UpgradeDataTableTypes = UpgradeDataTableTypes; +/** + * Prior to 2020.2 (internal-contract v1.13 and older), worksheet.getUnderlyingTableDataAsync doesn't exist. + * Map it to the older GetUnderlyingData verb and validate the the logical table Id. + **/ +function DowngradeUnderlyingTableDataAsync(verb, parameters) { + if (verb === JsApiInternalContract_1.VerbId.GetUnderlyingTableData) { + validateParametersForObjectModel(verb, parameters); + verb = JsApiInternalContract_1.VerbId.GetUnderlyingData; + } + return { + verb: verb, + parameters: parameters, + }; +} +exports.DowngradeUnderlyingTableDataAsync = DowngradeUnderlyingTableDataAsync; +/** + * Prior to 2020.2 (internal-contract v1.13 and older), datasource.getLogicalTableDataAsync doesn't exist. + * Map it to the older GetDataSourceData verb and validate the the logical table Id. + **/ +function DowngradeLogicalTableDataAsync(verb, parameters) { + if (verb === JsApiInternalContract_1.VerbId.GetLogicalTableData) { + validateParametersForObjectModel(verb, parameters); + verb = JsApiInternalContract_1.VerbId.GetDataSourceData; + } + return { + verb: verb, + parameters: parameters, + }; +} +exports.DowngradeLogicalTableDataAsync = DowngradeLogicalTableDataAsync; +function convertDataValues(table) { + // dataTable is a two-dimensional array of data. First index is the row, second is the column. + if (table === undefined || table.dataTable === undefined || !Array.isArray(table.dataTable)) { + return; + } + table.dataTable.forEach(function (row) { + row.forEach(function (dataValue, columnIndex) { + var value = dataValue.value; + if (value !== null) { + dataValue.value = JsApiInternalContract_1.DataTypeConverter.convertValueAsStringToValue(value, table.headers[columnIndex].dataType); + } + }); + }); +} +// ToDo: TFS1069027 Refactor input verbs & parameters in api-internal-contract Upgrade/Downgrade framework +function validateParametersForObjectModel(verb, parameters) { + if (parameters[JsApiInternalContract_1.ParameterId.LogicalTableId] !== JsApiInternalContract_1.ApiShowDataTableSentinel.SingleTableId) { + throw new Error("Invalid logical table id passed to " + verb + "."); + } +} +/** + * Prior to 2021.2 (internal-contract v1.29 and below), getSummaryDataAsync did not support maxRows, + * and any get...DataAsync did not support columnsToIncludeById. + * Trim result to maxRows if it is included in the parameters for getSummaryDataAsync + * Trim columns to columnsToInclude if included in the parameters for any get...DataAsync + */ +function UpgradeDataTableRowsAndColumns(executeResponse, verb, parameters) { + if (isGetSummaryDataVerb(verb) && parameters[JsApiInternalContract_1.ParameterId.MaxRows]) { + executeResponse = adjustDataRowLength(executeResponse, parameters[JsApiInternalContract_1.ParameterId.MaxRows]); + } + if (isGetTableDataVerb(verb) && parameters[JsApiInternalContract_1.ParameterId.ColumnsToIncludeById]) { + executeResponse = adjustDataColumns(executeResponse, parameters[JsApiInternalContract_1.ParameterId.ColumnsToIncludeById]); + } + return executeResponse; +} +exports.UpgradeDataTableRowsAndColumns = UpgradeDataTableRowsAndColumns; +function isGetSummaryDataVerb(verb) { + return verb === JsApiInternalContract_1.VerbId.GetDataSummaryData; +} +function isGetTableDataVerb(verb) { + return (verb === JsApiInternalContract_1.VerbId.GetDataSummaryData || + verb === JsApiInternalContract_1.VerbId.GetUnderlyingTableData || + verb === JsApiInternalContract_1.VerbId.GetLogicalTableData || + verb === JsApiInternalContract_1.VerbId.GetDataSourceData || + verb === JsApiInternalContract_1.VerbId.GetUnderlyingData); +} +function adjustDataRowLength(executeResponse, maxRows) { + var underlyingDataTable = executeResponse.result; + if (!underlyingDataTable.data || !Array.isArray(underlyingDataTable.data.dataTable)) { + return executeResponse; + } + if (maxRows > 0 && maxRows < underlyingDataTable.data.dataTable.length) { + underlyingDataTable.data.dataTable.length = maxRows; + } + return executeResponse; +} +function adjustDataColumns(executeResponse, columnsToInclude) { + if (columnsToInclude.length === 0) { + return executeResponse; + } + // verify that we have a valid UnderlyingDataTable + var underlyingDataTable = executeResponse.result; + if (!underlyingDataTable.data || !Array.isArray(underlyingDataTable.data.dataTable) || !Array.isArray(underlyingDataTable.data.headers)) { + return executeResponse; + } + // 1. filter the headers to only columnsToInclude + // 2. use the new headers to filter all rows + // 3. update the indices in our new headers + var newHeaders = underlyingDataTable.data.headers.filter(function (header, index) { + return columnsToInclude.find(function (name) { return name === header.fieldName; }); + }); + underlyingDataTable.data.dataTable.forEach(function (row, index) { + underlyingDataTable.data.dataTable[index] = row.filter(function (value, valueIndex) { return newHeaders.findIndex(function (header) { return header.index === valueIndex; }) !== -1; }); + }); + var newIndex = 0; + underlyingDataTable.data.headers = newHeaders.map(function (header) { + header.index = newIndex++; + return header; + }); + return executeResponse; +} + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared.js": +/*!*********************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared.js ***! + \*********************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +// Export everything which had been previously in the api-shared module +function __export(m) { + for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p]; +} +Object.defineProperty(exports, "__esModule", ({ value: true })); +var ApiVersion_1 = __webpack_require__(/*! ./ApiShared/ApiVersion */ "../api-shared-js/lib/src/ApiShared/ApiVersion.js"); +exports.ApiVersion = ApiVersion_1.ApiVersion; +__export(__webpack_require__(/*! ./ApiShared/CrossFrame/CrossFrameBootstrap */ "../api-shared-js/lib/src/ApiShared/CrossFrame/CrossFrameBootstrap.js")); +var CrossFrameDispatcher_1 = __webpack_require__(/*! ./ApiShared/CrossFrame/CrossFrameDispatcher */ "../api-shared-js/lib/src/ApiShared/CrossFrame/CrossFrameDispatcher.js"); +exports.CrossFrameDispatcher = CrossFrameDispatcher_1.CrossFrameDispatcher; +var DataSource_1 = __webpack_require__(/*! ./ApiShared/DataSource */ "../api-shared-js/lib/src/ApiShared/DataSource.js"); +exports.DataSource = DataSource_1.DataSource; +var ExternalToInternalEnumMappings_1 = __webpack_require__(/*! ./ApiShared/EnumMappings/ExternalToInternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.js"); +exports.ExternalToInternalEnumMappings = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings; +var InternalToExternalEnumMappings_1 = __webpack_require__(/*! ./ApiShared/EnumMappings/InternalToExternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js"); +exports.InternalToExternalEnumMappings = InternalToExternalEnumMappings_1.InternalToExternalEnumMappings; +var EventListenerManager_1 = __webpack_require__(/*! ./ApiShared/EventListenerManager */ "../api-shared-js/lib/src/ApiShared/EventListenerManager.js"); +exports.EventListenerManager = EventListenerManager_1.EventListenerManager; +var Field_1 = __webpack_require__(/*! ./ApiShared/Field */ "../api-shared-js/lib/src/ApiShared/Field.js"); +exports.Field = Field_1.Field; +var CustomViewImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/CustomViewImpl */ "../api-shared-js/lib/src/ApiShared/Impl/CustomViewImpl.js"); +exports.CustomViewImpl = CustomViewImpl_1.CustomViewImpl; +var DashboardImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/DashboardImpl */ "../api-shared-js/lib/src/ApiShared/Impl/DashboardImpl.js"); +exports.DashboardImpl = DashboardImpl_1.DashboardImpl; +var DashboardObjectImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/DashboardObjectImpl */ "../api-shared-js/lib/src/ApiShared/Impl/DashboardObjectImpl.js"); +exports.DashboardObjectImpl = DashboardObjectImpl_1.DashboardObjectImpl; +var DataSourceImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/DataSourceImpl */ "../api-shared-js/lib/src/ApiShared/Impl/DataSourceImpl.js"); +exports.DataSourceImpl = DataSourceImpl_1.DataSourceImpl; +var ParameterImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/ParameterImpl */ "../api-shared-js/lib/src/ApiShared/Impl/ParameterImpl.js"); +exports.ParameterImpl = ParameterImpl_1.ParameterImpl; +var SheetImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/SheetImpl */ "../api-shared-js/lib/src/ApiShared/Impl/SheetImpl.js"); +exports.SheetImpl = SheetImpl_1.SheetImpl; +var SheetInfoImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/SheetInfoImpl */ "../api-shared-js/lib/src/ApiShared/Impl/SheetInfoImpl.js"); +exports.SheetInfoImpl = SheetInfoImpl_1.SheetInfoImpl; +var SingleEventManagerImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/SingleEventManagerImpl */ "../api-shared-js/lib/src/ApiShared/Impl/SingleEventManagerImpl.js"); +exports.SingleEventManagerImpl = SingleEventManagerImpl_1.SingleEventManagerImpl; +var StoryImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/StoryImpl */ "../api-shared-js/lib/src/ApiShared/Impl/StoryImpl.js"); +exports.StoryImpl = StoryImpl_1.StoryImpl; +var StoryPointImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/StoryPointImpl */ "../api-shared-js/lib/src/ApiShared/Impl/StoryPointImpl.js"); +exports.StoryPointImpl = StoryPointImpl_1.StoryPointImpl; +var StoryPointInfoImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/StoryPointInfoImpl */ "../api-shared-js/lib/src/ApiShared/Impl/StoryPointInfoImpl.js"); +exports.StoryPointInfoImpl = StoryPointInfoImpl_1.StoryPointInfoImpl; +var WorkbookImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/WorkbookImpl */ "../api-shared-js/lib/src/ApiShared/Impl/WorkbookImpl.js"); +exports.WorkbookImpl = WorkbookImpl_1.WorkbookImpl; +var WorksheetImpl_1 = __webpack_require__(/*! ./ApiShared/Impl/WorksheetImpl */ "../api-shared-js/lib/src/ApiShared/Impl/WorksheetImpl.js"); +exports.WorksheetImpl = WorksheetImpl_1.WorksheetImpl; +var Point_1 = __webpack_require__(/*! ./ApiShared/Point */ "../api-shared-js/lib/src/ApiShared/Point.js"); +exports.Point = Point_1.Point; +__export(__webpack_require__(/*! ./ApiShared/Services/RegisterAllSharedServices */ "../api-shared-js/lib/src/ApiShared/Services/RegisterAllSharedServices.js")); +__export(__webpack_require__(/*! ./ApiShared/Services/ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js")); +var ClientInfoServiceImpl_1 = __webpack_require__(/*! ./ApiShared/Services/impl/ClientInfoServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/ClientInfoServiceImpl.js"); +exports.ClientInfoServiceImpl = ClientInfoServiceImpl_1.ClientInfoServiceImpl; +var NotificationServiceImpl_1 = __webpack_require__(/*! ./ApiShared/Services/impl/NotificationServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/NotificationServiceImpl.js"); +exports.NotificationServiceImpl = NotificationServiceImpl_1.NotificationServiceImpl; +var NotificationServiceImplBase_1 = __webpack_require__(/*! ./ApiShared/Services/impl/NotificationServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/NotificationServiceImplBase.js"); +exports.NotificationServiceImplBase = NotificationServiceImplBase_1.NotificationServiceImplBase; +exports.Registration = NotificationServiceImplBase_1.Registration; +var ServiceImplBase_1 = __webpack_require__(/*! ./ApiShared/Services/impl/ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +exports.ServiceImplBase = ServiceImplBase_1.ServiceImplBase; +var SizeServiceImpl_1 = __webpack_require__(/*! ./ApiShared/Services/impl/SizeServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/SizeServiceImpl.js"); +exports.SizeServiceImpl = SizeServiceImpl_1.SizeServiceImpl; +var StoryActivationServiceImpl_1 = __webpack_require__(/*! ./ApiShared/Services/impl/StoryActivationServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/StoryActivationServiceImpl.js"); +exports.StoryActivationServiceImpl = StoryActivationServiceImpl_1.StoryActivationServiceImpl; +var TableauError_1 = __webpack_require__(/*! ./ApiShared/TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +exports.TableauError = TableauError_1.TableauError; +var Deferred_1 = __webpack_require__(/*! ./ApiShared/Utils/Deferred */ "../api-shared-js/lib/src/ApiShared/Utils/Deferred.js"); +exports.Deferred = Deferred_1.Deferred; +var ErrorHelpers_1 = __webpack_require__(/*! ./ApiShared/Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +exports.ErrorHelpers = ErrorHelpers_1.ErrorHelpers; +var ExportHelpers_1 = __webpack_require__(/*! ./ApiShared/Utils/ExportHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ExportHelpers.js"); +exports.ExportHelpers = ExportHelpers_1.ExportHelpers; +var SheetUtils_1 = __webpack_require__(/*! ./ApiShared/Utils/SheetUtils */ "../api-shared-js/lib/src/ApiShared/Utils/SheetUtils.js"); +exports.SheetUtils = SheetUtils_1.SheetUtils; +var VersionNumber_1 = __webpack_require__(/*! ./ApiShared/VersionNumber */ "../api-shared-js/lib/src/ApiShared/VersionNumber.js"); +exports.VersionNumber = VersionNumber_1.VersionNumber; +var VersionedExternalApiDispatcher_1 = __webpack_require__(/*! ./VersionedExternalApiDispatcher */ "../api-shared-js/lib/src/VersionedExternalApiDispatcher.js"); +exports.VersionedExternalApiDispatcher = VersionedExternalApiDispatcher_1.VersionedExternalApiDispatcher; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/ApiVersion.js": +/*!********************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/ApiVersion.js ***! + \********************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var VersionNumber_1 = __webpack_require__(/*! ./VersionNumber */ "../api-shared-js/lib/src/ApiShared/VersionNumber.js"); +/** + * This is the singleton wrapper of VersionNumber + */ +var ApiVersion = /** @class */ (function () { + function ApiVersion() { + } + Object.defineProperty(ApiVersion, "Instance", { + /** + * Gets the singleton instance of the version number. + */ + get: function () { + return ApiVersion._instance; + }, + enumerable: true, + configurable: true + }); + ApiVersion.SetVersionNumber = function (numString, isAlpha) { + ApiVersion._instance = new VersionNumber_1.VersionNumber(numString, isAlpha); + }; + return ApiVersion; +}()); +exports.ApiVersion = ApiVersion; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/ConnectionSummary.js": +/*!***************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/ConnectionSummary.js ***! + \***************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Implementation of a connection summary. + * This does not follow the Impl pattern as it is just a property bag. + */ +var ConnectionSummary = /** @class */ (function () { + function ConnectionSummary(_connectionInfo) { + this._connectionInfo = _connectionInfo; + } + Object.defineProperty(ConnectionSummary.prototype, "name", { + get: function () { + return this._connectionInfo.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ConnectionSummary.prototype, "id", { + get: function () { + return this._connectionInfo.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ConnectionSummary.prototype, "serverURI", { + get: function () { + return this._connectionInfo.serverURI; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ConnectionSummary.prototype, "type", { + get: function () { + return this._connectionInfo.type; + }, + enumerable: true, + configurable: true + }); + return ConnectionSummary; +}()); +exports.ConnectionSummary = ConnectionSummary; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/CrossFrame/CrossFrameBootstrap.js": +/*!****************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/CrossFrame/CrossFrameBootstrap.js ***! + \****************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var CrossFrameDispatcher_1 = __webpack_require__(/*! ./CrossFrameDispatcher */ "../api-shared-js/lib/src/ApiShared/CrossFrame/CrossFrameDispatcher.js"); +// Checks to see if we are running in an iframe currently: https://stackoverflow.com/a/326076/8821153 +function inIframe(thisWindow) { + try { + return thisWindow.self !== thisWindow.parent; + } + catch (e) { + return true; + } +} +/** + * Attempts to bootstrap the extension with a cross-frame parent where Tableau is running + * + * @param thisWindow The window which we are running in (injected for unit testing purposes) + * @param internalContractVersion The version number of the internal contract we are using + * @returns A promise which is doing the actual bootstrapping + */ +function doCrossFrameBootstrap(thisWindow, internalContractVersion, options) { + return new Promise(function (resolve, reject) { + var parent; + // Normally, we are running inside an iframe. The exception to this is + // when we are running as an extension inside a dialog as part of the UINamespace + // functionality. In that case, we want the opener of this window rather than the parent. + if (!inIframe(thisWindow)) { + parent = thisWindow.opener; + } + else { + parent = thisWindow.parent; + } + if (!parent) { + reject('This extension is not running inside an iframe, desktop, or popup window. Initialization failed.'); + } + // Create the messenger which will do he communication between this window and our parent + // Since we don't know where we are running yet, we have to make this initial origin '*'. Once + // we have successfully initialized our extension, we will limit where we send messages + var messenger = new api_internal_contract_js_1.CrossFrameMessenger(thisWindow, parent, '*'); + // Prepare to send an initialization message to the parent frame + var initializationMessage = messenger.prepareInitializationMessage(internalContractVersion, api_internal_contract_js_1.MESSAGING_VERSION, options); + // When we receive a response back from the parent, we check to make sure the guids match and then we know + // that the parent is aware of us and we can start communicating + messenger.setCommandResponseMessageHandler(function (msg) { + // Verify we are getting a response from our initialize message + if (msg.commandGuid === initializationMessage.messageGuid) { + // The versioning of the dispatcher happens on the other side of our frame, and + // in a wrapper on this side. This one doesn't have any version knowledge. + var dispatcherFactory = function () { return new CrossFrameDispatcher_1.CrossFrameDispatcher(messenger); }; + resolve(dispatcherFactory); + } + }); + // Now that our handlers are ready, start listening and send our initialization message + messenger.startListening(); + initializationMessage.send(); + }); +} +exports.doCrossFrameBootstrap = doCrossFrameBootstrap; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/CrossFrame/CrossFrameDispatcher.js": +/*!*****************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/CrossFrame/CrossFrameDispatcher.js ***! + \*****************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +/** + * This is an implementation of the InternalApiDispatcher interface which functions by passing messages + * across a frame boundary. This is usually between the code where our javscript library has been included + * by a 3rd party dev and another frame where Tableau server has content. + */ +var CrossFrameDispatcher = /** @class */ (function () { + /** + * Creates an instance of CrossFrameDispatcher which will use the given messenger to communicate + * @param _messenger an instantiated and listening messenger object + */ + function CrossFrameDispatcher(_messenger) { + this._messenger = _messenger; + // Collection of pending promises which are waiting to be resolved. When we receive a response back from the other frame, + // these promises can be either resolved or rejected + this._pendingPromises = {}; + // The collection of notification handlers which have been registered with this dispatcher + this._notificationHandlers = []; + if (!this._messenger) { + throw 'Missing messenger object'; + } + // Set up our message handlers. We only care about incoming notifications and command responses + this._messenger.setCommandResponseMessageHandler(this.onCommandResponse.bind(this)); + this._messenger.setNotificationMessageHandler(this.onNotification.bind(this)); + } + ////// Start InternalApiDispatcher implementation + CrossFrameDispatcher.prototype.execute = function (verb, parameters) { + var _this = this; + // To execute a verb, we first prepare a command message and then define a promise. + var preparedMessage = this._messenger.prepareCommandMessage(verb, parameters); + var promise = new Promise(function (resolve, reject) { + // Save off the pending promise by the messageGuid we are about to send. When a response is + // received, we'll be able to resolve this promise with the result + _this._pendingPromises[preparedMessage.messageGuid] = { resolve: resolve, reject: reject }; + }); + // Actually send the message and return the promise + preparedMessage.send(); + return promise; + }; + CrossFrameDispatcher.prototype.registerNotificationHandler = function (handler) { + this._notificationHandlers.push(handler); + }; + CrossFrameDispatcher.prototype.unregisterNotificationHandler = function (handler) { + this._notificationHandlers = this._notificationHandlers.filter(function (h) { return h !== handler; }); + }; + ////// End InternalApiDispatcher implementation + CrossFrameDispatcher.prototype.onCommandResponse = function (response) { + // We got a command response, look through the pending promises and resolve + if (Object.keys(this._pendingPromises).indexOf(response.commandGuid) < 0) { + return; // We don't have any reference to this command, just return + } + var pendingPromise = this._pendingPromises[response.commandGuid]; + // If we have an error defined, reject the promise + if (response.error) { + pendingPromise.reject(response.error); + } + // If we have data defined, resolve the promise + if (response.data) { + pendingPromise.resolve({ result: response.data }); + } + // Clean up our pending promises object + delete this._pendingPromises[response.commandGuid]; + }; + CrossFrameDispatcher.prototype.onNotification = function (notificationMessage) { + // Go through each notification handler we have registered and let them know a notification came in + for (var _i = 0, _a = this._notificationHandlers; _i < _a.length; _i++) { + var handler = _a[_i]; + try { + handler({ notificationId: notificationMessage.notificationId, data: notificationMessage.data }); + } + catch (e) { + // Incase of a IncompatibleVersionError, re-throw the error. + if (e.errorCode === api_external_contract_js_1.EmbeddingErrorCodes.IncompatibleVersionError) { + throw e; + } + // Else Ignore so if one handler errors, the other still get the message. + } + } + }; + return CrossFrameDispatcher; +}()); +exports.CrossFrameDispatcher = CrossFrameDispatcher; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/DataSource.js": +/*!********************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/DataSource.js ***! + \********************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var DataSource = /** @class */ (function () { + function DataSource(_dataSourceImpl) { + this._dataSourceImpl = _dataSourceImpl; + } + Object.defineProperty(DataSource.prototype, "name", { + get: function () { + return this._dataSourceImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSource.prototype, "id", { + get: function () { + return this._dataSourceImpl.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSource.prototype, "fields", { + get: function () { + return this._dataSourceImpl.fields; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSource.prototype, "extractUpdateTime", { + get: function () { + return this._dataSourceImpl.extractUpdateTime; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSource.prototype, "isExtract", { + get: function () { + return this._dataSourceImpl.isExtract; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSource.prototype, "isPublished", { + get: function () { + return this._dataSourceImpl.isPublished; + }, + enumerable: true, + configurable: true + }); + DataSource.prototype.publishedUrl = function () { + return this._dataSourceImpl.publishedUrl(); + }; + DataSource.prototype.refreshAsync = function () { + return this._dataSourceImpl.refreshAsync(); + }; + DataSource.prototype.getActiveTablesAsync = function () { + console.warn('DataSource.getActiveTablesAsync is deprecated. Please use DataSource.getLogicalTablesAsync.'); + return this._dataSourceImpl.getActiveTablesAsync(); + }; + DataSource.prototype.getConnectionSummariesAsync = function () { + return this._dataSourceImpl.getConnectionSummariesAsync(); + }; + DataSource.prototype.getUnderlyingDataAsync = function (options) { + console.warn('DataSource.getUnderlyingDataAsync is deprecated. Please use ' + + 'DataSource.getLogicalTablesAsync and DataSource.getLogicalTableDataAsync.'); + return this._dataSourceImpl.getUnderlyingDataAsync(options); + }; + DataSource.prototype.getLogicalTablesAsync = function () { + return this._dataSourceImpl.getLogicalTablesAsync(); + }; + DataSource.prototype.getLogicalTableDataAsync = function (logicalTableId, options) { + return this._dataSourceImpl.getLogicalTableDataAsync(logicalTableId, options); + }; + DataSource.prototype.getLogicalTableDataReaderAsync = function (logicalTableId, pageRowCount, options) { + return this._dataSourceImpl.getLogicalTableDataReaderAsync(logicalTableId, pageRowCount, options); + }; + return DataSource; +}()); +exports.DataSource = DataSource; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.js": +/*!*****************************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.js ***! + \*****************************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k; +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var EnumConverter_1 = __webpack_require__(/*! ../Utils/EnumConverter */ "../api-shared-js/lib/src/ApiShared/Utils/EnumConverter.js"); +/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */ +/** + * Maps enums used by the external-api-contract to the enums used + * in the internal-api-contract, which developers code against. + */ +var ExternalToInternalEnumMappings = /** @class */ (function () { + function ExternalToInternalEnumMappings() { + } + ExternalToInternalEnumMappings.filterDomainType = new EnumConverter_1.EnumConverter((_a = {}, + _a[api_external_contract_js_1.FilterDomainType.Relevant] = api_internal_contract_js_1.FilterDomainType.Relevant, + _a[api_external_contract_js_1.FilterDomainType.Database] = api_internal_contract_js_1.FilterDomainType.Database, + _a)); + ExternalToInternalEnumMappings.nullOptions = new EnumConverter_1.EnumConverter((_b = {}, + _b[api_external_contract_js_1.FilterNullOption.AllValues] = api_internal_contract_js_1.FilterNullOption.AllValues, + _b[api_external_contract_js_1.FilterNullOption.NonNullValues] = api_internal_contract_js_1.FilterNullOption.NonNullValues, + _b[api_external_contract_js_1.FilterNullOption.NullValues] = api_internal_contract_js_1.FilterNullOption.NullValues, + _b)); + ExternalToInternalEnumMappings.filterUpdateType = new EnumConverter_1.EnumConverter((_c = {}, + _c[api_external_contract_js_1.FilterUpdateType.Add] = api_internal_contract_js_1.FilterUpdateType.Add, + _c[api_external_contract_js_1.FilterUpdateType.All] = api_internal_contract_js_1.FilterUpdateType.All, + _c[api_external_contract_js_1.FilterUpdateType.Remove] = api_internal_contract_js_1.FilterUpdateType.Remove, + _c[api_external_contract_js_1.FilterUpdateType.Replace] = api_internal_contract_js_1.FilterUpdateType.Replace, + _c)); + ExternalToInternalEnumMappings.setVisibilityType = new EnumConverter_1.EnumConverter((_d = {}, + _d[api_external_contract_js_1.ZoneVisibilityType.Show] = true, + _d[api_external_contract_js_1.ZoneVisibilityType.Hide] = false, + _d)); + ExternalToInternalEnumMappings.setReplaySpeedType = new EnumConverter_1.EnumConverter((_e = {}, + // these numbers are duration multipliers + // 2.0, for example, doubles the duration of the replay, slowing it down to 0.5x speed + _e[api_external_contract_js_1.ReplaySpeedType.Slow] = 2.0, + _e[api_external_contract_js_1.ReplaySpeedType.Normal] = 1.0, + _e[api_external_contract_js_1.ReplaySpeedType.Fast] = 0.5, + _e)); + ExternalToInternalEnumMappings.sheetType = new EnumConverter_1.EnumConverter((_f = {}, + _f[api_external_contract_js_1.SheetType.Dashboard] = api_internal_contract_js_1.SheetType.Dashboard, + _f[api_external_contract_js_1.SheetType.Worksheet] = api_internal_contract_js_1.SheetType.Worksheet, + _f[api_external_contract_js_1.SheetType.Story] = api_internal_contract_js_1.SheetType.Story, + _f)); + ExternalToInternalEnumMappings.showDataTableFormatType = new EnumConverter_1.EnumConverter((_g = {}, + _g[api_external_contract_js_1.IncludeDataValuesOption.AllValues] = api_internal_contract_js_1.ApiShowDataTableFormat.NativeAndFormattedValues, + _g[api_external_contract_js_1.IncludeDataValuesOption.OnlyNativeValues] = api_internal_contract_js_1.ApiShowDataTableFormat.NativeValuesOnly, + _g[api_external_contract_js_1.IncludeDataValuesOption.OnlyFormattedValues] = api_internal_contract_js_1.ApiShowDataTableFormat.FormattedValuesOnly, + _g)); + ExternalToInternalEnumMappings.periodType = new EnumConverter_1.EnumConverter((_h = {}, + _h[api_external_contract_js_1.PeriodType.Years] = api_internal_contract_js_1.DateStepPeriod.Years, + _h[api_external_contract_js_1.PeriodType.Quarters] = api_internal_contract_js_1.DateStepPeriod.Quarters, + _h[api_external_contract_js_1.PeriodType.Months] = api_internal_contract_js_1.DateStepPeriod.Months, + _h[api_external_contract_js_1.PeriodType.Weeks] = api_internal_contract_js_1.DateStepPeriod.Weeks, + _h[api_external_contract_js_1.PeriodType.Days] = api_internal_contract_js_1.DateStepPeriod.Days, + _h[api_external_contract_js_1.PeriodType.Hours] = api_internal_contract_js_1.DateStepPeriod.Hours, + _h[api_external_contract_js_1.PeriodType.Minutes] = api_internal_contract_js_1.DateStepPeriod.Minutes, + _h[api_external_contract_js_1.PeriodType.Seconds] = api_internal_contract_js_1.DateStepPeriod.Seconds, + _h)); + ExternalToInternalEnumMappings.dateRangeType = new EnumConverter_1.EnumConverter((_j = {}, + _j[api_external_contract_js_1.DateRangeType.Last] = api_internal_contract_js_1.DateRangeType.Last, + _j[api_external_contract_js_1.DateRangeType.LastN] = api_internal_contract_js_1.DateRangeType.LastN, + _j[api_external_contract_js_1.DateRangeType.Next] = api_internal_contract_js_1.DateRangeType.Next, + _j[api_external_contract_js_1.DateRangeType.NextN] = api_internal_contract_js_1.DateRangeType.NextN, + _j[api_external_contract_js_1.DateRangeType.Current] = api_internal_contract_js_1.DateRangeType.Current, + _j[api_external_contract_js_1.DateRangeType.ToDate] = api_internal_contract_js_1.DateRangeType.ToDate, + _j)); + ExternalToInternalEnumMappings.dialogStyles = new EnumConverter_1.EnumConverter((_k = {}, + _k[api_external_contract_js_1.DialogStyle.Window] = api_internal_contract_js_1.DialogStyle.Window, + _k[api_external_contract_js_1.DialogStyle.Modal] = api_internal_contract_js_1.DialogStyle.Modal, + _k[api_external_contract_js_1.DialogStyle.Modeless] = api_internal_contract_js_1.DialogStyle.Modeless, + _k)); + return ExternalToInternalEnumMappings; +}()); +exports.ExternalToInternalEnumMappings = ExternalToInternalEnumMappings; +/* tslint:enable:typedef */ + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js": +/*!*****************************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js ***! + \*****************************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t; +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var EnumConverter_1 = __webpack_require__(/*! ../Utils/EnumConverter */ "../api-shared-js/lib/src/ApiShared/Utils/EnumConverter.js"); +/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */ +/** + * Maps enums used by the internal-api-contract to the enums used + * in the external-api-contract, which developers code against. + */ +var InternalToExternalEnumMappings = /** @class */ (function () { + function InternalToExternalEnumMappings() { + } + InternalToExternalEnumMappings.extensionContext = new EnumConverter_1.EnumConverter((_a = {}, + _a[api_internal_contract_js_1.ExtensionContext.Desktop] = api_external_contract_js_1.ExtensionContext.Desktop, + _a[api_internal_contract_js_1.ExtensionContext.Server] = api_external_contract_js_1.ExtensionContext.Server, + _a)); + InternalToExternalEnumMappings.extensionMode = new EnumConverter_1.EnumConverter((_b = {}, + _b[api_internal_contract_js_1.ExtensionMode.Authoring] = api_external_contract_js_1.ExtensionMode.Authoring, + _b[api_internal_contract_js_1.ExtensionMode.Viewing] = api_external_contract_js_1.ExtensionMode.Viewing, + _b)); + InternalToExternalEnumMappings.columnType = new EnumConverter_1.EnumConverter((_c = {}, + _c[api_internal_contract_js_1.ColumnType.Continuous] = api_external_contract_js_1.ColumnType.Continuous, + _c[api_internal_contract_js_1.ColumnType.Discrete] = api_external_contract_js_1.ColumnType.Discrete, + _c[api_internal_contract_js_1.ColumnType.Unknown] = api_external_contract_js_1.ColumnType.Unknown, + _c)); + InternalToExternalEnumMappings.fieldAggregationType = new EnumConverter_1.EnumConverter((_d = {}, + _d[api_internal_contract_js_1.FieldAggregationType.Attr] = api_external_contract_js_1.FieldAggregationType.Attr, + _d[api_internal_contract_js_1.FieldAggregationType.Avg] = api_external_contract_js_1.FieldAggregationType.Avg, + _d[api_internal_contract_js_1.FieldAggregationType.Collect] = api_external_contract_js_1.FieldAggregationType.Collect, + _d[api_internal_contract_js_1.FieldAggregationType.Count] = api_external_contract_js_1.FieldAggregationType.Count, + _d[api_internal_contract_js_1.FieldAggregationType.Countd] = api_external_contract_js_1.FieldAggregationType.Countd, + _d[api_internal_contract_js_1.FieldAggregationType.Day] = api_external_contract_js_1.FieldAggregationType.Day, + _d[api_internal_contract_js_1.FieldAggregationType.End] = api_external_contract_js_1.FieldAggregationType.End, + _d[api_internal_contract_js_1.FieldAggregationType.Hour] = api_external_contract_js_1.FieldAggregationType.Hour, + _d[api_internal_contract_js_1.FieldAggregationType.InOut] = api_external_contract_js_1.FieldAggregationType.InOut, + _d[api_internal_contract_js_1.FieldAggregationType.Kurtosis] = api_external_contract_js_1.FieldAggregationType.Kurtosis, + _d[api_internal_contract_js_1.FieldAggregationType.Max] = api_external_contract_js_1.FieldAggregationType.Max, + _d[api_internal_contract_js_1.FieldAggregationType.Mdy] = api_external_contract_js_1.FieldAggregationType.Mdy, + _d[api_internal_contract_js_1.FieldAggregationType.Median] = api_external_contract_js_1.FieldAggregationType.Median, + _d[api_internal_contract_js_1.FieldAggregationType.Min] = api_external_contract_js_1.FieldAggregationType.Min, + _d[api_internal_contract_js_1.FieldAggregationType.Minute] = api_external_contract_js_1.FieldAggregationType.Minute, + _d[api_internal_contract_js_1.FieldAggregationType.MonthYear] = api_external_contract_js_1.FieldAggregationType.MonthYear, + _d[api_internal_contract_js_1.FieldAggregationType.None] = api_external_contract_js_1.FieldAggregationType.None, + _d[api_internal_contract_js_1.FieldAggregationType.Qtr] = api_external_contract_js_1.FieldAggregationType.Qtr, + _d[api_internal_contract_js_1.FieldAggregationType.Quart1] = api_external_contract_js_1.FieldAggregationType.Quart1, + _d[api_internal_contract_js_1.FieldAggregationType.Quart3] = api_external_contract_js_1.FieldAggregationType.Quart3, + _d[api_internal_contract_js_1.FieldAggregationType.Second] = api_external_contract_js_1.FieldAggregationType.Second, + _d[api_internal_contract_js_1.FieldAggregationType.Skewness] = api_external_contract_js_1.FieldAggregationType.Skewness, + _d[api_internal_contract_js_1.FieldAggregationType.Stdev] = api_external_contract_js_1.FieldAggregationType.Stdev, + _d[api_internal_contract_js_1.FieldAggregationType.Stdevp] = api_external_contract_js_1.FieldAggregationType.Stdevp, + _d[api_internal_contract_js_1.FieldAggregationType.Sum] = api_external_contract_js_1.FieldAggregationType.Sum, + _d[api_internal_contract_js_1.FieldAggregationType.TruncDay] = api_external_contract_js_1.FieldAggregationType.TruncDay, + _d[api_internal_contract_js_1.FieldAggregationType.TruncHour] = api_external_contract_js_1.FieldAggregationType.TruncHour, + _d[api_internal_contract_js_1.FieldAggregationType.TruncMinute] = api_external_contract_js_1.FieldAggregationType.TruncMinute, + _d[api_internal_contract_js_1.FieldAggregationType.TruncMonth] = api_external_contract_js_1.FieldAggregationType.TruncMonth, + _d[api_internal_contract_js_1.FieldAggregationType.TruncQtr] = api_external_contract_js_1.FieldAggregationType.TruncQtr, + _d[api_internal_contract_js_1.FieldAggregationType.TruncSecond] = api_external_contract_js_1.FieldAggregationType.TruncSecond, + _d[api_internal_contract_js_1.FieldAggregationType.TruncWeek] = api_external_contract_js_1.FieldAggregationType.TruncWeek, + _d[api_internal_contract_js_1.FieldAggregationType.TruncYear] = api_external_contract_js_1.FieldAggregationType.TruncYear, + _d[api_internal_contract_js_1.FieldAggregationType.User] = api_external_contract_js_1.FieldAggregationType.User, + _d[api_internal_contract_js_1.FieldAggregationType.Var] = api_external_contract_js_1.FieldAggregationType.Var, + _d[api_internal_contract_js_1.FieldAggregationType.Varp] = api_external_contract_js_1.FieldAggregationType.Varp, + _d[api_internal_contract_js_1.FieldAggregationType.Week] = api_external_contract_js_1.FieldAggregationType.Week, + _d[api_internal_contract_js_1.FieldAggregationType.Weekday] = api_external_contract_js_1.FieldAggregationType.Weekday, + _d[api_internal_contract_js_1.FieldAggregationType.Year] = api_external_contract_js_1.FieldAggregationType.Year, + _d)); + InternalToExternalEnumMappings.fieldRoleType = new EnumConverter_1.EnumConverter((_e = {}, + _e[api_internal_contract_js_1.FieldRoleType.Dimension] = api_external_contract_js_1.FieldRoleType.Dimension, + _e[api_internal_contract_js_1.FieldRoleType.Measure] = api_external_contract_js_1.FieldRoleType.Measure, + _e[api_internal_contract_js_1.FieldRoleType.Unknown] = api_external_contract_js_1.FieldRoleType.Unknown, + _e)); + InternalToExternalEnumMappings.sheetType = new EnumConverter_1.EnumConverter((_f = {}, + _f[api_internal_contract_js_1.SheetType.Dashboard] = api_external_contract_js_1.SheetType.Dashboard, + _f[api_internal_contract_js_1.SheetType.Story] = api_external_contract_js_1.SheetType.Story, + _f[api_internal_contract_js_1.SheetType.Worksheet] = api_external_contract_js_1.SheetType.Worksheet, + _f)); + InternalToExternalEnumMappings.dashboardObjectType = new EnumConverter_1.EnumConverter((_g = {}, + _g[api_internal_contract_js_1.DashboardObjectType.Extension] = api_external_contract_js_1.DashboardObjectType.Extension, + _g[api_internal_contract_js_1.DashboardObjectType.Blank] = api_external_contract_js_1.DashboardObjectType.Blank, + _g[api_internal_contract_js_1.DashboardObjectType.Image] = api_external_contract_js_1.DashboardObjectType.Image, + _g[api_internal_contract_js_1.DashboardObjectType.Legend] = api_external_contract_js_1.DashboardObjectType.Legend, + _g[api_internal_contract_js_1.DashboardObjectType.PageFilter] = api_external_contract_js_1.DashboardObjectType.PageFilter, + _g[api_internal_contract_js_1.DashboardObjectType.ParameterControl] = api_external_contract_js_1.DashboardObjectType.ParameterControl, + _g[api_internal_contract_js_1.DashboardObjectType.QuickFilter] = api_external_contract_js_1.DashboardObjectType.QuickFilter, + _g[api_internal_contract_js_1.DashboardObjectType.Text] = api_external_contract_js_1.DashboardObjectType.Text, + _g[api_internal_contract_js_1.DashboardObjectType.Title] = api_external_contract_js_1.DashboardObjectType.Title, + _g[api_internal_contract_js_1.DashboardObjectType.WebPage] = api_external_contract_js_1.DashboardObjectType.WebPage, + _g[api_internal_contract_js_1.DashboardObjectType.Worksheet] = api_external_contract_js_1.DashboardObjectType.Worksheet, + _g)); + InternalToExternalEnumMappings.dataType = new EnumConverter_1.EnumConverter((_h = {}, + _h[api_internal_contract_js_1.DataType.Bool] = api_external_contract_js_1.DataType.Bool, + _h[api_internal_contract_js_1.DataType.Date] = api_external_contract_js_1.DataType.Date, + _h[api_internal_contract_js_1.DataType.DateTime] = api_external_contract_js_1.DataType.DateTime, + _h[api_internal_contract_js_1.DataType.Float] = api_external_contract_js_1.DataType.Float, + _h[api_internal_contract_js_1.DataType.Int] = api_external_contract_js_1.DataType.Int, + _h[api_internal_contract_js_1.DataType.Spatial] = api_external_contract_js_1.DataType.Spatial, + _h[api_internal_contract_js_1.DataType.String] = api_external_contract_js_1.DataType.String, + _h)); + InternalToExternalEnumMappings.filterUpdateType = new EnumConverter_1.EnumConverter((_j = {}, + _j[api_internal_contract_js_1.FilterUpdateType.Add] = api_external_contract_js_1.FilterUpdateType.Add, + _j[api_internal_contract_js_1.FilterUpdateType.All] = api_external_contract_js_1.FilterUpdateType.All, + _j[api_internal_contract_js_1.FilterUpdateType.Remove] = api_external_contract_js_1.FilterUpdateType.Remove, + _j[api_internal_contract_js_1.FilterUpdateType.Replace] = api_external_contract_js_1.FilterUpdateType.Replace, + _j)); + InternalToExternalEnumMappings.allowableValues = new EnumConverter_1.EnumConverter((_k = {}, + _k[api_internal_contract_js_1.DomainRestrictionType.All] = api_external_contract_js_1.ParameterValueType.All, + _k[api_internal_contract_js_1.DomainRestrictionType.List] = api_external_contract_js_1.ParameterValueType.List, + _k[api_internal_contract_js_1.DomainRestrictionType.Range] = api_external_contract_js_1.ParameterValueType.Range, + _k)); + InternalToExternalEnumMappings.dateStepPeriod = new EnumConverter_1.EnumConverter((_l = {}, + _l[api_internal_contract_js_1.DateStepPeriod.Years] = api_external_contract_js_1.PeriodType.Years, + _l[api_internal_contract_js_1.DateStepPeriod.Quarters] = api_external_contract_js_1.PeriodType.Quarters, + _l[api_internal_contract_js_1.DateStepPeriod.Months] = api_external_contract_js_1.PeriodType.Months, + _l[api_internal_contract_js_1.DateStepPeriod.Weeks] = api_external_contract_js_1.PeriodType.Weeks, + _l[api_internal_contract_js_1.DateStepPeriod.Days] = api_external_contract_js_1.PeriodType.Days, + _l[api_internal_contract_js_1.DateStepPeriod.Hours] = api_external_contract_js_1.PeriodType.Hours, + _l[api_internal_contract_js_1.DateStepPeriod.Minutes] = api_external_contract_js_1.PeriodType.Minutes, + _l[api_internal_contract_js_1.DateStepPeriod.Seconds] = api_external_contract_js_1.PeriodType.Seconds, + _l)); + InternalToExternalEnumMappings.dateRangeType = new EnumConverter_1.EnumConverter((_m = {}, + _m[api_internal_contract_js_1.DateRangeType.Current] = api_external_contract_js_1.DateRangeType.Current, + _m[api_internal_contract_js_1.DateRangeType.Last] = api_external_contract_js_1.DateRangeType.Last, + _m[api_internal_contract_js_1.DateRangeType.LastN] = api_external_contract_js_1.DateRangeType.LastN, + _m[api_internal_contract_js_1.DateRangeType.Next] = api_external_contract_js_1.DateRangeType.Next, + _m[api_internal_contract_js_1.DateRangeType.NextN] = api_external_contract_js_1.DateRangeType.NextN, + _m[api_internal_contract_js_1.DateRangeType.ToDate] = api_external_contract_js_1.DateRangeType.ToDate, + _m)); + InternalToExternalEnumMappings.errorCode = new EnumConverter_1.EnumConverter((_o = {}, + _o[api_internal_contract_js_1.ErrorCodes.INITIALIZATION_ERROR] = api_external_contract_js_1.ErrorCodes.InternalError, + _o[api_internal_contract_js_1.ErrorCodes.INTERNAL_ERROR] = api_external_contract_js_1.ErrorCodes.InternalError, + _o[api_internal_contract_js_1.ErrorCodes.MISSING_ENUM_MAPPING] = api_external_contract_js_1.ErrorCodes.InternalError, + _o[api_internal_contract_js_1.ErrorCodes.MISSING_PARAMETER] = api_external_contract_js_1.ErrorCodes.InternalError, + _o[api_internal_contract_js_1.ErrorCodes.PERMISSION_DENIED] = api_external_contract_js_1.ErrorCodes.InternalError, + _o[api_internal_contract_js_1.ErrorCodes.PRES_MODEL_PARSING_ERROR] = api_external_contract_js_1.ErrorCodes.InternalError, + _o[api_internal_contract_js_1.ErrorCodes.UNKNOWN_VERB_ID] = api_external_contract_js_1.ErrorCodes.InternalError, + _o[api_internal_contract_js_1.ErrorCodes.VERSION_NOT_CONFIGURED] = api_external_contract_js_1.ErrorCodes.APINotInitialized, + _o[api_internal_contract_js_1.ErrorCodes.VISIBILITY_ERROR] = api_external_contract_js_1.ErrorCodes.VisibilityError, + _o), api_external_contract_js_1.ErrorCodes.InternalError); + InternalToExternalEnumMappings.filterType = new EnumConverter_1.EnumConverter((_p = {}, + _p[api_internal_contract_js_1.FilterType.Categorical] = api_external_contract_js_1.FilterType.Categorical, + _p[api_internal_contract_js_1.FilterType.Range] = api_external_contract_js_1.FilterType.Range, + _p[api_internal_contract_js_1.FilterType.RelativeDate] = api_external_contract_js_1.FilterType.RelativeDate, + _p[api_internal_contract_js_1.FilterType.Hierarchical] = api_external_contract_js_1.FilterType.Hierarchical, + _p)); + InternalToExternalEnumMappings.classNameKey = new EnumConverter_1.EnumConverter((_q = {}, + _q["tableau-dashboard-title" /* DashboardTitle */] = api_external_contract_js_1.ClassNameKey.DashboardTitle, + _q["tableau-story-title" /* StoryTitle */] = api_external_contract_js_1.ClassNameKey.StoryTitle, + _q["tableau-tooltip" /* Tooltip */] = api_external_contract_js_1.ClassNameKey.Tooltip, + _q["tableau-worksheet" /* Worksheet */] = api_external_contract_js_1.ClassNameKey.Worksheet, + _q["tableau-worksheet-title" /* WorksheetTitle */] = api_external_contract_js_1.ClassNameKey.WorksheetTitle, + // Temporary until we fix 1317266 - Platform hasn't been updated currently because near branch is closed + _q['dashboard-title'] = api_external_contract_js_1.ClassNameKey.DashboardTitle, + _q['story-title'] = api_external_contract_js_1.ClassNameKey.StoryTitle, + _q['tooltip'] = api_external_contract_js_1.ClassNameKey.Tooltip, + _q['worksheet'] = api_external_contract_js_1.ClassNameKey.Worksheet, + _q['worksheet-title'] = api_external_contract_js_1.ClassNameKey.WorksheetTitle, + _q)); + InternalToExternalEnumMappings.hierarchicalLevelSelectionState = new EnumConverter_1.EnumConverter((_r = {}, + _r[api_internal_contract_js_1.HierarchicalLevelSelectionState.AllSelected] = api_external_contract_js_1.HierarchicalLevelSelectionState.AllSelected, + _r[api_internal_contract_js_1.HierarchicalLevelSelectionState.NoneSelected] = api_external_contract_js_1.HierarchicalLevelSelectionState.NoneSelected, + _r[api_internal_contract_js_1.HierarchicalLevelSelectionState.SomeSelected] = api_external_contract_js_1.HierarchicalLevelSelectionState.SomeSelected, + _r[api_internal_contract_js_1.HierarchicalLevelSelectionState.UnknownSelected] = api_external_contract_js_1.HierarchicalLevelSelectionState.UnknownSelected, + _r)); + InternalToExternalEnumMappings.annotationType = new EnumConverter_1.EnumConverter((_s = {}, + _s[api_internal_contract_js_1.AnnotateEnum.Area] = api_external_contract_js_1.AnnotationType.Area, + _s[api_internal_contract_js_1.AnnotateEnum.Mark] = api_external_contract_js_1.AnnotationType.Mark, + _s[api_internal_contract_js_1.AnnotateEnum.Point] = api_external_contract_js_1.AnnotationType.Point, + _s)); + InternalToExternalEnumMappings.markType = new EnumConverter_1.EnumConverter((_t = {}, + _t[api_internal_contract_js_1.MarkType.Area] = api_external_contract_js_1.MarkType.Area, + _t[api_internal_contract_js_1.MarkType.Bar] = api_external_contract_js_1.MarkType.Bar, + _t[api_internal_contract_js_1.MarkType.Circle] = api_external_contract_js_1.MarkType.Circle, + _t[api_internal_contract_js_1.MarkType.GanttBar] = api_external_contract_js_1.MarkType.GanttBar, + _t[api_internal_contract_js_1.MarkType.Heatmap] = api_external_contract_js_1.MarkType.Heatmap, + _t[api_internal_contract_js_1.MarkType.Line] = api_external_contract_js_1.MarkType.Line, + _t[api_internal_contract_js_1.MarkType.Map] = api_external_contract_js_1.MarkType.Map, + _t[api_internal_contract_js_1.MarkType.Pie] = api_external_contract_js_1.MarkType.Pie, + _t[api_internal_contract_js_1.MarkType.Polygon] = api_external_contract_js_1.MarkType.Polygon, + _t[api_internal_contract_js_1.MarkType.Shape] = api_external_contract_js_1.MarkType.Shape, + _t[api_internal_contract_js_1.MarkType.Square] = api_external_contract_js_1.MarkType.Square, + _t[api_internal_contract_js_1.MarkType.Text] = api_external_contract_js_1.MarkType.Text, + _t[api_internal_contract_js_1.MarkType.VizExtension] = api_external_contract_js_1.MarkType.VizExtension, + _t)); + return InternalToExternalEnumMappings; +}()); +exports.InternalToExternalEnumMappings = InternalToExternalEnumMappings; +/* tslint:enable:typedef */ + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/EventListenerManager.js": +/*!******************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/EventListenerManager.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var TableauError_1 = __webpack_require__(/*! ./TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +/** + * Class designed to register and unregister handlers from a user. Only those events + * which are added via AddNewEventType will be supported by this instance + */ +var EventListenerManager = /** @class */ (function () { + function EventListenerManager() { + this._eventListenerManagers = {}; + } + EventListenerManager.prototype.addEventListener = function (eventType, handler) { + if (!this._eventListenerManagers.hasOwnProperty(eventType)) { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.UnsupportedEventName, "Cannot add event, unsupported event type: " + eventType); + } + return this._eventListenerManagers[eventType].addEventListener(handler); + }; + EventListenerManager.prototype.removeEventListener = function (eventType, handler) { + if (!this._eventListenerManagers.hasOwnProperty(eventType)) { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.UnsupportedEventName, "Cannot remove event, unsupported event type: " + eventType); + } + return this._eventListenerManagers[eventType].removeEventListener(handler); + }; + EventListenerManager.prototype.addNewEventType = function (eventManager) { + this._eventListenerManagers[eventManager.eventType] = eventManager; + }; + return EventListenerManager; +}()); +exports.EventListenerManager = EventListenerManager; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Field.js": +/*!***************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Field.js ***! + \***************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Field = /** @class */ (function () { + function Field(_fieldImpl) { + this._fieldImpl = _fieldImpl; + } + Object.defineProperty(Field.prototype, "name", { + get: function () { + return this._fieldImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "id", { + get: function () { + return this._fieldImpl.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "description", { + get: function () { + return this._fieldImpl.description; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "dataType", { + get: function () { + return this._fieldImpl.dataType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "aggregation", { + get: function () { + return this._fieldImpl.aggregation; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "dataSource", { + get: function () { + return this._fieldImpl.dataSource; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "role", { + get: function () { + return this._fieldImpl.role; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "columnType", { + get: function () { + return this._fieldImpl.columnType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isCalculatedField", { + get: function () { + return this._fieldImpl.isCalculatedField; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isCombinedField", { + get: function () { + return this._fieldImpl.isCombinedField; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isGenerated", { + get: function () { + return this._fieldImpl.isGenerated; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isGeospatial", { + get: function () { + return this._fieldImpl.isGeospatial; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isHidden", { + get: function () { + return this._fieldImpl.isHidden; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isPresentOnPublishedDatasource", { + get: function () { + return this._fieldImpl.isPresentOnPublishedDatasource; + }, + enumerable: true, + configurable: true + }); + return Field; +}()); +exports.Field = Field; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/CustomViewImpl.js": +/*!*****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/CustomViewImpl.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var ApiShared_1 = __webpack_require__(/*! ../../ApiShared */ "../api-shared-js/lib/src/ApiShared.js"); +var CustomViewImpl = /** @class */ (function () { + function CustomViewImpl(customViewModel, _registryId) { + this._registryId = _registryId; + this._luid = customViewModel.luid; + this._name = customViewModel.name; + this._shared = customViewModel.shared; + this._isDefault = customViewModel.isDefault; + this._ownerName = customViewModel.owner.userFriendlyName; + this._url = customViewModel.url; + } + Object.defineProperty(CustomViewImpl.prototype, "luid", { + get: function () { + return this._luid; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CustomViewImpl.prototype, "name", { + get: function () { + return this._name; + }, + set: function (name) { + this._name = name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CustomViewImpl.prototype, "shared", { + get: function () { + return this._shared; + }, + set: function (shared) { + this._shared = shared; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CustomViewImpl.prototype, "isDefault", { + get: function () { + return this._isDefault; + }, + set: function (isDefault) { + this._isDefault = isDefault; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CustomViewImpl.prototype, "ownerName", { + get: function () { + return this._ownerName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CustomViewImpl.prototype, "url", { + get: function () { + return this._url; + }, + enumerable: true, + configurable: true + }); + CustomViewImpl.prototype.saveAsync = function () { + var service = ApiShared_1.ApiServiceRegistry.get(this._registryId).getService("viz-service" /* Viz */); + return service.saveAsync(this); + }; + return CustomViewImpl; +}()); +exports.CustomViewImpl = CustomViewImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/DashboardImpl.js": +/*!****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/DashboardImpl.js ***! + \****************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var InternalToExternalEnumMappings_1 = __webpack_require__(/*! ../EnumMappings/InternalToExternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js"); +var Point_1 = __webpack_require__(/*! ../Point */ "../api-shared-js/lib/src/ApiShared/Point.js"); +var ServiceRegistry_1 = __webpack_require__(/*! ../Services/ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var DashboardObjectImpl_1 = __webpack_require__(/*! ./DashboardObjectImpl */ "../api-shared-js/lib/src/ApiShared/Impl/DashboardObjectImpl.js"); +var SheetImpl_1 = __webpack_require__(/*! ./SheetImpl */ "../api-shared-js/lib/src/ApiShared/Impl/SheetImpl.js"); +var SheetInfoImpl_1 = __webpack_require__(/*! ./SheetInfoImpl */ "../api-shared-js/lib/src/ApiShared/Impl/SheetInfoImpl.js"); +var WorksheetImpl_1 = __webpack_require__(/*! ./WorksheetImpl */ "../api-shared-js/lib/src/ApiShared/Impl/WorksheetImpl.js"); +var DashboardImpl = /** @class */ (function (_super) { + __extends(DashboardImpl, _super); + function DashboardImpl(_sheetInfo, _zones, _sheetPath, _registryId, _parentStoryPointImpl, _activeDashboardObjectId) { + if (_activeDashboardObjectId === void 0) { _activeDashboardObjectId = 0; } + var _this = _super.call(this, _sheetInfo, _registryId) || this; + _this._zones = _zones; + _this._sheetPath = _sheetPath; + _this._parentStoryPointImpl = _parentStoryPointImpl; + _this._activeDashboardObjectId = _activeDashboardObjectId; + return _this; + } + Object.defineProperty(DashboardImpl.prototype, "worksheetsImpl", { + get: function () { + return this._worksheetsImpl; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardImpl.prototype, "objects", { + get: function () { + return this._objects; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardImpl.prototype, "parentStoryPoint", { + get: function () { + return this._parentStoryPointImpl; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardImpl.prototype, "activeDashboardObjectId", { + get: function () { + return this._activeDashboardObjectId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardImpl.prototype, "activeDashboardName", { + get: function () { + return this._sheetPath.sheetName; + }, + enumerable: true, + configurable: true + }); + DashboardImpl.prototype.initializeWithPublicInterfaces = function () { + this._worksheetsImpl = new Array(); + this._objects = new Array(); + this.zoneMap = new Map(); + // Process all the zones which are contained in this dashboard + for (var _i = 0, _a = this._zones; _i < _a.length; _i++) { + var zone = _a[_i]; + var worksheetImpl = undefined; + var zoneSize = { width: zone.width, height: zone.height }; + // As the dashboard is active, all other zones in the dashboard are inactive. + var isActive = false; + if (zone.zoneType === api_internal_contract_js_1.DashboardObjectType.Worksheet || zone.zoneType === api_internal_contract_js_1.DashboardObjectType.QuickFilter) { + var worksheetName = ''; + var worksheetUrl = ''; + var isHidden = false; + if (zone.sheetInfo) { + // zone.sheetInfo was not initialized prior to internal-contract 1.6.0 + worksheetName = zone.sheetInfo.name; + // worksheetUrl & isHidden is for Embedding only + worksheetUrl = zone.sheetInfo.url || ''; + // If there's a url, then it's not hidden + isHidden = worksheetUrl === ''; + } + else { + worksheetName = zone.name; + } + // Indexes, isActive and some more properties in sheetInfoImpl are embedding specific. + // But we init them for both extensions and embedding as the Models will only use what is relevant. + var sheetInfoImpl = new SheetInfoImpl_1.SheetInfoImpl(worksheetName, api_external_contract_js_1.SheetType.Worksheet, zoneSize, this._worksheetsImpl.length, isActive, isHidden, worksheetUrl); + var vizId = { + worksheet: worksheetName, + dashboard: this._sheetInfoImpl.name, + storyboard: this._sheetPath.storyboard, + flipboardZoneID: this._sheetPath.flipboardZoneID, + storyPointID: this._sheetPath.storyPointID, + }; + worksheetImpl = new WorksheetImpl_1.WorksheetImpl(sheetInfoImpl, this._registryId, vizId, this, this._parentStoryPointImpl); + if (zone.zoneType === api_internal_contract_js_1.DashboardObjectType.Worksheet) { + this._worksheetsImpl.push(worksheetImpl); + } + } + var zonePoint = new Point_1.Point(zone.x, zone.y); + var dashboardObjectImpl = new DashboardObjectImpl_1.DashboardObjectImpl(this, InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dashboardObjectType.convert(zone.zoneType), zonePoint, zoneSize, worksheetImpl, zone.name, zone.isFloating !== undefined ? zone.isFloating : false, // before 1.6.0 we didn't have isFloating, so we assume false + zone.isVisible !== undefined ? zone.isVisible : true, // before 1.6.0 we didn't have isVisible, so we assume true + zone.zoneId, zone.fieldId); + this._objects.push(dashboardObjectImpl); + this.zoneMap.set(zone.zoneId, dashboardObjectImpl); + } + }; + DashboardImpl.prototype.setDashboardObjectVisibilityAsync = function (dashboardObjectVisibilityMap) { + var zoneService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("zone-service" /* Zone */); + return zoneService.setVisibilityAsync(/*Dashboard Name*/ this.name, this.zoneMap, dashboardObjectVisibilityMap); + }; + DashboardImpl.prototype.getDashboardObjectById = function (dashboardObjectId) { + return this.zoneMap.get(dashboardObjectId); + }; + DashboardImpl.prototype.updateZones = function (newZones, newActiveZoneId, newActiveDashboardName) { + var _this = this; + if (newActiveZoneId === void 0) { newActiveZoneId = 0; } + if (newActiveDashboardName === void 0) { newActiveDashboardName = ''; } + // getting previous dashboard objects, active zone ID and active dashboard name + var oldDashboardObjects = this._objects; + var oldZoneMap = this.zoneMap; + var oldActiveZoneId = this._activeDashboardObjectId; + var oldActiveDashboardName = this._sheetPath.sheetName; + // updating zones and reinitializing instance variables + this._zones = newZones; + this._activeDashboardObjectId = newActiveZoneId; + this._sheetPath.sheetName = newActiveDashboardName; + this._sheetInfoImpl.name = newActiveDashboardName; + this.initializeWithPublicInterfaces(); + // getting new dashboard objects + var newDashboardObjects = this._objects; + var newZoneMap = this.zoneMap; + // initializing map for changes + var zoneChanges = new Map(); + // comparing old dashboard objects with new ones + oldDashboardObjects.forEach(function (oldObject) { + var oldId = oldObject.id; + // checking if zone was removed + if (!newZoneMap.has(oldId)) { + _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.Removed); + return; + } + var newObject = newZoneMap.get(oldId); + if (oldObject.isFloating !== newObject.isFloating) { + _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.IsFloatingChanged); + } + if (oldObject.isVisible !== newObject.isVisible) { + _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.IsVisibleChanged); + } + if (oldObject.name !== newObject.name) { + _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.NameChanged); + } + if (oldObject.position.x !== newObject.position.x || oldObject.position.y !== newObject.position.y) { + _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.PositionChanged); + } + if (oldObject.size.width !== newObject.size.width || oldObject.size.height !== newObject.size.height) { + _this.addChange(oldId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.SizeChanged); + } + }); + // Checking for any added zones + newDashboardObjects.forEach(function (newObject) { + if (!oldZoneMap.has(newObject.id)) { + _this.addChange(newObject.id, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.Added); + } + }); + // Checking if zone selection has changed + if (oldActiveZoneId !== newActiveZoneId) { + if (newActiveZoneId !== 0) { + this.addChange(newActiveZoneId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.Selected); + } + if (oldActiveZoneId !== 0) { + this.addChange(oldActiveZoneId, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.Deselected); + } + } + // Checking if switched to another dashboard + if (oldActiveDashboardName !== newActiveDashboardName) { + this.addChange(0, zoneChanges, api_external_contract_js_1.DashboardLayoutChange.DashboardChanged); + } + return zoneChanges; + }; + DashboardImpl.prototype.addChange = function (zoneId, zoneChanges, change) { + if (!zoneChanges.has(zoneId)) { + zoneChanges.set(zoneId, []); + } + zoneChanges.get(zoneId).push(change); + }; + DashboardImpl.prototype.moveAndResizeDashboardObjectsAsync = function (dashboardObjectPositionAndSizeUpdateArray) { + var zoneService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("zone-service" /* Zone */); + return zoneService.moveAndResizeAsync(/*Dashboard Name*/ this.name, this.zoneMap, dashboardObjectPositionAndSizeUpdateArray); + }; + DashboardImpl.prototype.replayAnimationAsync = function (replaySpeed) { + var animationService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("animation-service" /* Animation */); + return animationService.replayAsync(replaySpeed); + }; + DashboardImpl.prototype.getFiltersAsync = function () { + this.verifyActiveSheetOrEmbeddedInActiveStoryPoint(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.getDashboardFiltersAsync(); + }; + DashboardImpl.prototype.applyFilterAsync = function (fieldName, values, updateType, options) { + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(updateType, Contract.FilterUpdateType, 'FilterUpdateType'); + ErrorHelpers_1.ErrorHelpers.verifyStringParameter(fieldName, 'fieldName'); + if (!Array.isArray(values)) { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'values parameter for applyDashboardFilterAsync must be an array'); + } + this.verifyActiveSheetOrEmbeddedInActiveStoryPoint(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.applyDashboardFilterAsync(fieldName, values, updateType, options); + }; + // @W-12986439: remove once initializeWithPublicInterfaces is moved to the constructor for this class + // This method only exists since worksheetsImpl can be undefined, but we need the worksheet names in the Export APIs + DashboardImpl.prototype.getWorksheetNamesFromZones = function () { + var worksheetNames = []; + for (var _i = 0, _a = this._zones; _i < _a.length; _i++) { + var zone = _a[_i]; + if (zone.zoneType !== api_internal_contract_js_1.DashboardObjectType.Worksheet) { + continue; + } + // zone.sheetInfo was not initialized prior to internal-contract 1.6.0 + var worksheetName = zone.sheetInfo ? zone.sheetInfo.name : zone.name; + worksheetNames.push(worksheetName); + } + return worksheetNames; + }; + DashboardImpl.prototype.verifyActiveSheetOrEmbeddedInActiveStoryPoint = function () { + var isRootAndActiveDashboard = this.active; + var isWithinActiveStoryPoint = this.parentStoryPoint != null && this.parentStoryPoint.active; + if (!isRootAndActiveDashboard && !isWithinActiveStoryPoint) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.NotActiveSheet, 'Operation not allowed on non-active sheet'); + } + }; + return DashboardImpl; +}(SheetImpl_1.SheetImpl)); +exports.DashboardImpl = DashboardImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/DashboardObjectImpl.js": +/*!**********************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/DashboardObjectImpl.js ***! + \**********************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Implementation of the dashboard objects - the zones in a dashboard. + * This does not follow the Impl pattern as it is just a property bag. + */ +var DashboardObjectImpl = /** @class */ (function () { + function DashboardObjectImpl(_dashboardImpl, _type, _position, _size, _worksheetImpl, _name, _isFloating, _isVisible, _id, _fieldId) { + this._dashboardImpl = _dashboardImpl; + this._type = _type; + this._position = _position; + this._size = _size; + this._worksheetImpl = _worksheetImpl; + this._name = _name; + this._isFloating = _isFloating; + this._isVisible = _isVisible; + this._id = _id; + this._fieldId = _fieldId; + } + Object.defineProperty(DashboardObjectImpl.prototype, "dashboardImpl", { + get: function () { + return this._dashboardImpl; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObjectImpl.prototype, "type", { + get: function () { + return this._type; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObjectImpl.prototype, "position", { + get: function () { + return this._position; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObjectImpl.prototype, "size", { + get: function () { + return this._size; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObjectImpl.prototype, "worksheetImpl", { + get: function () { + return this._worksheetImpl; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObjectImpl.prototype, "name", { + get: function () { + return this._name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObjectImpl.prototype, "isFloating", { + get: function () { + return this._isFloating; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObjectImpl.prototype, "isVisible", { + get: function () { + return this._isVisible; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObjectImpl.prototype, "id", { + get: function () { + return this._id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DashboardObjectImpl.prototype, "fieldId", { + get: function () { + return this._fieldId; + }, + enumerable: true, + configurable: true + }); + return DashboardObjectImpl; +}()); +exports.DashboardObjectImpl = DashboardObjectImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/DataSourceImpl.js": +/*!*****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/DataSourceImpl.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var ConnectionSummary_1 = __webpack_require__(/*! ../ConnectionSummary */ "../api-shared-js/lib/src/ApiShared/ConnectionSummary.js"); +var Field_1 = __webpack_require__(/*! ../Field */ "../api-shared-js/lib/src/ApiShared/Field.js"); +var LogicalTable_1 = __webpack_require__(/*! ../LogicalTable */ "../api-shared-js/lib/src/ApiShared/LogicalTable.js"); +var ServiceRegistry_1 = __webpack_require__(/*! ../Services/ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js"); +var TableSummary_1 = __webpack_require__(/*! ../TableSummary */ "../api-shared-js/lib/src/ApiShared/TableSummary.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var FieldImpl_1 = __webpack_require__(/*! ./FieldImpl */ "../api-shared-js/lib/src/ApiShared/Impl/FieldImpl.js"); +var DataSourceImpl = /** @class */ (function () { + function DataSourceImpl(_dataSourceInfo, _registryId) { + var _this = this; + this._dataSourceInfo = _dataSourceInfo; + this._registryId = _registryId; + this._fields = _dataSourceInfo.fields.map(function (fieldModel) { + var fieldImpl = new FieldImpl_1.FieldImpl(fieldModel, _this); + return new Field_1.Field(fieldImpl); + }); + } + Object.defineProperty(DataSourceImpl.prototype, "name", { + get: function () { + return this._dataSourceInfo.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSourceImpl.prototype, "id", { + get: function () { + return this._dataSourceInfo.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSourceImpl.prototype, "extractUpdateTime", { + get: function () { + return this._dataSourceInfo.extractUpdateTime; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSourceImpl.prototype, "fields", { + get: function () { + return this._fields; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSourceImpl.prototype, "isExtract", { + get: function () { + return this._dataSourceInfo.isExtract; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataSourceImpl.prototype, "isPublished", { + get: function () { + return this._dataSourceInfo.isPublished; + }, + enumerable: true, + configurable: true + }); + DataSourceImpl.prototype.publishedUrl = function () { + return this._dataSourceInfo.publishedUrl; + }; + DataSourceImpl.prototype.getMaxPageRowLimit = function () { + return 10000; + }; + DataSourceImpl.prototype.refreshAsync = function () { + var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("data-source-service" /* DataSourceService */); + return dataSourceService.refreshAsync(this._dataSourceInfo.id); + }; + DataSourceImpl.prototype.getConnectionSummariesAsync = function () { + var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("data-source-service" /* DataSourceService */); + return dataSourceService.getConnectionSummariesAsync(this._dataSourceInfo.id).then(function (summaries) { + return summaries.map(function (summary) { return new ConnectionSummary_1.ConnectionSummary(summary); }); + }); + }; + DataSourceImpl.prototype.getActiveTablesAsync = function () { + var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("data-source-service" /* DataSourceService */); + return dataSourceService.getActiveTablesAsync(this._dataSourceInfo.id).then(function (tableInfos) { + return tableInfos.map(function (tableInfo) { return new TableSummary_1.TableSummary(tableInfo); }); + }); + }; + DataSourceImpl.prototype.getUnderlyingDataAsync = function (options) { + var getDataService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + options = options || {}; + return getDataService.getDataSourceDataAsync(this.id, !!options.ignoreAliases, options.maxRows || 0, // 0 and [] are defaults + options.columnsToInclude || [], options.columnsToIncludeById || [], options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues); + }; + DataSourceImpl.prototype.getLogicalTableDataAsync = function (logicalTableId, options) { + var getDataService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + options = options || {}; + return getDataService.getLogicalTableDataAsync(this.id, logicalTableId, !!options.ignoreAliases, options.maxRows || 0, // 0 and [] are defaults + options.columnsToInclude || [], options.columnsToIncludeById || [], options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues); + }; + DataSourceImpl.prototype.getLogicalTableDataReaderAsync = function (logicalTableId, pageRowCount, options) { + var getDataService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + options = options || {}; + return getDataService.getLogicalTableDataReaderAsync(this.id, logicalTableId, pageRowCount || this.getMaxPageRowLimit(), !!options.ignoreAliases, options.columnsToIncludeById || [], options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues); + }; + DataSourceImpl.prototype.initializeWithPublicInterfaces = function (dataSource) { + ErrorHelpers_1.ErrorHelpers.verifyInternalValue(dataSource, 'dataSource'); + this._fields = this._dataSourceInfo.fields.map(function (fieldModel) { + var fieldImpl = new FieldImpl_1.FieldImpl(fieldModel, dataSource); + return new Field_1.Field(fieldImpl); + }); + }; + DataSourceImpl.prototype.getLogicalTablesAsync = function () { + var dataSourceService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("data-source-service" /* DataSourceService */); + return dataSourceService.getLogicalTablesAsync(this.id).then(function (logicalTableInfos) { + return logicalTableInfos.map(function (logicalTableInfo) { return new LogicalTable_1.LogicalTable(logicalTableInfo); }); + }); + }; + return DataSourceImpl; +}()); +exports.DataSourceImpl = DataSourceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/FieldImpl.js": +/*!************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/FieldImpl.js ***! + \************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var InternalContract = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var InternalToExternalEnumMappings_1 = __webpack_require__(/*! ../EnumMappings/InternalToExternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js"); +var FieldImpl = /** @class */ (function () { + function FieldImpl(_fieldInfo, _parentDataSource) { + this._fieldInfo = _fieldInfo; + this._parentDataSource = _parentDataSource; + } + Object.defineProperty(FieldImpl.prototype, "name", { + get: function () { + return this._fieldInfo.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "id", { + get: function () { + return this._fieldInfo.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "description", { + get: function () { + return this._fieldInfo.description; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "dataType", { + get: function () { + var _a; + return _a = this._fieldInfo.dataType, (_a !== null && _a !== void 0 ? _a : Contract.DataType.Unknown); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "aggregation", { + get: function () { + return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.fieldAggregationType.convert(this._fieldInfo.aggregation); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "dataSource", { + get: function () { + if (!this._parentDataSource) + throw new Error("Data source information is not available for this field. Please use getFieldAsync method to get field's data source information"); + return this._parentDataSource; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "role", { + get: function () { + return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.fieldRoleType.convert(this._fieldInfo.role); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "columnType", { + get: function () { + var definedValue = this._fieldInfo.columnType || InternalContract.ColumnType.Unknown; + return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.columnType.convert(definedValue); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isCalculatedField", { + get: function () { + return this._fieldInfo.isCalculatedField; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isCombinedField", { + get: function () { + return this._fieldInfo.isCombinedField; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isGenerated", { + get: function () { + return this._fieldInfo.isGenerated; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isGeospatial", { + get: function () { + return this._fieldInfo.isGeospatial; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isHidden", { + get: function () { + return this._fieldInfo.isHidden; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isPresentOnPublishedDatasource", { + get: function () { + return this._fieldInfo.isPresentOnPublishedDatasource; + }, + enumerable: true, + configurable: true + }); + return FieldImpl; +}()); +exports.FieldImpl = FieldImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/ParameterImpl.js": +/*!****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/ParameterImpl.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var InternalToExternalEnumMappings_1 = __webpack_require__(/*! ../EnumMappings/InternalToExternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js"); +var ServiceRegistry_1 = __webpack_require__(/*! ../Services/ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js"); +var DataValueFactory_1 = __webpack_require__(/*! ../Utils/DataValueFactory */ "../api-shared-js/lib/src/ApiShared/Utils/DataValueFactory.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var Param_1 = __webpack_require__(/*! ../Utils/Param */ "../api-shared-js/lib/src/ApiShared/Utils/Param.js"); +var ParameterImpl = /** @class */ (function () { + function ParameterImpl(parameterInfo, _registryId) { + this._registryId = _registryId; + this.setParameterInfo(parameterInfo); + } + Object.defineProperty(ParameterImpl.prototype, "name", { + get: function () { + return this._parameterInfo.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParameterImpl.prototype, "currentValue", { + get: function () { + return DataValueFactory_1.DataValueFactory.MakeParameterDataValue(this._parameterInfo.currentValue, this._parameterInfo.dataType); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParameterImpl.prototype, "dataType", { + get: function () { + return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dataType.convert(this._parameterInfo.dataType); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParameterImpl.prototype, "id", { + get: function () { + return this._globalFieldName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(ParameterImpl.prototype, "allowableValues", { + get: function () { + return this._allowableValues; + }, + enumerable: true, + configurable: true + }); + ParameterImpl.prototype.changeValueAsync = function (newValue) { + var _this = this; + ErrorHelpers_1.ErrorHelpers.verifyParameter(newValue, 'newValue'); + var coercedValue = Param_1.Param.serializeParameterValue(newValue); + var parametersService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("parameters-service" /* Parameters */); + return parametersService.changeParameterValueAsync(this._globalFieldName, coercedValue).then(function (parameterInfo) { + _this.setParameterInfo(parameterInfo); + return _this.currentValue; + }); + }; + ParameterImpl.prototype.setParameterInfo = function (parameterInfo) { + this._parameterInfo = parameterInfo; + this._globalFieldName = parameterInfo.fieldName; + var type = InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.allowableValues.convert(parameterInfo.allowableValuesType); + var listValues; + var minValue; + var maxValue; + var stepSize; + var dateStepPeriod; + if (type === api_external_contract_js_1.ParameterValueType.List) { + var values = parameterInfo.allowableValues || []; + listValues = values.map(function (val) { return DataValueFactory_1.DataValueFactory.MakeParameterDataValue(val, parameterInfo.dataType); }); + } + else if (type === api_external_contract_js_1.ParameterValueType.Range) { + minValue = parameterInfo.minValue && DataValueFactory_1.DataValueFactory.MakeParameterDataValue(parameterInfo.minValue, parameterInfo.dataType); + maxValue = parameterInfo.maxValue && DataValueFactory_1.DataValueFactory.MakeParameterDataValue(parameterInfo.maxValue, parameterInfo.dataType); + stepSize = parameterInfo.stepSize; + dateStepPeriod = parameterInfo.dateStepPeriod && InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dateStepPeriod.convert(parameterInfo.dateStepPeriod); + } + this._allowableValues = { + type: type, + allowableValues: listValues, + minValue: minValue, + maxValue: maxValue, + stepSize: stepSize, + dateStepPeriod: dateStepPeriod, + }; + }; + return ParameterImpl; +}()); +exports.ParameterImpl = ParameterImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/SheetImpl.js": +/*!************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/SheetImpl.js ***! + \************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var ServiceRegistry_1 = __webpack_require__(/*! ../Services/ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var Param_1 = __webpack_require__(/*! ../Utils/Param */ "../api-shared-js/lib/src/ApiShared/Utils/Param.js"); +var SheetUtils_1 = __webpack_require__(/*! ../Utils/SheetUtils */ "../api-shared-js/lib/src/ApiShared/Utils/SheetUtils.js"); +var SheetImpl = /** @class */ (function () { + function SheetImpl(_sheetInfoImpl, _registryId) { + this._sheetInfoImpl = _sheetInfoImpl; + this._registryId = _registryId; + } + Object.defineProperty(SheetImpl.prototype, "name", { + get: function () { + return this._sheetInfoImpl.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetImpl.prototype, "sheetType", { + get: function () { + return this._sheetInfoImpl.sheetType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetImpl.prototype, "sheetPath", { + get: function () { + return this._sheetInfoImpl.sheetPath; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetImpl.prototype, "size", { + get: function () { + return this._sheetInfoImpl.sheetSize; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetImpl.prototype, "hidden", { + get: function () { + if (this._sheetInfoImpl.isHidden !== undefined) { + return this._sheetInfoImpl.isHidden; + } + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.ImplementationError, "isHidden not implemented"); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetImpl.prototype, "active", { + get: function () { + if (this._sheetInfoImpl.isActive !== undefined) { + return this._sheetInfoImpl.isActive; + } + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.ImplementationError, "active not implemented"); + }, + set: function (active) { + if (this._sheetInfoImpl.isActive !== undefined) { + this._sheetInfoImpl.active = active; + } + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetImpl.prototype, "index", { + get: function () { + if (this._sheetInfoImpl.index !== undefined) { + return this._sheetInfoImpl.index; + } + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.ImplementationError, "index not implemented"); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetImpl.prototype, "url", { + get: function () { + if (this._sheetInfoImpl.url !== undefined) { + return this._sheetInfoImpl.url; + } + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.ImplementationError, "url not implemented"); + }, + enumerable: true, + configurable: true + }); + SheetImpl.prototype.getSheetSize = function () { + if (!SheetUtils_1.SheetUtils.isValidSheetSize(this.size)) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InternalError, 'size is not of type SheetSize'); + } + return this.size; + }; + SheetImpl.prototype.findParameterAsync = function (parameterName) { + ErrorHelpers_1.ErrorHelpers.verifyParameter(parameterName, 'parameterName'); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("parameters-service" /* Parameters */); + return service.findParameterByNameAsync(parameterName); + }; + SheetImpl.prototype.getParametersAsync = function () { + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("parameters-service" /* Parameters */); + return service.getParametersForSheetAsync(this.sheetPath); + }; + SheetImpl.prototype.changeSizeAsync = function (newSize) { + var _this = this; + var invalidSizeError = new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Invalid sheet size parameter'); + if (!newSize || !newSize.behavior) { + throw invalidSizeError; + } + var partialSheetSize = this.normalizeSheetSize(newSize); + var isAutomatic = partialSheetSize.behavior === Contract.SheetSizeBehavior.Automatic; + if (!isAutomatic && !partialSheetSize.minSize && !partialSheetSize.maxSize) { + throw invalidSizeError; + } + if (!isAutomatic && this.sheetType === Contract.SheetType.Worksheet) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSizeBehaviorOnWorksheet, 'Only SheetSizeBehavior.Automatic is allowed on Worksheets'); + } + if (isAutomatic && this.getSheetSize().behavior === partialSheetSize.behavior) { + return Promise.resolve(newSize); + } + var processedNewSize = this.processNewSize(partialSheetSize); + var sizeService = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("size-service" /* Size */); + return sizeService.changeSizeAsync(this.name, processedNewSize).then(function () { + var clientInfoService = ServiceRegistry_1.ApiServiceRegistry.get(_this._registryId).getService("client-info-service" /* ClientInfo */); + return clientInfoService.getClientInfoAsync().then(function (bootstrapInfo) { + var sheet = bootstrapInfo.publishedSheets.find(function (s) { return s.name === _this.name; }); + if (!sheet) { + throw new TableauError_1.TableauError(Contract.SharedErrorCodes.InternalError, "Can't find sheet with name " + _this.name); + } + var sheetSize = SheetUtils_1.SheetUtils.getSheetSizeFromSizeConstraints(sheet.sizeConstraint); + _this._sheetInfoImpl.sheetSize = sheetSize; + return sheetSize; + }); + }); + }; + SheetImpl.prototype.normalizeSheetSize = function (newSize) { + var behavior = newSize.behavior; + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(behavior, Contract.SheetSizeBehavior, 'SheetSizeBehavior'); + var minSize = SheetImpl.parseDimensions(newSize.minSize); + var maxSize = SheetImpl.parseDimensions(newSize.maxSize); + return { behavior: behavior, minSize: minSize, maxSize: maxSize }; + }; + SheetImpl.prototype.processNewSize = function (newSize) { + var _a, _b, _c, _d; + var behavior = newSize.behavior, minSizeMaybe = newSize.minSize, maxSizeMaybe = newSize.maxSize; + var hasMinWidth = !Param_1.Param.isNullOrUndefined((_a = minSizeMaybe) === null || _a === void 0 ? void 0 : _a.width); + var hasMinHeight = !Param_1.Param.isNullOrUndefined((_b = minSizeMaybe) === null || _b === void 0 ? void 0 : _b.height); + var hasMaxWidth = !Param_1.Param.isNullOrUndefined((_c = maxSizeMaybe) === null || _c === void 0 ? void 0 : _c.width); + var hasMaxHeight = !Param_1.Param.isNullOrUndefined((_d = maxSizeMaybe) === null || _d === void 0 ? void 0 : _d.height); + var hasValidMinSize = hasMinWidth && hasMinHeight; + var hasValidMaxSize = hasMaxWidth && hasMaxHeight; + switch (behavior) { + case Contract.SheetSizeBehavior.Automatic: { + return { behavior: behavior }; + } + case Contract.SheetSizeBehavior.AtMost: { + if (!maxSizeMaybe || !hasValidMaxSize) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.MissingMaxSize, 'Missing maxSize for SheetSizeBehavior.AtMost'); + } + var maxSize = { width: maxSizeMaybe.width, height: maxSizeMaybe.height }; + if (maxSize.width < 0 || maxSize.height < 0) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Size value cannot be less than zero'); + } + return { behavior: behavior, maxSize: maxSize }; + } + case Contract.SheetSizeBehavior.AtLeast: { + if (!minSizeMaybe || !hasValidMinSize) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.MissingMinSize, 'Missing minSize for SheetSizeBehavior.AtLeast'); + } + var minSize = { width: minSizeMaybe.width, height: minSizeMaybe.height }; + if (minSize.width < 0 || minSize.height < 0) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Size value cannot be less than zero'); + } + return { behavior: behavior, minSize: minSize }; + } + case Contract.SheetSizeBehavior.Range: { + if (!minSizeMaybe || !maxSizeMaybe || !hasValidMinSize || !hasValidMaxSize) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.MissingMinMaxSize, 'Missing minSize or maxSize for SheetSizeBehavior.Range'); + } + var minSize = { width: minSizeMaybe.width, height: minSizeMaybe.height }; + var maxSize = { width: maxSizeMaybe.width, height: maxSizeMaybe.height }; + if (minSize.width < 0 || + minSize.height < 0 || + maxSize.width < 0 || + maxSize.height < 0 || + minSize.width > maxSize.width || + minSize.height > maxSize.height) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Missing minSize or maxSize for SheetSizeBehavior.Range'); + } + return { behavior: behavior, minSize: minSize, maxSize: maxSize }; + } + case Contract.SheetSizeBehavior.Exactly: { + if (minSizeMaybe && maxSizeMaybe) { + if (hasValidMinSize && hasValidMaxSize) { + var minSize = { width: minSizeMaybe.width, height: minSizeMaybe.height }; + var maxSize = { width: maxSizeMaybe.width, height: maxSizeMaybe.height }; + if (minSize.width !== maxSize.width || minSize.height !== maxSize.height) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Conflicting size values for SheetSizeBehavior.Exactly'); + } + return { behavior: behavior, minSize: minSize, maxSize: maxSize }; + } + if (hasValidMinSize) { + var minSize = { width: minSizeMaybe.width, height: minSizeMaybe.height }; + return { behavior: behavior, minSize: minSize, maxSize: minSize }; + } + if (hasValidMaxSize) { + var maxSize = { width: maxSizeMaybe.width, height: maxSizeMaybe.height }; + return { behavior: behavior, minSize: maxSize, maxSize: maxSize }; + } + } + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Invalid sheet size parameter'); + } + default: { + throw new TableauError_1.TableauError(Contract.SharedErrorCodes.InternalError, "Unsupported sheet size behavior: " + behavior); + } + } + }; + SheetImpl.parseDimensions = function (size) { + var empty = { width: undefined, height: undefined }; + if (!size) { + return empty; + } + var _a = Param_1.Param.tryParseNumber(size.width), widthParsed = _a.success, parsedWidth = _a.parsed; + var _b = Param_1.Param.tryParseNumber(size.height), heightParsed = _b.success, parsedHeight = _b.parsed; + if (widthParsed && heightParsed) { + return { width: parsedWidth, height: parsedHeight }; + } + if (widthParsed) { + return { width: parsedWidth }; + } + if (heightParsed) { + return { height: parsedHeight }; + } + return empty; + }; + return SheetImpl; +}()); +exports.SheetImpl = SheetImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/SheetInfoImpl.js": +/*!****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/SheetInfoImpl.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var SheetInfoImpl = /** @class */ (function () { + function SheetInfoImpl(_name, _sheetType, _sheetSize, _index, _isActive, _isHidden, _url) { + this._name = _name; + this._sheetType = _sheetType; + this._sheetSize = _sheetSize; + this._index = _index; + this._isActive = _isActive; + this._isHidden = _isHidden; + this._url = _url; + } + Object.defineProperty(SheetInfoImpl.prototype, "name", { + get: function () { + return this._name; + }, + set: function (sheetName) { + this._name = sheetName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "sheetSize", { + get: function () { + return this._sheetSize; + }, + set: function (value) { + this._sheetSize = value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "sheetType", { + get: function () { + return this._sheetType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "sheetPath", { + get: function () { + return { + sheetName: this.name, + isDashboard: this.sheetType === api_external_contract_js_1.SheetType.Dashboard, + }; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "index", { + get: function () { + return this._index; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "isActive", { + get: function () { + return this._isActive; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "active", { + set: function (active) { + this._isActive = active; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "isHidden", { + get: function () { + return this._isHidden; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(SheetInfoImpl.prototype, "url", { + get: function () { + return this._url; + }, + enumerable: true, + configurable: true + }); + return SheetInfoImpl; +}()); +exports.SheetInfoImpl = SheetInfoImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/SingleEventManagerImpl.js": +/*!*************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/SingleEventManagerImpl.js ***! + \*************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * This class implements the SingleEventManager interface for a single type of Tableau event + * + * @template TEventType The Tableau event type this class specializes + */ +var SingleEventManagerImpl = /** @class */ (function () { + function SingleEventManagerImpl(eventType) { + this._eventType = eventType; + this._handlers = []; + } + Object.defineProperty(SingleEventManagerImpl.prototype, "eventType", { + get: function () { + return this._eventType; + }, + enumerable: true, + configurable: true + }); + SingleEventManagerImpl.prototype.addEventListener = function (handler) { + var _this = this; + this._handlers.push(handler); + return function () { return _this.removeEventListener(handler); }; + }; + SingleEventManagerImpl.prototype.removeEventListener = function (handler) { + var beforeCount = this._handlers.length; + this._handlers = this._handlers.filter(function (h) { return h !== handler; }); + return beforeCount > this._handlers.length; + }; + SingleEventManagerImpl.prototype.triggerEvent = function (eventGenerator) { + for (var _i = 0, _a = this._handlers; _i < _a.length; _i++) { + var handler = _a[_i]; + try { + var eventModel = eventGenerator(); + handler(eventModel); + } + catch (e) { + // Since this handler could be outside our control, just catch anything it throws and continue on + continue; + } + } + }; + return SingleEventManagerImpl; +}()); +exports.SingleEventManagerImpl = SingleEventManagerImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/StoryImpl.js": +/*!************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/StoryImpl.js ***! + \************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var ServiceRegistry_1 = __webpack_require__(/*! ../Services/ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var ShortLivedDeferred_1 = __webpack_require__(/*! ../Utils/ShortLivedDeferred */ "../api-shared-js/lib/src/ApiShared/Utils/ShortLivedDeferred.js"); +var SheetImpl_1 = __webpack_require__(/*! ./SheetImpl */ "../api-shared-js/lib/src/ApiShared/Impl/SheetImpl.js"); +var StoryPointImpl_1 = __webpack_require__(/*! ./StoryPointImpl */ "../api-shared-js/lib/src/ApiShared/Impl/StoryPointImpl.js"); +var StoryPointInfoImpl_1 = __webpack_require__(/*! ./StoryPointInfoImpl */ "../api-shared-js/lib/src/ApiShared/Impl/StoryPointInfoImpl.js"); +var StoryImpl = /** @class */ (function (_super) { + __extends(StoryImpl, _super); + function StoryImpl(_sheetInfoImpl, storyModel, _publishedSheetInfos, _registryId) { + var _this = _super.call(this, _sheetInfoImpl, _registryId) || this; + _this._sheetInfoImpl = _sheetInfoImpl; + _this._publishedSheetInfos = _publishedSheetInfos; + _this._registryId = _registryId; + _this._storyPointInfoImpls = []; + _this._deferred = new ShortLivedDeferred_1.ShortLivedDeferred(); + _this.initializeStory(storyModel); + return _this; + } + StoryImpl.prototype.initializeStory = function (storyModel) { + var _this = this; + storyModel.storyPoints.forEach(function (storyPointModel) { + var isActive = storyPointModel.index === storyModel.activeStoryPointIndex; + var storyPointInfoImpl = new StoryPointInfoImpl_1.StoryPointInfoImpl(storyPointModel.caption, storyPointModel.index, storyPointModel.storyPointId, isActive, storyPointModel.updated, _this); + _this._storyPointInfoImpls.push(storyPointInfoImpl); + if (isActive) { + _this._activeStoryPointImpl = new StoryPointImpl_1.StoryPointImpl(storyPointInfoImpl, _this._publishedSheetInfos, _this._registryId, storyPointModel.containedSheetInfo); + } + }); + }; + StoryImpl.prototype.updateStoryInfo = function (index, storyPointModel) { + if (!this._storyPointInfoImpls) { + return; + } + var storyInfoImpl = this._storyPointInfoImpls[index]; + if (storyInfoImpl.storyPointId !== storyPointModel.storyPointId) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.StoryPointIdMismatch, "We should not be updating a story point when the IDs don't match. Existing storyPointID=" + storyInfoImpl.storyPointId + ", newStoryPointID=" + storyPointModel.storyPointId); + } + storyInfoImpl.caption = storyPointModel.caption; + storyInfoImpl.updated = storyPointModel.updated; + if (this._activeStoryPointImpl.storyPointId === storyPointModel.storyPointId) { + this._activeStoryPointImpl.updated = storyInfoImpl.updated; + } + }; + StoryImpl.prototype.updateStory = function (storyPointModel) { + var _this = this; + if (!this._storyPointInfoImpls) { + return; + } + this._storyPointInfoImpls.forEach(function (storyPointInfoImpl) { + var isActive = storyPointInfoImpl.storyPointId === storyPointModel.storyPointId; + if (isActive) { + // update the state + storyPointInfoImpl.caption = storyPointModel.caption; + storyPointInfoImpl.index = storyPointModel.index; + storyPointInfoImpl.active = true; + storyPointInfoImpl.updated = storyPointModel.updated; + // re-initialize activeStoryPointImpl + _this._activeStoryPointImpl = new StoryPointImpl_1.StoryPointImpl(storyPointInfoImpl, _this._publishedSheetInfos, _this._registryId, storyPointModel.containedSheetInfo); + } + else { + // set old ones to false + storyPointInfoImpl.active = false; + } + }); + if (this.activeStoryPoint) { + this._deferred.resolve(this.activeStoryPoint); + } + }; + Object.defineProperty(StoryImpl.prototype, "activeStoryPoint", { + get: function () { + return this._activeStoryPointImpl; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryImpl.prototype, "storyPointsInfo", { + get: function () { + return this._storyPointInfoImpls; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryImpl.prototype, "isActive", { + get: function () { + return this._sheetInfoImpl.active; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryImpl.prototype, "isHidden", { + get: function () { + return !!this._sheetInfoImpl.isHidden; + }, + enumerable: true, + configurable: true + }); + StoryImpl.prototype.activateNextStoryPointAsync = function () { + if (this._activeStoryPointImpl.index === this._storyPointInfoImpls.length - 1) { + return Promise.resolve(this._activeStoryPointImpl); + } + var promise = this._deferred.getNewPromiseOrThrowIfBusy(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("story-activation-service" /* StoryActivation */); + service.activateNextStoryPointAsync(); + return promise; + }; + StoryImpl.prototype.activatePreviousStoryPointAsync = function () { + if (this._activeStoryPointImpl.index === 0) { + return Promise.resolve(this._activeStoryPointImpl); + } + var promise = this._deferred.getNewPromiseOrThrowIfBusy(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("story-activation-service" /* StoryActivation */); + service.activatePreviousStoryPointAsync(); + return promise; + }; + StoryImpl.prototype.activateStoryPointAsync = function (index) { + ErrorHelpers_1.ErrorHelpers.verifyParameter(index, 'index'); + ErrorHelpers_1.ErrorHelpers.verifyParameterType(index, 'number', 'index'); + if (index < 0 || index >= this._storyPointInfoImpls.length) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.IndexOutOfRange, 'The index passed to this command is out of range.'); + } + if (index === this._activeStoryPointImpl.index) { + return Promise.resolve(this._activeStoryPointImpl); + } + var promise = this._deferred.getNewPromiseOrThrowIfBusy(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("story-activation-service" /* StoryActivation */); + service.activateStoryPointAsync(index); + return promise; + }; + StoryImpl.prototype.revertStoryPointAsync = function (index) { + var _this = this; + ErrorHelpers_1.ErrorHelpers.verifyParameter(index, 'index'); + ErrorHelpers_1.ErrorHelpers.verifyParameterType(index, 'number', 'index'); + if (index < 0 || index >= this._storyPointInfoImpls.length) { + throw new TableauError_1.TableauError(Contract.EmbeddingErrorCodes.IndexOutOfRange, 'The index passed to this command is out of range.'); + } + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("story-activation-service" /* StoryActivation */); + return service.revertStoryPointAsync(index).then(function (response) { + _this.updateStoryInfo(response.index, response); + var storyPointInfoImpl = new StoryPointInfoImpl_1.StoryPointInfoImpl(response.caption, response.index, response.storyPointId, false, response.updated, _this); + return storyPointInfoImpl; + }); + }; + StoryImpl.prototype.clearPendingPromises = function () { + if (this._deferred) { + this._deferred.reject('All pending promises cleared'); + } + }; + return StoryImpl; +}(SheetImpl_1.SheetImpl)); +exports.StoryImpl = StoryImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/StoryPointImpl.js": +/*!*****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/StoryPointImpl.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var SheetUtils_1 = __webpack_require__(/*! ../Utils/SheetUtils */ "../api-shared-js/lib/src/ApiShared/Utils/SheetUtils.js"); +var DashboardImpl_1 = __webpack_require__(/*! ./DashboardImpl */ "../api-shared-js/lib/src/ApiShared/Impl/DashboardImpl.js"); +var SheetInfoImpl_1 = __webpack_require__(/*! ./SheetInfoImpl */ "../api-shared-js/lib/src/ApiShared/Impl/SheetInfoImpl.js"); +var WorksheetImpl_1 = __webpack_require__(/*! ./WorksheetImpl */ "../api-shared-js/lib/src/ApiShared/Impl/WorksheetImpl.js"); +var StoryPointImpl = /** @class */ (function () { + function StoryPointImpl(_storyPointInfoImpl, sheetInfos, registryId, containedSheetInfo) { + this._storyPointInfoImpl = _storyPointInfoImpl; + if (containedSheetInfo) { + this._containedSheetImpl = this.createContainedSheet(containedSheetInfo, sheetInfos, registryId); + } + } + Object.defineProperty(StoryPointImpl.prototype, "index", { + get: function () { + return this._storyPointInfoImpl.index; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointImpl.prototype, "caption", { + get: function () { + return this._storyPointInfoImpl.caption; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointImpl.prototype, "active", { + get: function () { + return this._storyPointInfoImpl.active; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointImpl.prototype, "updated", { + get: function () { + return this._storyPointInfoImpl.updated; + }, + set: function (updated) { + this._storyPointInfoImpl.updated = updated; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointImpl.prototype, "parentStory", { + get: function () { + return this._storyPointInfoImpl.parentStory; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointImpl.prototype, "containedSheet", { + get: function () { + return this._containedSheetImpl; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointImpl.prototype, "storyPointId", { + get: function () { + return this._storyPointInfoImpl.storyPointId; + }, + enumerable: true, + configurable: true + }); + StoryPointImpl.prototype.createContainedSheet = function (containedSheetInfo, sheetInfos, registryId) { + var containedSheetIdx = -1; + var publishedSheetInfo = SheetUtils_1.SheetUtils.getPublishedSheetInfoByName(containedSheetInfo.name, sheetInfos); + var containedSheetSize = SheetUtils_1.SheetUtils.createAutomaticSize(); + var isContainedSheetHidden = publishedSheetInfo === undefined; + var containedSheetUrl = publishedSheetInfo ? publishedSheetInfo.url : ''; + // Contained sheets aren't active - the containing sheet is active. + var containedSheetActive = false; + var containedSheetInfoImpl = new SheetInfoImpl_1.SheetInfoImpl(containedSheetInfo.name, SheetUtils_1.SheetUtils.getSheetTypeEnum(containedSheetInfo.sheetType), containedSheetSize, containedSheetIdx, containedSheetActive, isContainedSheetHidden, containedSheetUrl); + var sheetImpl; + switch (containedSheetInfoImpl.sheetType) { + case Contract.SheetType.Worksheet: { + var vizId = { + worksheet: containedSheetInfoImpl.name, + }; + sheetImpl = new WorksheetImpl_1.WorksheetImpl(containedSheetInfoImpl, registryId, vizId, null, this); + break; + } + case Contract.SheetType.Dashboard: { + var sheetPath = { + sheetName: containedSheetInfoImpl.name, + isDashboard: true, + }; + sheetImpl = new DashboardImpl_1.DashboardImpl(containedSheetInfoImpl, containedSheetInfo.dashboardZones, sheetPath, registryId, this); + break; + } + default: { + throw new TableauError_1.TableauError(Contract.SharedErrorCodes.ServerError, 'Invalid SheetType'); + } + } + return sheetImpl; + }; + return StoryPointImpl; +}()); +exports.StoryPointImpl = StoryPointImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/StoryPointInfoImpl.js": +/*!*********************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/StoryPointInfoImpl.js ***! + \*********************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var StoryPointInfoImpl = /** @class */ (function () { + function StoryPointInfoImpl(_caption, _index, _storyPointId, _active, _updated, _parentStoryImpl) { + this._caption = _caption; + this._index = _index; + this._storyPointId = _storyPointId; + this._active = _active; + this._updated = _updated; + this._parentStoryImpl = _parentStoryImpl; + } + Object.defineProperty(StoryPointInfoImpl.prototype, "caption", { + get: function () { + return this._caption; + }, + set: function (caption) { + this._caption = caption; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointInfoImpl.prototype, "index", { + get: function () { + return this._index; + }, + set: function (index) { + this._index = index; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointInfoImpl.prototype, "storyPointId", { + get: function () { + return this._storyPointId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointInfoImpl.prototype, "active", { + get: function () { + return this._active; + }, + set: function (isActive) { + this._active = isActive; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointInfoImpl.prototype, "updated", { + get: function () { + return this._updated; + }, + set: function (isUpdated) { + this._updated = isUpdated; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(StoryPointInfoImpl.prototype, "parentStory", { + get: function () { + return this._parentStoryImpl; + }, + enumerable: true, + configurable: true + }); + return StoryPointInfoImpl; +}()); +exports.StoryPointInfoImpl = StoryPointInfoImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/WorkbookImpl.js": +/*!***************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/WorkbookImpl.js ***! + \***************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var WorkbookImpl = /** @class */ (function () { + function WorkbookImpl() { + } + return WorkbookImpl; +}()); +exports.WorkbookImpl = WorkbookImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Impl/WorksheetImpl.js": +/*!****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Impl/WorksheetImpl.js ***! + \****************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var DataSource_1 = __webpack_require__(/*! ../DataSource */ "../api-shared-js/lib/src/ApiShared/DataSource.js"); +var LogicalTable_1 = __webpack_require__(/*! ../LogicalTable */ "../api-shared-js/lib/src/ApiShared/LogicalTable.js"); +var GetDataService_1 = __webpack_require__(/*! ../Services/GetDataService */ "../api-shared-js/lib/src/ApiShared/Services/GetDataService.js"); +var ServiceRegistry_1 = __webpack_require__(/*! ../Services/ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var DataSourceImpl_1 = __webpack_require__(/*! ./DataSourceImpl */ "../api-shared-js/lib/src/ApiShared/Impl/DataSourceImpl.js"); +var SheetImpl_1 = __webpack_require__(/*! ./SheetImpl */ "../api-shared-js/lib/src/ApiShared/Impl/SheetImpl.js"); +var WorksheetImpl = /** @class */ (function (_super) { + __extends(WorksheetImpl, _super); + function WorksheetImpl(sheetInfoImpl, _registryId, _visualId, _parentDashboardImpl, _parentStoryPointImpl) { + var _this = _super.call(this, sheetInfoImpl, _registryId) || this; + _this._visualId = _visualId; + _this._parentDashboardImpl = _parentDashboardImpl; + _this._parentStoryPointImpl = _parentStoryPointImpl; + return _this; + } + Object.defineProperty(WorksheetImpl.prototype, "parentDashboard", { + get: function () { + return this._parentDashboardImpl; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(WorksheetImpl.prototype, "parentStoryPoint", { + get: function () { + return this._parentStoryPointImpl; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(WorksheetImpl.prototype, "visualId", { + get: function () { + return this._visualId; + }, + enumerable: true, + configurable: true + }); + WorksheetImpl.prototype.getMaxPageRowLimit = function () { + return 10000; + }; + WorksheetImpl.prototype.applyFilterAsync = function (fieldName, values, updateType, options) { + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(updateType, Contract.FilterUpdateType, 'Contract.FilterUpdateType'); + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.applyFilterAsync(this.visualId, fieldName, values, updateType, options); + }; + WorksheetImpl.prototype.applyRangeFilterAsync = function (fieldName, filterOptions) { + ErrorHelpers_1.ErrorHelpers.verifyParameter(fieldName, 'fieldName'); + ErrorHelpers_1.ErrorHelpers.verifyParameter(filterOptions, 'filterOptions'); + if (filterOptions.nullOption) { + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(filterOptions.nullOption, api_external_contract_js_1.FilterNullOption, 'FilterNullOption'); + } + else { + ErrorHelpers_1.ErrorHelpers.verifyRangeParamType(filterOptions.min, filterOptions.max); + } + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.applyRangeFilterAsync(this.visualId, fieldName, filterOptions); + }; + WorksheetImpl.prototype.applyHierarchicalFilterAsync = function (fieldName, values, updateType, options) { + ErrorHelpers_1.ErrorHelpers.verifyParameter(fieldName, 'fieldName'); + ErrorHelpers_1.ErrorHelpers.verifyParameter(values, 'values'); + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(updateType, Contract.FilterUpdateType, 'Contract.FilterUpdateType'); + if (!Array.isArray(values) && !values.levels) { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'values parameter for applyHierarchicalFilterAsync must be an array or contain a levels key'); + } + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.applyHierarchicalFilterAsync(this.visualId, fieldName, values, updateType, options); + }; + WorksheetImpl.prototype.clearFilterAsync = function (fieldName) { + ErrorHelpers_1.ErrorHelpers.verifyParameter(fieldName, 'fieldName'); + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.clearFilterAsync(this.visualId, fieldName); + }; + WorksheetImpl.prototype.applyRelativeDateFilterAsync = function (fieldName, options) { + ErrorHelpers_1.ErrorHelpers.verifyStringParameter(fieldName, 'fieldName'); + ErrorHelpers_1.ErrorHelpers.verifyParameter(options, 'options'); + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(options.periodType, api_external_contract_js_1.PeriodType, 'PeriodType'); + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(options.rangeType, api_external_contract_js_1.DateRangeType, 'DateRangeType'); + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.applyRelativeDateFilterAsync(this.visualId, fieldName, options); + }; + WorksheetImpl.prototype.getDataSourcesAsync = function () { + var _this = this; + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("data-source-service" /* DataSourceService */); + return service.getDataSourcesAsync(this.visualId).then(function (result) { + var dataSchema = result; + var worksheetDataSourceInfo = dataSchema.worksheetDataSchemaMap[_this.name]; + var dataSources = []; + // First, add the primary datasource. By convention, it comes first in the returned array. + var primaryId = worksheetDataSourceInfo.primaryDataSource; + dataSources.push(_this.createDataSourceFromInfo(dataSchema.dataSources[primaryId])); + // Then, loop through any secondary data sources and add them. + for (var _i = 0, _a = worksheetDataSourceInfo.referencedDataSourceList; _i < _a.length; _i++) { + var secondaryId = _a[_i]; + if (secondaryId !== primaryId) { + dataSources.push(_this.createDataSourceFromInfo(dataSchema.dataSources[secondaryId])); + } + } + return dataSources; + }); + }; + WorksheetImpl.prototype.getFiltersAsync = function () { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.getFiltersAsync(this.visualId); + }; + WorksheetImpl.prototype.getSelectedMarksAsync = function () { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + return service.getSelectedMarksAsync(this.visualId); + }; + WorksheetImpl.prototype.getHighlightedMarksAsync = function () { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + return service.getHighlightedMarksAsync(this.visualId); + }; + WorksheetImpl.prototype.getSummaryDataAsync = function (options) { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + options = options || {}; + return service.getUnderlyingDataAsync(this.visualId, GetDataService_1.GetDataType.Summary, !!options.ignoreAliases, !!options.ignoreSelection, true, options.columnsToIncludeById || [], options.maxRows || 0, options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues); + }; + WorksheetImpl.prototype.getSummaryDataReaderAsync = function (pageRowCount, options) { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + options = options || {}; + return service.getSummaryDataReaderAsync(this.visualId, pageRowCount || this.getMaxPageRowLimit(), !!options.ignoreAliases, !!options.ignoreSelection, true, // includeAllColumns (can be overridden by columnsToIncludeById) + options.columnsToIncludeById || [], options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues); + }; + WorksheetImpl.prototype.getVisualSpecificationAsync = function () { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("visual-model-service" /* VisualModel */); + return service.getVisualSpecificationAsync(this.visualId); + }; + WorksheetImpl.prototype.getSummaryColumnsInfoAsync = function () { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + return service.getSummaryColumnsInfoAsync(this.visualId); + }; + WorksheetImpl.prototype.getUnderlyingDataAsync = function (options) { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + options = options || {}; + return service.getUnderlyingDataAsync(this.visualId, GetDataService_1.GetDataType.Underlying, !!options.ignoreAliases, !!options.ignoreSelection, !!options.includeAllColumns, options.columnsToIncludeById || [], options.maxRows || 0, options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues); + }; + WorksheetImpl.prototype.getUnderlyingTablesAsync = function () { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("data-source-service" /* DataSourceService */); + return service.getUnderlyingTablesAsync(this.visualId).then(function (logicalTableInfos) { + return logicalTableInfos.map(function (logicalTableInfo) { return new LogicalTable_1.LogicalTable(logicalTableInfo); }); + }); + }; + WorksheetImpl.prototype.getUnderlyingTableDataAsync = function (logicalTableId, options) { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + options = options || {}; + return service.getUnderlyingTableDataAsync(this.visualId, logicalTableId, !!options.ignoreAliases, !!options.ignoreSelection, !!options.includeAllColumns, options.columnsToIncludeById || [], options.maxRows || 0, options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues); + }; + WorksheetImpl.prototype.getUnderlyingTableDataReaderAsync = function (logicalTableId, pageRowCount, options) { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + options = options || {}; + return service.getUnderlyingTableDataReaderAsync(this.visualId, logicalTableId, pageRowCount || this.getMaxPageRowLimit(), !!options.ignoreAliases, !!options.ignoreSelection, !!options.includeAllColumns, options.columnsToIncludeById || [], options.includeDataValuesOption || api_external_contract_js_1.IncludeDataValuesOption.AllValues); + }; + WorksheetImpl.prototype.clearSelectedMarksAsync = function () { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("selection-service" /* Selection */); + return service.clearSelectedMarksAsync(this.visualId); + }; + WorksheetImpl.prototype.selectMarksByValueAsync = function (selections, selectionUpdateType) { + ErrorHelpers_1.ErrorHelpers.verifyParameter(selections, 'fieldName'); + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(selectionUpdateType, api_external_contract_js_1.SelectionUpdateType, 'SelectionUpdateType'); + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("selection-service" /* Selection */); + return service.selectMarksByValueAsync(this.visualId, selections, selectionUpdateType); + }; + WorksheetImpl.prototype.selectMarksByIdAsync = function (selections, selectionUpdateType) { + ErrorHelpers_1.ErrorHelpers.verifyParameter(selections, 'fieldName'); + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(selectionUpdateType, api_external_contract_js_1.SelectionUpdateType, 'SelectionUpdateType'); + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("selection-service" /* Selection */); + return service.selectMarksByIdAsync(this.visualId, selections, selectionUpdateType); + }; + WorksheetImpl.prototype.annotateMarkAsync = function (mark, annotationText) { + ErrorHelpers_1.ErrorHelpers.verifyParameter(mark, 'mark'); + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("annotation-service" /* Annotation */); + return service.annotateMarkAsync(this.visualId, mark, annotationText); + }; + WorksheetImpl.prototype.getAnnotationsAsync = function () { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("annotation-service" /* Annotation */); + return service.getAnnotationsAsync(this.visualId); + }; + WorksheetImpl.prototype.removeAnnotationAsync = function (annotation) { + ErrorHelpers_1.ErrorHelpers.verifyParameter(annotation, 'annotation'); + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("annotation-service" /* Annotation */); + return service.removeAnnotationAsync(this.visualId, annotation); + }; + WorksheetImpl.prototype.appendContextMenuAsync = function (targetMenu, config) { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("external-context-menu-service" /* ExternalContextMenu */); + return service.appendContextMenuAsync(this.visualId.worksheet, targetMenu, config); + }; + WorksheetImpl.prototype.removeContextMenuAsync = function (targetMenu, menuItemId) { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("external-context-menu-service" /* ExternalContextMenu */); + return service.removeContextMenuAsync(this.visualId.worksheet, targetMenu, menuItemId); + }; + WorksheetImpl.prototype.executeContextMenuAsync = function (targetMenu, menuItemId) { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("external-context-menu-service" /* ExternalContextMenu */); + return service.executeContextMenuAsync(this.visualId.worksheet, targetMenu, menuItemId); + }; + WorksheetImpl.prototype.renameContextMenuAsync = function (targetMenu, menuHeader, menuDescription) { + this.verifyActiveSheet(); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("external-context-menu-service" /* ExternalContextMenu */); + return service.renameContextMenuAsync(this.visualId.worksheet, targetMenu, menuHeader, menuDescription); + }; + WorksheetImpl.prototype.hoverTupleAsync = function (hoveredTuple, tooltip, allowHoverActions) { + if (this.isInsideDashboardExtension()) { + return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, "hoverTupleAsync is not supported in dashboard extensions")); + } + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("selection-service" /* Selection */); + return service.hoverTupleAsync(this.visualId, hoveredTuple, tooltip, allowHoverActions); + }; + WorksheetImpl.prototype.selectTuplesAsync = function (selectedTuples, selectOption, tooltip) { + if (this.isInsideDashboardExtension()) { + return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, "selectTuplesAsync is not supported in dashboard extensions")); + } + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("selection-service" /* Selection */); + return service.selectTuplesAsync(this.visualId, selectedTuples, selectOption, tooltip); + }; + WorksheetImpl.prototype.getTooltipTextAsync = function (tupleId) { + if (this.isInsideDashboardExtension()) { + return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, "getTooltipTextAsync is not supported in dashboard extensions")); + } + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("accessibility" /* Accessibility */); + return service.getTooltipTextAsync(this.visualId, tupleId); + }; + WorksheetImpl.prototype.leaveMarkNavigationAsync = function () { + if (this.isInsideDashboardExtension()) { + return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, "leaveMarkNavigationAsync is not supported in dashboard extensions")); + } + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("accessibility" /* Accessibility */); + return service.leaveMarkNavigationAsync(this.visualId); + }; + WorksheetImpl.prototype.createDataSourceFromInfo = function (dataSourceInfo) { + var dataSourceImpl = new DataSourceImpl_1.DataSourceImpl(dataSourceInfo, this._registryId); + var dataSource = new DataSource_1.DataSource(dataSourceImpl); + dataSourceImpl.initializeWithPublicInterfaces(dataSource); + return dataSource; + }; + WorksheetImpl.prototype.verifyActiveSheet = function () { + var isRootAndActiveWorksheet = this.active; + var isInsideActiveDashboard = this.isInsideActiveDashboard(); + var isInsideActiveStoryPoint = this.isInsideActiveStoryPoint(); + if (!isRootAndActiveWorksheet && !isInsideActiveDashboard && !isInsideActiveStoryPoint) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.NotActiveSheet, 'Operation not allowed on non-active sheet'); + } + }; + WorksheetImpl.prototype.isInsideActiveStoryPoint = function () { + return this._parentStoryPointImpl && this._parentStoryPointImpl.active; + }; + WorksheetImpl.prototype.isInsideActiveDashboard = function () { + return this._parentDashboardImpl && this._parentDashboardImpl.active; + }; + WorksheetImpl.prototype.isInsideDashboardExtension = function () { + return this._parentDashboardImpl !== null; + }; + return WorksheetImpl; +}(SheetImpl_1.SheetImpl)); +exports.WorksheetImpl = WorksheetImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/LogicalTable.js": +/*!**********************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/LogicalTable.js ***! + \**********************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Implementation of a logical table. + * This does not follow the Impl pattern as it is just a property bag. + */ +var LogicalTable = /** @class */ (function () { + function LogicalTable(_logicalTable) { + this._logicalTable = _logicalTable; + } + Object.defineProperty(LogicalTable.prototype, "id", { + get: function () { + return this._logicalTable.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(LogicalTable.prototype, "caption", { + get: function () { + return this._logicalTable.caption; + }, + enumerable: true, + configurable: true + }); + return LogicalTable; +}()); +exports.LogicalTable = LogicalTable; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Models/AccessibilityModels.js": +/*!************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Models/AccessibilityModels.js ***! + \************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var TooltipTextRequestModel = /** @class */ (function () { + function TooltipTextRequestModel(visualIdPresModel, tupleId) { + this.visualIdPresModel = visualIdPresModel; + this.tupleId = tupleId; + } + return TooltipTextRequestModel; +}()); +exports.TooltipTextRequestModel = TooltipTextRequestModel; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Models/FilterModels.js": +/*!*****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Models/FilterModels.js ***! + \*****************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var ServiceRegistry_1 = __webpack_require__(/*! ../Services/ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var Filter = /** @class */ (function () { + function Filter(_worksheetName, _fieldName, _filterType, _fieldId, _registryId) { + this._worksheetName = _worksheetName; + this._fieldName = _fieldName; + this._filterType = _filterType; + this._fieldId = _fieldId; + this._registryId = _registryId; + } + Object.defineProperty(Filter.prototype, "worksheetName", { + get: function () { + return this._worksheetName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Filter.prototype, "fieldName", { + get: function () { + return this._fieldName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Filter.prototype, "fieldId", { + get: function () { + return this._fieldId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Filter.prototype, "filterType", { + get: function () { + return this._filterType; + }, + enumerable: true, + configurable: true + }); + Filter.prototype.getFieldAsync = function () { + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("data-source-service" /* DataSourceService */); + return service.getFieldAsync(this._fieldId); + }; + Filter.prototype.getAppliedWorksheetsAsync = function () { + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.getAppliedWorksheetsAsync(this._worksheetName, this._fieldId); + }; + Filter.prototype.setAppliedWorksheetsAsync = function (applyToWorksheets) { + ErrorHelpers_1.ErrorHelpers.verifyParameter(applyToWorksheets, 'applyToWorksheets'); + var uniqueWorksheets = new Set(applyToWorksheets); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.setAppliedWorksheetsAsync(this._worksheetName, this._fieldName, this._fieldId, Array.from(uniqueWorksheets)); + }; + return Filter; +}()); +exports.Filter = Filter; +var CategoricalFilter = /** @class */ (function (_super) { + __extends(CategoricalFilter, _super); + function CategoricalFilter(worksheetName, fieldName, fieldId, filterType, registryId, _appliedValues, _isExcludeMode, _isAllSelected) { + var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId, registryId) || this; + _this._appliedValues = _appliedValues; + _this._isExcludeMode = _isExcludeMode; + _this._isAllSelected = _isAllSelected; + return _this; + } + Object.defineProperty(CategoricalFilter.prototype, "isAllSelected", { + get: function () { + return this._isAllSelected; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CategoricalFilter.prototype, "appliedValues", { + get: function () { + return this._appliedValues; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CategoricalFilter.prototype, "isExcludeMode", { + get: function () { + return this._isExcludeMode; + }, + enumerable: true, + configurable: true + }); + CategoricalFilter.prototype.getDomainAsync = function (domainType) { + if (!domainType) { + domainType = api_external_contract_js_1.FilterDomainType.Relevant; + } + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(domainType, api_external_contract_js_1.FilterDomainType, 'FilterDomainType'); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + return service.getCategoricalDomainAsync(this._worksheetName, this._fieldId, domainType); + }; + return CategoricalFilter; +}(Filter)); +exports.CategoricalFilter = CategoricalFilter; +var HierarchicalDataValue = /** @class */ (function () { + function HierarchicalDataValue(_value, _hierarchicalPath, _level) { + this._value = _value; + this._hierarchicalPath = _hierarchicalPath; + this._level = _level; + } + Object.defineProperty(HierarchicalDataValue.prototype, "value", { + get: function () { + return this._value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(HierarchicalDataValue.prototype, "hierarchicalPath", { + get: function () { + return this._hierarchicalPath; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(HierarchicalDataValue.prototype, "level", { + get: function () { + return this._level; + }, + enumerable: true, + configurable: true + }); + return HierarchicalDataValue; +}()); +exports.HierarchicalDataValue = HierarchicalDataValue; +var HierarchicalLevelDetail = /** @class */ (function () { + function HierarchicalLevelDetail(_name, _levelSelectionState) { + this._name = _name; + this._levelSelectionState = _levelSelectionState; + } + Object.defineProperty(HierarchicalLevelDetail.prototype, "name", { + get: function () { + return this._name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(HierarchicalLevelDetail.prototype, "levelSelectionState", { + get: function () { + return this._levelSelectionState; + }, + enumerable: true, + configurable: true + }); + return HierarchicalLevelDetail; +}()); +exports.HierarchicalLevelDetail = HierarchicalLevelDetail; +var HierarchicalFilter = /** @class */ (function (_super) { + __extends(HierarchicalFilter, _super); + function HierarchicalFilter(worksheetName, fieldName, fieldId, filterType, registryId, _dimensionName, _hierarchyCaption, _numberOfLevels, _levelDetails, _appliedValues, _isAllSelected) { + var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId, registryId) || this; + _this._dimensionName = _dimensionName; + _this._hierarchyCaption = _hierarchyCaption; + _this._numberOfLevels = _numberOfLevels; + _this._levelDetails = _levelDetails; + _this._appliedValues = _appliedValues; + _this._isAllSelected = _isAllSelected; + return _this; + } + HierarchicalFilter.prototype.getDomainAsync = function (domainType) { + throw new Error('Method not implemented.'); + }; + Object.defineProperty(HierarchicalFilter.prototype, "dimensionName", { + get: function () { + return this._dimensionName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(HierarchicalFilter.prototype, "hierarchyCaption", { + get: function () { + return this._hierarchyCaption; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(HierarchicalFilter.prototype, "numberOfLevels", { + get: function () { + return this._numberOfLevels; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(HierarchicalFilter.prototype, "levelDetails", { + get: function () { + return this._levelDetails; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(HierarchicalFilter.prototype, "isAllSelected", { + get: function () { + return this._isAllSelected; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(HierarchicalFilter.prototype, "appliedValues", { + get: function () { + return this._appliedValues; + }, + enumerable: true, + configurable: true + }); + return HierarchicalFilter; +}(Filter)); +exports.HierarchicalFilter = HierarchicalFilter; +var RangeFilter = /** @class */ (function (_super) { + __extends(RangeFilter, _super); + function RangeFilter(worksheetName, fieldName, fieldId, filterType, registryId, _min, _max, _includeNullValues) { + var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId, registryId) || this; + _this._min = _min; + _this._max = _max; + _this._includeNullValues = _includeNullValues; + return _this; + } + Object.defineProperty(RangeFilter.prototype, "minValue", { + get: function () { + return this._min; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RangeFilter.prototype, "maxValue", { + get: function () { + return this._max; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RangeFilter.prototype, "includeNullValues", { + get: function () { + return this._includeNullValues; + }, + enumerable: true, + configurable: true + }); + RangeFilter.prototype.getDomainAsync = function (domainType) { + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("filter-service" /* Filter */); + if (!domainType) { + domainType = api_external_contract_js_1.FilterDomainType.Relevant; + } + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(domainType, api_external_contract_js_1.FilterDomainType, 'FilterDomainType'); + return service.getRangeDomainAsync(this._worksheetName, this._fieldId, domainType); + }; + return RangeFilter; +}(Filter)); +exports.RangeFilter = RangeFilter; +var RelativeDateFilter = /** @class */ (function (_super) { + __extends(RelativeDateFilter, _super); + function RelativeDateFilter(worksheetName, fieldName, fieldId, filterType, registryId, _anchorDate, _periodType, _rangeType, _rangeN) { + var _this = _super.call(this, worksheetName, fieldName, filterType, fieldId, registryId) || this; + _this._anchorDate = _anchorDate; + _this._periodType = _periodType; + _this._rangeType = _rangeType; + _this._rangeN = _rangeN; + return _this; + } + Object.defineProperty(RelativeDateFilter.prototype, "anchorDate", { + get: function () { + return this._anchorDate; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RelativeDateFilter.prototype, "periodType", { + get: function () { + return this._periodType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RelativeDateFilter.prototype, "rangeType", { + get: function () { + return this._rangeType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RelativeDateFilter.prototype, "rangeN", { + get: function () { + return this._rangeN; + }, + enumerable: true, + configurable: true + }); + return RelativeDateFilter; +}(Filter)); +exports.RelativeDateFilter = RelativeDateFilter; +var CategoricalDomain = /** @class */ (function () { + function CategoricalDomain(_values, _domainType) { + this._values = _values; + this._domainType = _domainType; + } + Object.defineProperty(CategoricalDomain.prototype, "values", { + get: function () { + return this._values; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(CategoricalDomain.prototype, "type", { + get: function () { + return this._domainType; + }, + enumerable: true, + configurable: true + }); + return CategoricalDomain; +}()); +exports.CategoricalDomain = CategoricalDomain; +var RangeDomain = /** @class */ (function () { + function RangeDomain(_min, _max, _domainType) { + this._min = _min; + this._max = _max; + this._domainType = _domainType; + } + Object.defineProperty(RangeDomain.prototype, "type", { + get: function () { + return this._domainType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RangeDomain.prototype, "min", { + get: function () { + return this._min; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(RangeDomain.prototype, "max", { + get: function () { + return this._max; + }, + enumerable: true, + configurable: true + }); + return RangeDomain; +}()); +exports.RangeDomain = RangeDomain; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Models/GetDataModels.js": +/*!******************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Models/GetDataModels.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var DataTable = /** @class */ (function () { + function DataTable(_data, _columns, _totalRowCount, _isTotalRowCountLimited, _isSummaryData, _marksInfo) { + this._data = _data; + this._columns = _columns; + this._totalRowCount = _totalRowCount; + this._isTotalRowCountLimited = _isTotalRowCountLimited; + this._isSummaryData = _isSummaryData; + this._marksInfo = _marksInfo; + this._name = _isSummaryData ? 'Summary Data Table' : 'Underlying Data Table'; + } + Object.defineProperty(DataTable.prototype, "name", { + get: function () { + return this._name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "data", { + get: function () { + return this._data; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "columns", { + get: function () { + return this._columns; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "marksInfo", { + get: function () { + return this._marksInfo; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "totalRowCount", { + get: function () { + return this._totalRowCount; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "isTotalRowCountLimited", { + get: function () { + return this._isTotalRowCountLimited; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTable.prototype, "isSummaryData", { + get: function () { + return this._isSummaryData; + }, + enumerable: true, + configurable: true + }); + return DataTable; +}()); +exports.DataTable = DataTable; +var MarkInfo = /** @class */ (function () { + function MarkInfo(_type, _color, _tupleId) { + this._type = _type; + this._color = _color; + this._tupleId = _tupleId; + } + Object.defineProperty(MarkInfo.prototype, "type", { + get: function () { + return this._type; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MarkInfo.prototype, "color", { + get: function () { + return this._color; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(MarkInfo.prototype, "tupleId", { + get: function () { + return this._tupleId; + }, + enumerable: true, + configurable: true + }); + return MarkInfo; +}()); +exports.MarkInfo = MarkInfo; +var Column = /** @class */ (function () { + function Column(_fieldName, _fieldId, _dataType, _isReferenced, _index) { + this._fieldName = _fieldName; + this._fieldId = _fieldId; + this._dataType = _dataType; + this._isReferenced = _isReferenced; + this._index = _index; + } + Object.defineProperty(Column.prototype, "fieldName", { + get: function () { + return this._fieldName; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Column.prototype, "fieldId", { + get: function () { + return this._fieldId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Column.prototype, "dataType", { + get: function () { + return this._dataType; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Column.prototype, "isReferenced", { + get: function () { + return this._isReferenced; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Column.prototype, "index", { + get: function () { + return this._index; + }, + enumerable: true, + configurable: true + }); + return Column; +}()); +exports.Column = Column; +var DataValue = /** @class */ (function () { + /* tslint:disable:no-any */ + function DataValue(_value, _nativeValue, _formattedValue) { + this._value = _value; + this._nativeValue = _nativeValue; + this._formattedValue = _formattedValue; + } + Object.defineProperty(DataValue.prototype, "value", { + get: function () { + return this._value; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataValue.prototype, "nativeValue", { + get: function () { + return this._nativeValue; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataValue.prototype, "formattedValue", { + get: function () { + return this._formattedValue; + }, + enumerable: true, + configurable: true + }); + return DataValue; +}()); +exports.DataValue = DataValue; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Models/GetDataTableReaderModels.js": +/*!*****************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Models/GetDataTableReaderModels.js ***! + \*****************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +var ServiceRegistry_1 = __webpack_require__(/*! ../Services/ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var DataTableReader = /** @class */ (function () { + function DataTableReader(_id, _totalRowCount, _pageRowCount, _registryId) { + this._id = _id; + this._totalRowCount = _totalRowCount; + this._pageRowCount = _pageRowCount; + this._registryId = _registryId; + this._pageCount = Math.ceil(_totalRowCount / _pageRowCount); + } + Object.defineProperty(DataTableReader.prototype, "totalRowCount", { + get: function () { + return this._totalRowCount; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(DataTableReader.prototype, "pageCount", { + get: function () { + return this._pageCount; + }, + enumerable: true, + configurable: true + }); + DataTableReader.prototype.getPageAsync = function (pageNumber) { + ErrorHelpers_1.ErrorHelpers.verifyRange(pageNumber, 0, this._pageCount); + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + return service.getPageAsync(this._id, pageNumber, this._pageRowCount); + }; + DataTableReader.prototype.getAllPagesAsync = function (maxRows) { + return __awaiter(this, void 0, void 0, function () { + var firstPage, rowsRequested, pagesRequested, pagesToFetch, isDataLimited, remainingData, i, page, fullData; + var _a; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: return [4 /*yield*/, this.getPageAsync(0)]; + case 1: + firstPage = _b.sent(); + maxRows = maxRows || this.totalRowCount; + rowsRequested = Math.min(maxRows, this.totalRowCount); + pagesRequested = Math.ceil(rowsRequested / this._pageRowCount); + pagesToFetch = Math.min(pagesRequested, 400); + isDataLimited = pagesToFetch < pagesRequested; + remainingData = []; + i = 1; + _b.label = 2; + case 2: + if (!(i < pagesToFetch)) return [3 /*break*/, 5]; + return [4 /*yield*/, this.getPageAsync(i)]; + case 3: + page = _b.sent(); + remainingData.push(page.data); + _b.label = 4; + case 4: + i++; + return [3 /*break*/, 2]; + case 5: + fullData = (_a = firstPage.data).concat.apply(_a, remainingData); + // This slices the array only if maxRows has been set and is less than totalRowCount + fullData.length = rowsRequested; + return [2 /*return*/, { + name: firstPage.name, + data: fullData, + columns: firstPage.columns, + totalRowCount: isDataLimited ? pagesToFetch * this._pageRowCount : rowsRequested, + isTotalRowCountLimited: isDataLimited, + isSummaryData: firstPage.isSummaryData, + }]; + } + }); + }); + }; + DataTableReader.prototype.releaseAsync = function () { + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("get-data-service" /* GetData */); + return service.releaseAsync(this._id); + }; + return DataTableReader; +}()); +exports.DataTableReader = DataTableReader; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Models/SelectionModels.js": +/*!********************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Models/SelectionModels.js ***! + \********************************************************************/ +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Selection Model. + */ +var SelectionModel = /** @class */ (function () { + function SelectionModel() { + } + return SelectionModel; +}()); +exports.SelectionModel = SelectionModel; +/** + * Value based selection model. Meant for hierarchical, range and categorical selections. + */ +var ValueSelectionModel = /** @class */ (function (_super) { + __extends(ValueSelectionModel, _super); + function ValueSelectionModel() { + var _this = _super !== null && _super.apply(this, arguments) || this; + _this.selectValues = []; + return _this; + } + return ValueSelectionModel; +}(SelectionModel)); +exports.ValueSelectionModel = ValueSelectionModel; +/** + * Hierarchical value selection model + */ +var HierarchicalSelectionModel = /** @class */ (function (_super) { + __extends(HierarchicalSelectionModel, _super); + function HierarchicalSelectionModel() { + return _super !== null && _super.apply(this, arguments) || this; + } + return HierarchicalSelectionModel; +}(ValueSelectionModel)); +exports.HierarchicalSelectionModel = HierarchicalSelectionModel; +/** + * Range based value selection model + */ +var RangeSelectionModel = /** @class */ (function (_super) { + __extends(RangeSelectionModel, _super); + function RangeSelectionModel() { + return _super !== null && _super.apply(this, arguments) || this; + } + return RangeSelectionModel; +}(SelectionModel)); +exports.RangeSelectionModel = RangeSelectionModel; +/** + * Dimension value selection model + */ +var DimensionSelectionModel = /** @class */ (function (_super) { + __extends(DimensionSelectionModel, _super); + function DimensionSelectionModel() { + return _super !== null && _super.apply(this, arguments) || this; + } + return DimensionSelectionModel; +}(ValueSelectionModel)); +exports.DimensionSelectionModel = DimensionSelectionModel; +/** + * Tuple based selection model + */ +var TupleSelectionModel = /** @class */ (function () { + function TupleSelectionModel() { + this.objectIds = []; + } + return TupleSelectionModel; +}()); +exports.TupleSelectionModel = TupleSelectionModel; +/** + * Container class to populate all the selection models when parsing input + */ +var SelectionModelsContainer = /** @class */ (function () { + function SelectionModelsContainer() { + this.hierModelArr = []; + this.dimModelArr = []; + this.quantModelArr = []; + } + return SelectionModelsContainer; +}()); +exports.SelectionModelsContainer = SelectionModelsContainer; +var SelectTuplesInteractionModel = /** @class */ (function () { + function SelectTuplesInteractionModel(visualIdPresModel, tupleIds, selectOptions, tooltipContext) { + if (tupleIds === void 0) { tupleIds = []; } + this.visualIdPresModel = visualIdPresModel; + this.tupleIds = tupleIds; + this.selectOptions = selectOptions; + this.tooltipContext = tooltipContext; + } + return SelectTuplesInteractionModel; +}()); +exports.SelectTuplesInteractionModel = SelectTuplesInteractionModel; +var HoverTupleInteractionModel = /** @class */ (function () { + function HoverTupleInteractionModel(visualIdPresModel, tupleId, tooltipContext, allowHoverActions) { + this.visualIdPresModel = visualIdPresModel; + this.tupleId = tupleId; + this.tooltipContext = tooltipContext; + this.allowHoverActions = allowHoverActions; + } + return HoverTupleInteractionModel; +}()); +exports.HoverTupleInteractionModel = HoverTupleInteractionModel; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Point.js": +/*!***************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Point.js ***! + \***************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Point = /** @class */ (function () { + function Point(_x, _y) { + this._x = _x; + this._y = _y; + } + Object.defineProperty(Point.prototype, "x", { + get: function () { + return this._x; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Point.prototype, "y", { + get: function () { + return this._y; + }, + enumerable: true, + configurable: true + }); + return Point; +}()); +exports.Point = Point; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/GetDataService.js": +/*!*********************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/GetDataService.js ***! + \*********************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Defines which type of getData call to make. + */ +var GetDataType; +(function (GetDataType) { + GetDataType["Summary"] = "summary"; + GetDataType["Underlying"] = "underlying"; +})(GetDataType = exports.GetDataType || (exports.GetDataType = {})); + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/RegisterAllSharedServices.js": +/*!********************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/RegisterAllSharedServices.js ***! + \********************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var ServiceRegistry_1 = __webpack_require__(/*! ./ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js"); +var AccessibilityServiceImpl_1 = __webpack_require__(/*! ./impl/AccessibilityServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/AccessibilityServiceImpl.js"); +var AnimationServiceImpl_1 = __webpack_require__(/*! ./impl/AnimationServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/AnimationServiceImpl.js"); +var AnnotationServiceImpl_1 = __webpack_require__(/*! ./impl/AnnotationServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/AnnotationServiceImpl.js"); +var DataSourceServiceImpl_1 = __webpack_require__(/*! ./impl/DataSourceServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/DataSourceServiceImpl.js"); +var ExportServiceImpl_1 = __webpack_require__(/*! ./impl/ExportServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/ExportServiceImpl.js"); +var ExternalContextMenuServiceImpl_1 = __webpack_require__(/*! ./impl/ExternalContextMenuServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/ExternalContextMenuServiceImpl.js"); +var FilterServiceImpl_1 = __webpack_require__(/*! ./impl/FilterServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/FilterServiceImpl.js"); +var GetDataServiceImpl_1 = __webpack_require__(/*! ./impl/GetDataServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/GetDataServiceImpl.js"); +var NotificationServiceImpl_1 = __webpack_require__(/*! ./impl/NotificationServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/NotificationServiceImpl.js"); +var ParametersServiceImpl_1 = __webpack_require__(/*! ./impl/ParametersServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/ParametersServiceImpl.js"); +var SelectionServiceImpl_1 = __webpack_require__(/*! ./impl/SelectionServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/SelectionServiceImpl.js"); +var SizeServiceImpl_1 = __webpack_require__(/*! ./impl/SizeServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/SizeServiceImpl.js"); +var VisualModelServiceImpl_1 = __webpack_require__(/*! ./impl/VisualModelServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/VisualModelServiceImpl.js"); +var VizServiceImpl_1 = __webpack_require__(/*! ./impl/VizServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/VizServiceImpl.js"); +var ZoneServiceImpl_1 = __webpack_require__(/*! ./impl/ZoneServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/ZoneServiceImpl.js"); +function registerAllSharedServices(dispatcher, registryId, platformVersion) { + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new AnimationServiceImpl_1.AnimationServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new DataSourceServiceImpl_1.DataSourceServiceImpl(dispatcher, registryId, platformVersion)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new ExportServiceImpl_1.ExportServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new GetDataServiceImpl_1.GetDataServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new FilterServiceImpl_1.FilterServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new NotificationServiceImpl_1.NotificationServiceImpl(dispatcher)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new ParametersServiceImpl_1.ParametersServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new SelectionServiceImpl_1.SelectionServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new AnnotationServiceImpl_1.AnnotationServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new ZoneServiceImpl_1.ZoneServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new SizeServiceImpl_1.SizeServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new VisualModelServiceImpl_1.VisualModelServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new VizServiceImpl_1.VizServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new ExternalContextMenuServiceImpl_1.ExternalContextMenuServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new AccessibilityServiceImpl_1.AccessibilityServiceImpl(dispatcher, registryId)); +} +exports.registerAllSharedServices = registerAllSharedServices; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js": +/*!**********************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js ***! + \**********************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +window.__tableauApiServiceRegistry = window.__tableauApiServiceRegistry || {}; +var ServiceRegistryImpl = /** @class */ (function () { + function ServiceRegistryImpl() { + this._services = {}; + } + ServiceRegistryImpl.prototype.registerService = function (service) { + this._services[service.serviceName] = service; + }; + ServiceRegistryImpl.prototype.getService = function (serviceName) { + if (!this._services.hasOwnProperty(serviceName)) { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, "Service not registered: " + serviceName); + } + return this._services[serviceName]; + }; + return ServiceRegistryImpl; +}()); +/** + * Static class used for getting access to the single instance + * of the ApiServiceRegistry associated with the registryId. + * + * Extensions by design don't need to store/access multiple service registries. Their single instance of ServiceRegistry is + * stored/access with registryId = 0. + * + * Whereas Embedding needs to be aware of which ServiceRegistry to use when there are multiple vizzes embedded. + * An example of how window.__tableauApiServiceRegistry will look when there are two vizzes: { 0 : ServiceRegistry, 1 : ServiceRegistry} + * where registry ID of 0 & 1 refers to viz's internal identifier (which is generated by VizManager). + */ +var ApiServiceRegistry = /** @class */ (function () { + // Private to avoid anyone constructing this + function ApiServiceRegistry() { + } + /** + * Gets the singleton instance of the ServiceRegistry + */ + ApiServiceRegistry.get = function (registryId) { + if (!window.__tableauApiServiceRegistry || !window.__tableauApiServiceRegistry[registryId]) { + ApiServiceRegistry.setInstance(registryId, new ServiceRegistryImpl()); + } + if (!window.__tableauApiServiceRegistry[registryId]) { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, 'Service registry failed'); + } + return window.__tableauApiServiceRegistry[registryId]; + }; + /** + * Helper method that sets the service registry instance for the corresponding registryId. Can be used by unit tests + * + * @param {ServiceRegistry} serviceRegistry The new registry + */ + ApiServiceRegistry.setInstance = function (registryId, serviceRegistry) { + if (!window.__tableauApiServiceRegistry) { + window.__tableauApiServiceRegistry = {}; + } + window.__tableauApiServiceRegistry[registryId] = serviceRegistry; + }; + /** + * Only used by unit tests + */ + ApiServiceRegistry.clearRegistry = function () { + window.__tableauApiServiceRegistry = {}; + }; + return ApiServiceRegistry; +}()); +exports.ApiServiceRegistry = ApiServiceRegistry; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/AccessibilityServiceImpl.js": +/*!************************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/AccessibilityServiceImpl.js ***! + \************************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var AccessibilityModels_1 = __webpack_require__(/*! ../../Models/AccessibilityModels */ "../api-shared-js/lib/src/ApiShared/Models/AccessibilityModels.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var AccessibilityServiceImpl = /** @class */ (function (_super) { + __extends(AccessibilityServiceImpl, _super); + function AccessibilityServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(AccessibilityServiceImpl.prototype, "serviceName", { + get: function () { + return "accessibility" /* Accessibility */; + }, + enumerable: true, + configurable: true + }); + AccessibilityServiceImpl.prototype.getTooltipTextAsync = function (visualId, tupleId) { + var _a; + var tooltipTextRequest = new AccessibilityModels_1.TooltipTextRequestModel(visualId, tupleId); + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getTooltipTextAsync', + _a[api_internal_contract_js_1.ParameterId.TooltipTextRequest] = tooltipTextRequest, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetTooltipText, parameters).then(function (response) { + return response.result; + }); + }; + AccessibilityServiceImpl.prototype.leaveMarkNavigationAsync = function (visualId) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'leaveMarkNavigationAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a); + return this.execute(api_internal_contract_js_1.VerbId.RaiseLeaveMarkNavNotification, parameters).then(function (response) { + return; + }); + }; + return AccessibilityServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.AccessibilityServiceImpl = AccessibilityServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/AnimationServiceImpl.js": +/*!********************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/AnimationServiceImpl.js ***! + \********************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var ExternalToInternalEnumMappings_1 = __webpack_require__(/*! ../../EnumMappings/ExternalToInternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var AnimationServiceImpl = /** @class */ (function (_super) { + __extends(AnimationServiceImpl, _super); + function AnimationServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(AnimationServiceImpl.prototype, "serviceName", { + get: function () { + return "animation-service" /* Animation */; + }, + enumerable: true, + configurable: true + }); + AnimationServiceImpl.prototype.replayAsync = function (replaySpeed) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.ReplaySpeed] = 1.0, + _a); + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(replaySpeed, api_external_contract_js_1.ReplaySpeedType, 'ReplaySpeedType'); + parameters[api_internal_contract_js_1.ParameterId.ReplaySpeed] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.setReplaySpeedType.convert(replaySpeed); + return this.execute(api_internal_contract_js_1.VerbId.ReplayAnimation, parameters).then(function (response) { + return; + }); + }; + return AnimationServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.AnimationServiceImpl = AnimationServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/AnnotationServiceImpl.js": +/*!*********************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/AnnotationServiceImpl.js ***! + \*********************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var InternalToExternalEnumMappings_1 = __webpack_require__(/*! ../../EnumMappings/InternalToExternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js"); +var SelectionModels_1 = __webpack_require__(/*! ../../Models/SelectionModels */ "../api-shared-js/lib/src/ApiShared/Models/SelectionModels.js"); +var TableauError_1 = __webpack_require__(/*! ../../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var AnnotationServiceImpl = /** @class */ (function (_super) { + __extends(AnnotationServiceImpl, _super); + function AnnotationServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(AnnotationServiceImpl.prototype, "serviceName", { + get: function () { + return "annotation-service" /* Annotation */; + }, + enumerable: true, + configurable: true + }); + /** + * Method to annotate a mark on the given worksheet. + * + * @param visualId + * @param mark + * @param annotationText + */ + AnnotationServiceImpl.prototype.annotateMarkAsync = function (visualId, mark, annotationText) { + var _a; + var selectionModelContainer = this.parseMarkSelectionIds([mark]); + var dummyTargetPoint = { x: 0, y: 0 }; + var formattedText = "" + annotationText + ""; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'annotateMarkAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_js_1.ParameterId.AnnotateEnum] = api_internal_contract_js_1.AnnotateEnum.Mark, + _a[api_internal_contract_js_1.ParameterId.TargetPoint] = dummyTargetPoint, + _a[api_internal_contract_js_1.ParameterId.SelectionList] = [selectionModelContainer.selection], + _a[api_internal_contract_js_1.ParameterId.FormattedText] = formattedText, + _a); + return this.execute(api_internal_contract_js_1.VerbId.CreateAnnotation, parameters).then(function (response) { + // Expecting an empty model and hence the void response. + return; + }); + }; + /** + * Method to retrieve annotations for the given worksheet. + * + * @param visualId + * @returns {Promise>} + */ + AnnotationServiceImpl.prototype.getAnnotationsAsync = function (visualId) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getAnnotationsAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetAnnotations, parameters).then(function (response) { + var annotationsList = response.result; + return _this.annotationFilterMap(annotationsList); + }); + }; + /** + * Method to remove an annotation from a given worksheet. + * + * @param visualId + * @param annotation + */ + AnnotationServiceImpl.prototype.removeAnnotationAsync = function (visualId, annotation) { + var _a; + var selectionModelContainer = this.parseAnnotationSelectionIds([annotation]); + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'removeAnnotationAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_js_1.ParameterId.SelectionList] = [selectionModelContainer.selection], + _a); + return this.execute(api_internal_contract_js_1.VerbId.RemoveAnnotation, parameters).then(function (response) { + // Expecting an empty model and hence the void response. + return; + }); + }; + /** + * Method to prepare the pres models for selection by MarksInfo + * @param marks + */ + AnnotationServiceImpl.prototype.parseMarkSelectionIds = function (marks) { + var ids = []; + var selectionModelContainer = new SelectionModels_1.SelectionModelsContainer(); + marks.forEach(function (mark) { + var tupleId = mark.tupleId; + if (tupleId !== undefined && tupleId !== null && tupleId > 0) { + ids.push(tupleId.toString()); // collect the tuple ids + } + else { + throw new TableauError_1.TableauError(Contract.ErrorCodes.InternalError, 'invalid tupleId'); + } + }); + if (ids.length !== 0) { + // tuple ids based selection + var tupleSelectionModel = new SelectionModels_1.TupleSelectionModel(); + tupleSelectionModel.selectionType = 'tuples'; + tupleSelectionModel.objectIds = ids; + selectionModelContainer.selection = tupleSelectionModel; + } + return selectionModelContainer; + }; + /** + * Method to prepare the pres models for selection by MarkAnnotationInfo + * @param marks + */ + AnnotationServiceImpl.prototype.parseAnnotationSelectionIds = function (annotations) { + var ids = []; + var selectionModelContainer = new SelectionModels_1.SelectionModelsContainer(); + annotations.forEach(function (annotation) { + var annotationId = annotation.annotationId; + if (annotationId !== undefined && annotationId !== null && annotationId >= 0) { + ids.push(annotationId.toString()); // collect the annotation ids + } + else { + throw new TableauError_1.TableauError(Contract.ErrorCodes.InternalError, 'invalid annotationId'); + } + }); + if (ids.length !== 0) { + // annotation ids based selection + var tupleSelectionModel = new SelectionModels_1.TupleSelectionModel(); + tupleSelectionModel.selectionType = 'annotations'; + tupleSelectionModel.objectIds = ids; + selectionModelContainer.selection = tupleSelectionModel; + } + return selectionModelContainer; + }; + /** + * Method to map Annotation to MarkAnnotationInfo + * @param annotation + * @returns {Annotation} + */ + AnnotationServiceImpl.prototype.mapAnnotation = function (annotation) { + return { + annotationHTML: annotation.annotationText, + annotationId: annotation.annotationId, + annotationText: annotation.annotationPlainText, + annotationType: InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.annotationType.convert(annotation.annotateEnum), + tupleId: annotation.tupleId, + }; + }; + /** + * Filter the Annotations to Mark Annotations, and map them to MarkAnnotationInfo + * @param annotations + * @returns {Array} + */ + AnnotationServiceImpl.prototype.annotationFilterMap = function (annotations) { + var _this = this; + var annotationInfos = annotations.map(function (annotation) { return _this.mapAnnotation(annotation); }); + return annotationInfos; + }; + return AnnotationServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.AnnotationServiceImpl = AnnotationServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/ClientInfoServiceImpl.js": +/*!*********************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/ClientInfoServiceImpl.js ***! + \*********************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var ClientInfoServiceImpl = /** @class */ (function (_super) { + __extends(ClientInfoServiceImpl, _super); + function ClientInfoServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(ClientInfoServiceImpl.prototype, "serviceName", { + get: function () { + return "client-info-service" /* ClientInfo */; + }, + enumerable: true, + configurable: true + }); + ClientInfoServiceImpl.prototype.getClientInfoAsync = function () { + var _a; + var verb = api_internal_contract_js_1.VerbId.GetEmbeddingClientInfo; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getClientInfoAsync', + _a); + return this.execute(verb, parameters).then(function (response) { + var clientInfo = response.result; + return clientInfo; + }); + }; + return ClientInfoServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.ClientInfoServiceImpl = ClientInfoServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/DataSourceServiceImpl.js": +/*!*********************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/DataSourceServiceImpl.js ***! + \*********************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var InternalContract = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var DataSource_1 = __webpack_require__(/*! ../../DataSource */ "../api-shared-js/lib/src/ApiShared/DataSource.js"); +var Field_1 = __webpack_require__(/*! ../../Field */ "../api-shared-js/lib/src/ApiShared/Field.js"); +var DataSourceImpl_1 = __webpack_require__(/*! ../../Impl/DataSourceImpl */ "../api-shared-js/lib/src/ApiShared/Impl/DataSourceImpl.js"); +var FieldImpl_1 = __webpack_require__(/*! ../../Impl/FieldImpl */ "../api-shared-js/lib/src/ApiShared/Impl/FieldImpl.js"); +var TableauError_1 = __webpack_require__(/*! ../../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +exports.SENTINEL_LOGICAL_TABLE_INFO = { + id: InternalContract.ApiShowDataTableSentinel.SingleTableId, + caption: InternalContract.ApiShowDataTableSentinel.SingleTableCaption, +}; +// The minimum platform version when Object Model was supported +var platformVersionObjectModelSupport = { major: 1, minor: 20, fix: 1 }; +var DataSourceServiceImpl = /** @class */ (function (_super) { + __extends(DataSourceServiceImpl, _super); + // Since Object Model is supported since Tableau 2020.2, DataSourceServiceImpl can be initialized with the + // platform version when OM was supported. Once we drop support for Tableau versions <= 2020.1, all additional + // code in here for Object Model can be removed. + function DataSourceServiceImpl(dispatcher, registryId, _platformVersion) { + if (_platformVersion === void 0) { _platformVersion = platformVersionObjectModelSupport; } + var _this = _super.call(this, dispatcher, registryId) || this; + _this._platformVersion = _platformVersion; + return _this; + } + Object.defineProperty(DataSourceServiceImpl.prototype, "serviceName", { + get: function () { + return "data-source-service" /* DataSourceService */; + }, + enumerable: true, + configurable: true + }); + DataSourceServiceImpl.prototype.refreshAsync = function (dataSourceId) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'refreshAsync', + _a[api_internal_contract_js_1.ParameterId.DeltaTimeMs] = 0, + _a[api_internal_contract_js_1.ParameterId.ShouldRefreshDS] = true, + _a); + // On server: Not passing the datasource id will refresh all datasources. + if (dataSourceId) { + parameters[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId; + } + return this.execute(api_internal_contract_js_1.VerbId.RefreshDataSource, parameters).then(function (response) { + return; + }); + }; + DataSourceServiceImpl.prototype.getActiveTablesAsync = function (dataSourceId) { + var _a; + var joinParameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getActiveTablesAsync', + _a[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId, + _a); + // Get the description of the tables used by this connection + return this.execute(api_internal_contract_js_1.VerbId.GetActiveTables, joinParameters).then(function (joinResponse) { + var tableInfos = joinResponse.result; + // getActiveTables is unsupported for cubes and GA. We do not have a connection type property + // available from the platform (intentionally, to reduce code churn as new connections are added). + // Instead,just check if any tables are returned. This array will be empty for any non-table based datasource. + if (tableInfos.tables.length === 0) { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.UnsupportedMethodForDataSourceType, "getActiveTables is not supported for: " + dataSourceId); + } + return tableInfos.tables; + }); + }; + DataSourceServiceImpl.prototype.getDataSourcesAsync = function (visualId) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getDataSourcesAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetDataSources, parameters).then(function (response) { + var dataSchema = response.result; + return dataSchema; + }); + }; + DataSourceServiceImpl.prototype.getAllDataSourcesAsync = function () { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getAllDataSourcesAsync', + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetAllDataSources, parameters).then(function (response) { + var dataSchema = response.result; + return dataSchema; + }); + }; + DataSourceServiceImpl.prototype.getConnectionSummariesAsync = function (dataSourceId) { + var _a; + var params = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getConnectionSummariesAsync', + _a[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId, + _a); + // Get the description of the tables used by this connection + return this.execute(api_internal_contract_js_1.VerbId.GetConnectionDescriptionSummaries, params).then(function (response) { + var descriptionSummaries = response.result; + return descriptionSummaries; + }); + }; + DataSourceServiceImpl.prototype.getFieldAsync = function (globalfieldName) { + var _a; + var _this = this; + var verb = api_internal_contract_js_1.VerbId.GetFieldAndDataSource; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getFieldAsync', + _a[api_internal_contract_js_1.ParameterId.FieldId] = globalfieldName, + _a); + return this.execute(verb, parameters).then(function (response) { + var dataSource = response.result[api_internal_contract_js_1.ParameterId.DataSource]; + var field = response.result[api_internal_contract_js_1.ParameterId.Field]; + return _this.convertField(field, _this.convertDataSource(dataSource)); + }); + }; + DataSourceServiceImpl.prototype.getLogicalTablesAsync = function (dataSourceId) { + var _a; + if (!this.isObjectModelSupportedByPlatform()) { + /** + * This sentinel ID can be passed to datasource.getLogicalTableData. + * Once the desktop is upgraded to a version that supports object model, + * the sentinel ID will automatically fetch the upgraded table. + * */ + return new Promise(function (resolve) { return resolve([exports.SENTINEL_LOGICAL_TABLE_INFO]); }); + } + var params = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getLogicalTablesAsync', + _a[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetLogicalTables, params).then(function (response) { + return response.result; + }); + }; + DataSourceServiceImpl.prototype.getUnderlyingTablesAsync = function (visualId) { + var _a; + if (!this.isObjectModelSupportedByPlatform()) { + /** + * This sentinel ID can be passed to worksheet.getUnderlyingTableData. + * Once the desktop is upgraded to a version that supports object model, + * the sentinel ID will automatically fetch the upgraded table. + * */ + return new Promise(function (resolve) { return resolve([exports.SENTINEL_LOGICAL_TABLE_INFO]); }); + } + var params = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getUnderlyingTablesAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetUnderlyingTables, params).then(function (response) { + return response.result; + }); + }; + DataSourceServiceImpl.prototype.convertField = function (field, dataSource) { + return new Field_1.Field(new FieldImpl_1.FieldImpl(field, dataSource)); + }; + DataSourceServiceImpl.prototype.convertDataSource = function (dataSource) { + return new DataSource_1.DataSource(new DataSourceImpl_1.DataSourceImpl(dataSource, this._registryId)); + }; + DataSourceServiceImpl.prototype.isObjectModelSupportedByPlatform = function () { + var platformVersionNoObjectModelSupport = { major: 1, minor: 13, fix: 0 }; + return InternalContract.VersionLessThan(platformVersionNoObjectModelSupport, this._platformVersion); + }; + return DataSourceServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.DataSourceServiceImpl = DataSourceServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/ExportServiceImpl.js": +/*!*****************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/ExportServiceImpl.js ***! + \*****************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var ExternalToInternalEnumMappings_1 = __webpack_require__(/*! ../../EnumMappings/ExternalToInternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.js"); +var ExportHelpers_1 = __webpack_require__(/*! ../../Utils/ExportHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ExportHelpers.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var TableauError_1 = __webpack_require__(/*! ../../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var ExportServiceImpl = /** @class */ (function (_super) { + __extends(ExportServiceImpl, _super); + function ExportServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(ExportServiceImpl.prototype, "serviceName", { + get: function () { + return "export-service" /* Export */; + }, + enumerable: true, + configurable: true + }); + ExportServiceImpl.prototype.getExportCrosstabSheetMapAsync = function (currentSheetType) { + var _a; + var verb = api_internal_contract_js_1.VerbId.GetExportCrosstabSheetMap; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getExportCrosstabSheetMapAsync', + _a[api_internal_contract_js_1.ParameterId.CurrentSheetType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.sheetType.convert(currentSheetType), + _a); + return this.execute(verb, parameters).then(function (response) { + var result = response.result; + return result; + }); + }; + ExportServiceImpl.prototype.exportCrosstabAsync = function (sheetName, format, exportableWorksheetNames, currentSheetType) { + return __awaiter(this, void 0, void 0, function () { + var sheetNameToIdMap, parameters, verb; + var _a; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + ErrorHelpers_1.ErrorHelpers.verifySheetName(exportableWorksheetNames, sheetName); + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(format, api_external_contract_js_1.CrosstabFileFormat, 'CrosstabFileFormat'); + return [4 /*yield*/, this.getExportCrosstabSheetMapAsync(currentSheetType)]; + case 1: + sheetNameToIdMap = _b.sent(); + if (!sheetNameToIdMap[sheetName]) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'missing sheet doc id from sheetMap'); + } + parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'exportCrosstabAsync', + _a[api_internal_contract_js_1.ParameterId.SheetIdentifier] = sheetNameToIdMap[sheetName], + _a[api_internal_contract_js_1.ParameterId.SendNotifications] = true, + _a); + switch (format) { + case api_external_contract_js_1.CrosstabFileFormat.CSV: + verb = api_internal_contract_js_1.VerbId.ExportCrosstabCsvDownload; + // CSV only parameter: see browser-clients/export-crosstab-options-dialog repo + parameters[api_internal_contract_js_1.ParameterId.UseTabDelimiters] = true; + break; + case api_external_contract_js_1.CrosstabFileFormat.Excel: + verb = api_internal_contract_js_1.VerbId.ExportCrosstabExcelDownload; + break; + default: + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'unsupported Crosstab file format.'); + } + return [2 /*return*/, this.execute(verb, parameters) + .then(function (response) { + var result = response.result; + return result; + }) + .catch(function () { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.CrosstabCreationError, 'An unexpected error occurred while generating the document.'); + })]; + } + }); + }); + }; + ExportServiceImpl.prototype.exportDataAsync = function (visualId, options) { + var _a; + var _b; + ErrorHelpers_1.ErrorHelpers.verifyExportDataOptions(options); + // Remove any duplicates from the input array + var columnsAsSet = new Set(options.columnsToIncludeById); + var columnsToIncludeById = Array.from(columnsAsSet); + var verb = api_internal_contract_js_1.VerbId.ExportDataDownload; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'exportDataAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = (_b = options.ignoreAliases, (_b !== null && _b !== void 0 ? _b : false)), + _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = columnsToIncludeById, + _a); + return this.execute(verb, parameters) + .then(function () { }) + .catch(function () { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.DataCreationError, 'An unexpected error occurred while generating the document.'); + }); + }; + ExportServiceImpl.prototype.exportPowerPointAsync = function (sheetNames, exportScenarios) { + var _a; + ErrorHelpers_1.ErrorHelpers.verifySheetNamesForPDFAndPPT(sheetNames, exportScenarios); + // Note: the ExportOriginUrl param is listed as optional for the pres layer command we are invoking; however, + // recent changes were made that enforced the use of the empty string when invoking this command with no ExportOriginUrl. + // see browser-clients/export-powerpoint-options-dialog repo. + var verb = api_internal_contract_js_1.VerbId.ExportPowerpointDownload; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'exportPowerPointAsync', + _a[api_internal_contract_js_1.ParameterId.ExportOriginUrl] = '', + _a[api_internal_contract_js_1.ParameterId.SelectedSheetNames] = sheetNames, + _a); + return this.execute(verb, parameters) + .then(function (response) { + var result = response.result; + return result; + }) + .catch(function () { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.PowerPointCreationError, 'An error occured while attempting to generate the PowerPoint file.'); + }); + }; + ExportServiceImpl.prototype.exportPDFAsync = function (sheetNames, externalExportPdfOptions, exportScenarios) { + return __awaiter(this, void 0, void 0, function () { + var internalExportPdfOptions, verb, parameters; + var _a; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + ErrorHelpers_1.ErrorHelpers.verifyExportPDFOptions(externalExportPdfOptions); + ErrorHelpers_1.ErrorHelpers.verifySheetNamesForPDFAndPPT(sheetNames, exportScenarios); + return [4 /*yield*/, this.getExportPDFOptionsAsync()]; + case 1: + internalExportPdfOptions = _b.sent(); + ExportHelpers_1.ExportHelpers.updateInternalExportPDFOptions(internalExportPdfOptions, externalExportPdfOptions, sheetNames); + verb = api_internal_contract_js_1.VerbId.ExportPdfDownload; + parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'exportPDFAsync', + _a[api_internal_contract_js_1.ParameterId.ExportPdfOptions] = internalExportPdfOptions, + _a); + return [2 /*return*/, this.execute(verb, parameters) + .then(function (response) { + var result = response.result; + return result; + }) + .catch(function () { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.PDFCreationError, 'Unable to create PDF because something went wrong. Try again.'); + })]; + } + }); + }); + }; + ExportServiceImpl.prototype.getExportPDFOptionsAsync = function () { + var _a; + var verb = api_internal_contract_js_1.VerbId.GetExportPdfOptions; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getExportPdfOptionsAsync', + _a); + return this.execute(verb, parameters).then(function (response) { + var result = response.result; + return result; + }); + }; + return ExportServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.ExportServiceImpl = ExportServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/ExternalContextMenuServiceImpl.js": +/*!******************************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/ExternalContextMenuServiceImpl.js ***! + \******************************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var ExternalContextMenuServiceImpl = /** @class */ (function (_super) { + __extends(ExternalContextMenuServiceImpl, _super); + function ExternalContextMenuServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(ExternalContextMenuServiceImpl.prototype, "serviceName", { + get: function () { + return "external-context-menu-service" /* ExternalContextMenu */; + }, + enumerable: true, + configurable: true + }); + ExternalContextMenuServiceImpl.prototype.appendContextMenuAsync = function (sheetName, targetMenu, config) { + var _a; + var verb = api_internal_contract_js_1.VerbId.AppendExternalMenuItem; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'appendContextMenuAsync', + _a[api_internal_contract_js_1.ParameterId.WorksheetName] = sheetName, + _a[api_internal_contract_js_1.ParameterId.ExternalMenuItemDisplayName] = config.displayName, + _a); + return this.execute(verb, parameters).then(function (response) { + var newMenuItemId = response.result; + return newMenuItemId; + }); + }; + ExternalContextMenuServiceImpl.prototype.removeContextMenuAsync = function (sheetName, targetMenu, menuItemId) { + var _a; + var verb = api_internal_contract_js_1.VerbId.RemoveExternalMenuItem; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'removeContextMenuAsync', + _a[api_internal_contract_js_1.ParameterId.WorksheetName] = sheetName, + _a[api_internal_contract_js_1.ParameterId.ExternalMenuItemId] = menuItemId, + _a); + return this.execute(verb, parameters).then(function (response) { + return; + }); + }; + ExternalContextMenuServiceImpl.prototype.executeContextMenuAsync = function (sheetName, targetMenu, menuItemId) { + var _a; + var verb = api_internal_contract_js_1.VerbId.ExecuteExternalMenuItem; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'executeContextMenuAsync', + _a[api_internal_contract_js_1.ParameterId.WorksheetName] = sheetName, + _a[api_internal_contract_js_1.ParameterId.ExternalMenuItemId] = menuItemId, + _a); + return this.execute(verb, parameters).then(function (response) { + return; + }); + }; + ExternalContextMenuServiceImpl.prototype.renameContextMenuAsync = function (sheetName, targetMenu, menuHeader, menuDescription) { + var _a; + var verb = api_internal_contract_js_1.VerbId.RenameExternalMenu; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'renameContextMenuAsync', + _a[api_internal_contract_js_1.ParameterId.WorksheetName] = sheetName, + _a[api_internal_contract_js_1.ParameterId.ExternalMenuHeader] = menuHeader, + _a[api_internal_contract_js_1.ParameterId.ExternalMenuDescription] = menuDescription, + _a); + return this.execute(verb, parameters).then(function (response) { + return; + }); + }; + return ExternalContextMenuServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.ExternalContextMenuServiceImpl = ExternalContextMenuServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/FilterServiceImpl.js": +/*!*****************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/FilterServiceImpl.js ***! + \*****************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var InternalContract = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var ApiShared_1 = __webpack_require__(/*! ../../../ApiShared */ "../api-shared-js/lib/src/ApiShared.js"); +var ExternalToInternalEnumMappings_1 = __webpack_require__(/*! ../../EnumMappings/ExternalToInternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.js"); +var InternalToExternalEnumMappings_1 = __webpack_require__(/*! ../../EnumMappings/InternalToExternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js"); +var FilterModels_1 = __webpack_require__(/*! ../../Models/FilterModels */ "../api-shared-js/lib/src/ApiShared/Models/FilterModels.js"); +var DataValueFactory_1 = __webpack_require__(/*! ../../Utils/DataValueFactory */ "../api-shared-js/lib/src/ApiShared/Utils/DataValueFactory.js"); +var Param_1 = __webpack_require__(/*! ../../Utils/Param */ "../api-shared-js/lib/src/ApiShared/Utils/Param.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var FilterServiceImpl = /** @class */ (function (_super) { + __extends(FilterServiceImpl, _super); + function FilterServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(FilterServiceImpl.prototype, "serviceName", { + get: function () { + return "filter-service" /* Filter */; + }, + enumerable: true, + configurable: true + }); + FilterServiceImpl.prototype.applyFilterAsync = function (visualId, fieldName, values, updateType, filterOptions) { + var _a; + var verb = api_internal_contract_js_1.VerbId.ApplyCategoricalFilter; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'applyFilterAsync', + _a); + parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId; + parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName; + if (!Array.isArray(values)) { + throw new ApiShared_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'values parameter for applyFilterAsync must be an array'); + } + parameters[api_internal_contract_js_1.ParameterId.FilterValues] = values; + parameters[api_internal_contract_js_1.ParameterId.FilterUpdateType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterUpdateType.convert(updateType); + parameters[api_internal_contract_js_1.ParameterId.IsExcludeMode] = + filterOptions === undefined || filterOptions.isExcludeMode === undefined ? false : filterOptions.isExcludeMode; + return this.execute(verb, parameters).then(function (response) { + return fieldName; + }); + }; + FilterServiceImpl.prototype.applyRangeFilterAsync = function (visualId, fieldName, filterOptions) { + var _a; + var _this = this; + var verb = api_internal_contract_js_1.VerbId.ApplyRangeFilter; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'applyRangeFilterAsync', + _a); + if (filterOptions.min !== undefined && filterOptions.min !== null) { + var min = void 0; + if (filterOptions.min instanceof Date) { + min = Param_1.Param.serializeDateForPlatform(filterOptions.min); + } + else { + min = filterOptions.min; + } + parameters[api_internal_contract_js_1.ParameterId.FilterRangeMin] = min; + } + if (filterOptions.max !== undefined && filterOptions.max !== null) { + var max = void 0; + if (filterOptions.max instanceof Date) { + max = Param_1.Param.serializeDateForPlatform(filterOptions.max); + } + else { + max = filterOptions.max; + } + parameters[api_internal_contract_js_1.ParameterId.FilterRangeMax] = max; + } + // The null option is used with min+max for 'include-range' or 'include-range-or-null' + if (filterOptions.nullOption) { + parameters[api_internal_contract_js_1.ParameterId.FilterRangeNullOption] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.nullOptions.convert(filterOptions.nullOption); + } + parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName; + parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId; + return this.execute(verb, parameters).then(function (response) { + _this.apiFilterHandlerCheckForCommandError(response.result); + return fieldName; + }); + }; + FilterServiceImpl.prototype.applyHierarchicalFilterAsync = function (visualId, fieldName, values, updateType, filterOptions) { + var _a; + var verb = api_internal_contract_js_1.VerbId.HierarchicalFilter; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'applyHierarchicalFilterAsync', + _a); + parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId; + parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName; + var hierarchicalLevels = values.levels; + if (Array.isArray(hierarchicalLevels) && hierarchicalLevels.length > 0) { + parameters[api_internal_contract_js_1.ParameterId.FilterLevels] = hierarchicalLevels; + } + else if (values.length > 0) { + parameters[api_internal_contract_js_1.ParameterId.FilterValues] = values; + } + else { + // the server command expects empty list for clearing the filter + // it also expects eithers FilterLevels or FilterValues to be set + parameters[api_internal_contract_js_1.ParameterId.FilterLevels] = []; + } + parameters[api_internal_contract_js_1.ParameterId.FilterUpdateType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterUpdateType.convert(updateType); + parameters[api_internal_contract_js_1.ParameterId.IsExcludeMode] = filterOptions && !!filterOptions.isExcludeMode; + return this.execute(verb, parameters).then(function (response) { + return fieldName; + }); + }; + FilterServiceImpl.prototype.clearFilterAsync = function (visualId, fieldName) { + var _a; + var verb = api_internal_contract_js_1.VerbId.ClearFilter; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'clearFilterAsync', + _a); + parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId; + parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName; + return this.execute(verb, parameters).then(function (resposne) { + return fieldName; + }); + }; + FilterServiceImpl.prototype.applyRelativeDateFilterAsync = function (visualId, fieldName, options) { + var _a; + var verb = api_internal_contract_js_1.VerbId.ApplyRelativeDateFilter; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'applyRelativeDateFilterAsync', + _a); + parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId; + parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName; + parameters[api_internal_contract_js_1.ParameterId.PeriodType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.periodType.convert(options.periodType); + parameters[api_internal_contract_js_1.ParameterId.DateRangeType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.dateRangeType.convert(options.rangeType); + if (options.rangeType === api_external_contract_js_1.DateRangeType.LastN || options.rangeType === api_external_contract_js_1.DateRangeType.NextN) { + if (options.rangeN === undefined || options.rangeN === null) { + throw new ApiShared_1.TableauError(api_external_contract_js_1.EmbeddingErrorCodes.MissingRangeNForRelativeDateFilters, 'Missing rangeN field for a relative date filter of LASTN or NEXTN.'); + } + parameters[api_internal_contract_js_1.ParameterId.RangeN] = options.rangeN; + } + if (options.anchorDate !== undefined && options.anchorDate !== null) { + parameters[api_internal_contract_js_1.ParameterId.AnchorDate] = this.convertAnchorDate(options.anchorDate); + } + return this.execute(verb, parameters).then(function (response) { + return response.result; + }); + }; + FilterServiceImpl.prototype.getFiltersAsync = function (visualId) { + var _a; + var _this = this; + var verb = api_internal_contract_js_1.VerbId.GetFilters; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getFiltersAsync', + _a); + parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId; + return this.execute(verb, parameters).then(function (response) { + var filters = response.result; + return _this.convertDomainFilters(filters); + }); + }; + FilterServiceImpl.prototype.getCategoricalDomainAsync = function (worksheetName, fieldId, domainType) { + var _a; + var _this = this; + var verb = api_internal_contract_js_1.VerbId.GetCategoricalDomain; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getCategoricalDomainAsync', + _a); + parameters[api_internal_contract_js_1.ParameterId.VisualId] = { + worksheet: worksheetName, + }; + parameters[api_internal_contract_js_1.ParameterId.FieldId] = fieldId; + parameters[api_internal_contract_js_1.ParameterId.DomainType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterDomainType.convert(domainType); + return this.execute(verb, parameters).then(function (response) { + var domain = response.result; + return _this.convertCategoricalDomain(domain, domainType); + }); + }; + FilterServiceImpl.prototype.getRangeDomainAsync = function (worksheetName, fieldId, domainType) { + var _a; + var _this = this; + var verb = api_internal_contract_js_1.VerbId.GetRangeDomain; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getRangeDomainAsync', + _a); + parameters[api_internal_contract_js_1.ParameterId.VisualId] = { + worksheet: worksheetName, + }; + parameters[api_internal_contract_js_1.ParameterId.FieldId] = fieldId; + parameters[api_internal_contract_js_1.ParameterId.DomainType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterDomainType.convert(domainType); + return this.execute(verb, parameters).then(function (response) { + var domain = response.result; + return _this.convertRangeDomain(domain, domainType); + }); + }; + FilterServiceImpl.prototype.getDashboardFiltersAsync = function () { + var _a; + var _this = this; + var verb = api_internal_contract_js_1.VerbId.GetDashboardFilters; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getDashboardFiltersAsync', + _a); + return this.execute(verb, parameters).then(function (response) { + var filters = response.result; + return _this.convertDomainFilters(filters); + }); + }; + FilterServiceImpl.prototype.applyDashboardFilterAsync = function (fieldName, values, updateType, filterOptions) { + var _a; + var verb = api_internal_contract_js_1.VerbId.DashboardCategoricalFilter; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'applyDashboardFilterAsync', + _a); + parameters[api_internal_contract_js_1.ParameterId.FieldName] = fieldName; + parameters[api_internal_contract_js_1.ParameterId.FilterValues] = values; + parameters[api_internal_contract_js_1.ParameterId.FilterUpdateType] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.filterUpdateType.convert(updateType); + parameters[api_internal_contract_js_1.ParameterId.IsExcludeMode] = filterOptions && !!filterOptions.isExcludeMode; + return this.execute(verb, parameters).then(function (response) { + return response.result; + }); + }; + FilterServiceImpl.prototype.getAppliedWorksheetsAsync = function (worksheetName, fieldId) { + var _a; + return __awaiter(this, void 0, void 0, function () { + var sharedFilterModel, worksheetNames; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: return [4 /*yield*/, this.executeGetAppliedWorksheets(worksheetName, fieldId, 'getAppliedWorksheetsAsync')]; + case 1: + sharedFilterModel = _b.sent(); + worksheetNames = []; + (_a = sharedFilterModel.worksheets) === null || _a === void 0 ? void 0 : _a.map(function (worksheetInfo) { + if (worksheetInfo.isSelected) { + worksheetNames.push(worksheetInfo.worksheetName); + } + }); + return [2 /*return*/, worksheetNames]; + } + }); + }); + }; + FilterServiceImpl.prototype.setAppliedWorksheetsAsync = function (worksheetName, fieldName, fieldId, applyToWorksheets) { + return __awaiter(this, void 0, void 0, function () { + var sharedFilterModel, allowedWorksheets, activeWorksheet, verb, parameters; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, this.executeGetAppliedWorksheets(worksheetName, fieldId, 'getAppliedWorksheetsAsyncInternal')]; + case 1: + sharedFilterModel = _a.sent(); + if (!sharedFilterModel || !sharedFilterModel.worksheets) { + throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'This filter does not apply to multiple worksheets'); + } + allowedWorksheets = []; + activeWorksheet = ''; + sharedFilterModel.worksheets.forEach(function (worksheet) { + // Get active worksheet + if (worksheet.isActive) { + activeWorksheet = worksheet.worksheetName; + } + // Populate allowed worksheets + if (worksheet.isSelected || worksheet.isEnabled) { + allowedWorksheets.push(worksheet.worksheetName); + } + }); + if (activeWorksheet === '') { + throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'No active worksheet'); + } + if (!applyToWorksheets.includes(activeWorksheet)) { + throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, activeWorksheet + " must be included in the applied worksheets"); + } + applyToWorksheets.forEach(function (sheet) { + // check if it's present within compatible sheets + if (!allowedWorksheets.includes(sheet)) { + throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, "The field " + fieldName + " isn't applicable to the worksheet " + sheet); + } + }); + verb = api_internal_contract_js_1.VerbId.ChangeSharedFilter; + parameters = {}; + parameters[api_internal_contract_js_1.ParameterId.FunctionName] = 'setAppliedWorksheetsAsync'; + parameters[api_internal_contract_js_1.ParameterId.VisualId] = { + worksheet: worksheetName, + }; + parameters[api_internal_contract_js_1.ParameterId.FieldId] = fieldId; + parameters[api_internal_contract_js_1.ParameterId.SharedFilterSheets] = applyToWorksheets; + return [2 /*return*/, this.execute(verb, parameters).then(function (response) { + return applyToWorksheets; + })]; + } + }); + }); + }; + // Helper Methods + FilterServiceImpl.prototype.executeGetAppliedWorksheets = function (worksheetName, fieldId, telemetryFunctionName) { + var verb = api_internal_contract_js_1.VerbId.GetSharedFilter; + var parameters = {}; + parameters[api_internal_contract_js_1.ParameterId.FunctionName] = telemetryFunctionName; + parameters[api_internal_contract_js_1.ParameterId.VisualId] = { + worksheet: worksheetName, + }; + parameters[api_internal_contract_js_1.ParameterId.FieldId] = fieldId; + return this.execute(verb, parameters).then(function (response) { + var sharedFilterModel = response.result; + return sharedFilterModel; + }); + }; + FilterServiceImpl.prototype.convertDomainFilters = function (domainFilters) { + var _this = this; + var filters = []; + domainFilters.forEach(function (domainFilter) { + switch (domainFilter.filterType) { + case api_internal_contract_js_1.FilterType.Categorical: { + var filter = domainFilter; + if (filter) { + filters.push(_this.convertCategoricalFilter(filter)); + } + else { + throw new Error('Invalid Categorical Filter'); + } + break; + } + case api_internal_contract_js_1.FilterType.Hierarchical: { + var filter = domainFilter; + if (filter) { + filters.push(_this.convertHierarchicalFilter(filter)); + } + else { + throw new Error('Invalid Hierarchical Filter'); + } + break; + } + case api_internal_contract_js_1.FilterType.Range: { + var filter = domainFilter; + if (filter) { + filters.push(_this.convertRangeFilter(filter)); + } + else { + throw new Error('Invalid Range Filter'); + } + break; + } + case api_internal_contract_js_1.FilterType.RelativeDate: { + var filter = domainFilter; + if (filter) { + filters.push(_this.convertRelativeDateFilter(filter)); + } + else { + throw new Error('Invalid Relative Date Filter'); + } + break; + } + default: { + break; + } + } + }); + return filters; + }; + FilterServiceImpl.prototype.convertCategoricalFilter = function (domainFilter) { + var appliedValues = domainFilter.values.map(function (dv) { + return DataValueFactory_1.DataValueFactory.MakeFilterDataValue(dv); + }); + return new FilterModels_1.CategoricalFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, api_internal_contract_js_1.FilterType.Categorical, this._registryId, appliedValues, domainFilter.isExclude, domainFilter.isAllSelected); + }; + FilterServiceImpl.prototype.convertHierarchicalFilter = function (domainFilter) { + var appliedValues = domainFilter.values.map(function (hierarchicalDataValue) { + return new FilterModels_1.HierarchicalDataValue(DataValueFactory_1.DataValueFactory.MakeFilterDataValue(hierarchicalDataValue.value), hierarchicalDataValue.hierarchicalPath, hierarchicalDataValue.level); + }); + var levelDetails = domainFilter.levelInfo.map(function (aLevel) { + return new FilterModels_1.HierarchicalLevelDetail(aLevel.name, InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.hierarchicalLevelSelectionState.convert(aLevel.levelSelectionState)); + }); + return new FilterModels_1.HierarchicalFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, api_internal_contract_js_1.FilterType.Hierarchical, this._registryId, domainFilter.dimensionName, domainFilter.hierarchyCaption, domainFilter.levels, levelDetails, appliedValues, domainFilter.isAllSelected); + }; + FilterServiceImpl.prototype.convertRangeFilter = function (domainFilter) { + var minValue = DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domainFilter.min); + var maxValue = DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domainFilter.max); + return new FilterModels_1.RangeFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, api_internal_contract_js_1.FilterType.Range, this._registryId, minValue, maxValue, domainFilter.includeNullValues); + }; + FilterServiceImpl.prototype.convertRelativeDateFilter = function (domainFilter) { + var anchorDateValue = DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domainFilter.anchorDate); + return new FilterModels_1.RelativeDateFilter(domainFilter.visualId.worksheet, domainFilter.fieldCaption, domainFilter.fieldName, api_external_contract_js_1.FilterType.RelativeDate, this._registryId, anchorDateValue, InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dateStepPeriod.convert(domainFilter.periodType), InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dateRangeType.convert(domainFilter.rangeType), domainFilter.rangeN); + }; + FilterServiceImpl.prototype.convertCategoricalDomain = function (domain, domainType) { + var values = domain.values.map(function (domainDv) { + return DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domainDv); + }); + return new FilterModels_1.CategoricalDomain(values, domainType); + }; + FilterServiceImpl.prototype.convertRangeDomain = function (domain, domainType) { + var min = DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domain.min); + var max = DataValueFactory_1.DataValueFactory.MakeFilterDataValue(domain.max); + return new FilterModels_1.RangeDomain(min, max, domainType); + }; + FilterServiceImpl.prototype.convertAnchorDate = function (anchorDate) { + // Converts a Date object into a string format that the server expects for date/time values. + // If anchorDate doesn't represent a valid Date object, any of these would be NaN. + var year = anchorDate.getUTCFullYear(); + var month = anchorDate.getUTCMonth() + 1; + var day = anchorDate.getUTCDate(); + var hh = anchorDate.getUTCHours(); + var mm = anchorDate.getUTCMinutes(); + var sec = anchorDate.getUTCSeconds(); + if (isNaN(year) || isNaN(month) || isNaN(day) || isNaN(hh) || isNaN(mm) || isNaN(sec)) { + throw new ApiShared_1.TableauError(api_external_contract_js_1.EmbeddingErrorCodes.InvalidDateParameter, 'Invalid date parameter: anchorDate'); + } + var result = year + "-" + month + "-" + day + " " + hh + ":" + mm + ":" + sec; + return result; + }; + FilterServiceImpl.prototype.apiFilterHandlerCheckForCommandError = function (serverPm) { + if (!serverPm[InternalContract.ParameterId.ParameterError]) { + return; + } + if (serverPm[InternalContract.ParameterId.InvalidFieldCaption]) { + throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidFilterFieldName, serverPm[InternalContract.ParameterId.InvalidFieldCaption]); + } + if (serverPm[InternalContract.ParameterId.InvalidValues]) { + throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidFilterFieldValue, serverPm[InternalContract.ParameterId.InvalidValues]); + } + if (serverPm[InternalContract.ParameterId.InvalidAggFieldName]) { + throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidAggregationFieldName, serverPm[InternalContract.ParameterId.InvalidAggFieldName]); + } + throw new ApiShared_1.TableauError(api_external_contract_js_1.SharedErrorCodes.ServerError, 'Server Error'); + }; + return FilterServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.FilterServiceImpl = FilterServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/GetDataServiceImpl.js": +/*!******************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/GetDataServiceImpl.js ***! + \******************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var uuid_1 = __webpack_require__(/*! uuid */ "../api-shared-js/node_modules/uuid/dist/esm-browser/index.js"); +var ApiShared_1 = __webpack_require__(/*! ../../../ApiShared */ "../api-shared-js/lib/src/ApiShared.js"); +var ExternalToInternalEnumMappings_1 = __webpack_require__(/*! ../../EnumMappings/ExternalToInternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.js"); +var GetDataModels_1 = __webpack_require__(/*! ../../Models/GetDataModels */ "../api-shared-js/lib/src/ApiShared/Models/GetDataModels.js"); +var GetDataTableReaderModels_1 = __webpack_require__(/*! ../../Models/GetDataTableReaderModels */ "../api-shared-js/lib/src/ApiShared/Models/GetDataTableReaderModels.js"); +var DataValueFactory_1 = __webpack_require__(/*! ../../Utils/DataValueFactory */ "../api-shared-js/lib/src/ApiShared/Utils/DataValueFactory.js"); +var GetDataService_1 = __webpack_require__(/*! ../GetDataService */ "../api-shared-js/lib/src/ApiShared/Services/GetDataService.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var GetDataServiceImpl = /** @class */ (function (_super) { + __extends(GetDataServiceImpl, _super); + function GetDataServiceImpl() { + var _this = _super !== null && _super.apply(this, arguments) || this; + // The extension/embedding instance uses the same cache for all DataTableReaders. + _this.viewDataTableCacheId = uuid_1.v4(); + return _this; + } + Object.defineProperty(GetDataServiceImpl.prototype, "serviceName", { + get: function () { + return "get-data-service" /* GetData */; + }, + enumerable: true, + configurable: true + }); + GetDataServiceImpl.prototype.getMaxRowLimit = function () { + return 10000; + }; + GetDataServiceImpl.prototype.getViewDataTableCacheId = function () { + return this.viewDataTableCacheId; + }; + GetDataServiceImpl.prototype.getLimitedMaxRows = function (requestedRows, rowCountLimit) { + return requestedRows > 0 && requestedRows < rowCountLimit ? requestedRows : rowCountLimit; + }; + GetDataServiceImpl.prototype.getUnderlyingDataAsync = function (visualId, getType, ignoreAliases, ignoreSelection, includeAllColumns, columnsToIncludeById, maxRows, includeDataValuesOption) { + var _a; + var _this = this; + // Create all of our parameters + var summaryData = getType === GetDataService_1.GetDataType.Summary; + var functionName = summaryData ? 'getSummaryDataAsync' : 'getUnderlyingDataAsync'; + var verb = summaryData ? api_internal_contract_js_1.VerbId.GetDataSummaryData : api_internal_contract_js_1.VerbId.GetUnderlyingData; + var requestMaxRows = verb === api_internal_contract_js_1.VerbId.GetUnderlyingData ? this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1) : maxRows; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = functionName, + _a); + parameters[api_internal_contract_js_1.ParameterId.VisualId] = visualId; + parameters[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases; + parameters[api_internal_contract_js_1.ParameterId.IgnoreSelection] = ignoreSelection; + parameters[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = includeAllColumns; + parameters[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById); + parameters[api_internal_contract_js_1.ParameterId.MaxRows] = requestMaxRows; + parameters[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption); + return this.execute(verb, parameters).then(function (response) { + var responseData = response.result; + return _this.processResultsTable(responseData.data, responseData.isSummary); + }); + }; + GetDataServiceImpl.prototype.getSummaryDataReaderAsync = function (visualId, pageRowCount, ignoreAliases, ignoreSelection, includeAllColumns, columnsToIncludeById, includeDataValuesOption) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getSummaryDataReaderAsync', + _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(), + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_js_1.ParameterId.PageRowCount] = pageRowCount, + _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases, + _a[api_internal_contract_js_1.ParameterId.IgnoreSelection] = ignoreSelection, + _a[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = includeAllColumns, + _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById), + _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption), + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetDataSummaryDataReader, parameters).then(function (response) { + var responseData = response.result; + return new GetDataTableReaderModels_1.DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, _this._registryId); + }); + }; + GetDataServiceImpl.prototype.getSummaryColumnsInfoAsync = function (visualId) { + var _a; + // Create all the parameters for GetDataType of Summary with 1 row, and only native values + // Then return just the columns + var verb = api_internal_contract_js_1.VerbId.GetDataSummaryData; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getSummaryColumnsInfoAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = true, + _a[api_internal_contract_js_1.ParameterId.IgnoreSelection] = true, + _a[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = true, + _a[api_internal_contract_js_1.ParameterId.MaxRows] = 1, + _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = api_internal_contract_js_1.ApiShowDataTableFormat.NativeValuesOnly, + _a); + return this.execute(verb, parameters).then(function (response) { + var underlyingDataTable = response.result; + var dataTable = underlyingDataTable.data; + var columns = dataTable.headers.map(function (h) { return new GetDataModels_1.Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index); }); + return columns; + }); + }; + GetDataServiceImpl.prototype.getSelectedMarksAsync = function (visualId) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getSelectedMarksAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetSelectedMarks, parameters).then(function (response) { + var responseData = response.result; + return { + data: responseData.data.map(function (table) { return _this.processResultsTable(table, true); }), + }; + }); + }; + GetDataServiceImpl.prototype.getHighlightedMarksAsync = function (visualId) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getHighlightedMarksAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetHighlightedMarks, parameters).then(function (response) { + var responseData = response.result; + return { + data: responseData.data.map(function (table) { return _this.processResultsTable(table, true); }), + }; + }); + }; + GetDataServiceImpl.prototype.getDataSourceDataAsync = function (dataSourceId, ignoreAliases, maxRows, columnsToInclude, columnsToIncludeById, includeDataValuesOption) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getDataSourceDataAsync', + _a[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId, + _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases, + _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1), + _a[api_internal_contract_js_1.ParameterId.ColumnsToInclude] = this.verifyIncludeColumnArray(columnsToInclude), + _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById), + _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption), + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetDataSourceData, parameters).then(function (response) { + var responseData = response.result; + return _this.processResultsTable(responseData.data, false); + }); + }; + GetDataServiceImpl.prototype.getLogicalTableDataAsync = function (datasourceId, logicalTableId, ignoreAliases, maxRows, columnsToInclude, columnsToIncludeById, includeDataValuesOption) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getLogicalTableDataAsync', + _a[api_internal_contract_js_1.ParameterId.ColumnsToInclude] = columnsToInclude, + _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById), + _a[api_internal_contract_js_1.ParameterId.DataSourceId] = datasourceId, + _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases, + _a[api_internal_contract_js_1.ParameterId.LogicalTableId] = logicalTableId, + _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1), + _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption), + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetLogicalTableData, parameters).then(function (response) { + var responseData = response.result; + return _this.processResultsTable(responseData.data, false); + }); + }; + GetDataServiceImpl.prototype.getLogicalTableDataReaderAsync = function (datasourceId, logicalTableId, pageRowCount, ignoreAliases, columnsToIncludeById, includeDataValuesOption) { + var _a; + var _this = this; + pageRowCount = this.getLimitedMaxRows(pageRowCount, this.getMaxRowLimit()); + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getLogicalTableDataReaderAsync', + _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(), + _a[api_internal_contract_js_1.ParameterId.DataSourceId] = datasourceId, + _a[api_internal_contract_js_1.ParameterId.LogicalTableId] = logicalTableId, + _a[api_internal_contract_js_1.ParameterId.PageRowCount] = pageRowCount, + _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases, + _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById), + _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption), + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetLogicalTableDataReader, parameters).then(function (response) { + var responseData = response.result; + return new GetDataTableReaderModels_1.DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, _this._registryId); + }); + }; + GetDataServiceImpl.prototype.getUnderlyingTableDataAsync = function (visualId, logicalTableId, ignoreAliases, ignoreSelection, includeAllColumns, columnsToIncludeById, maxRows, includeDataValuesOption) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getUnderlyingTableDataAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_js_1.ParameterId.LogicalTableId] = logicalTableId, + _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases, + _a[api_internal_contract_js_1.ParameterId.IgnoreSelection] = ignoreSelection, + _a[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = includeAllColumns, + _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById), + _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1), + _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption), + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetUnderlyingTableData, parameters).then(function (response) { + var responseData = response.result; + return _this.processResultsTable(responseData.data, false); + }); + }; + GetDataServiceImpl.prototype.getUnderlyingTableDataReaderAsync = function (visualId, logicalTableId, pageRowCount, ignoreAliases, ignoreSelection, includeAllColumns, columnsToIncludeById, includeDataValuesOption) { + var _a; + var _this = this; + pageRowCount = this.getLimitedMaxRows(pageRowCount, this.getMaxRowLimit()); + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getUnderlyingTableDataReaderAsync', + _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(), + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_js_1.ParameterId.LogicalTableId] = logicalTableId, + _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases, + _a[api_internal_contract_js_1.ParameterId.IgnoreSelection] = ignoreSelection, + _a[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = includeAllColumns, + _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById), + _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption), + _a[api_internal_contract_js_1.ParameterId.PageRowCount] = pageRowCount, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetUnderlyingTableDataReader, parameters).then(function (response) { + var responseData = response.result; + return new GetDataTableReaderModels_1.DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, _this._registryId); + }); + }; + GetDataServiceImpl.prototype.getPageAsync = function (tableId, pageNumber, pageSize) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getPageAsync', + _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(), + _a[api_internal_contract_js_1.ParameterId.ViewDataTableId] = tableId, + _a[api_internal_contract_js_1.ParameterId.DataRowIndex] = pageNumber * pageSize, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetDataTableReaderPage, parameters).then(function (response) { + var responseData = response.result; + return _this.processResultsPage(responseData, tableId === GetDataServiceImpl.summaryTableId ? true : false); + }); + }; + GetDataServiceImpl.prototype.releaseAsync = function (tableId) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'release', + _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(), + _a[api_internal_contract_js_1.ParameterId.ViewDataTableId] = tableId, + _a); + return this.execute(api_internal_contract_js_1.VerbId.ReleaseDataTableReader, parameters).then(function (response) { + return; + }); + }; + GetDataServiceImpl.prototype.verifyIncludeColumnArray = function (columns) { + // columns must be a valid array + if (!Array.isArray(columns)) { + throw new ApiShared_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'columnsToInclude and columnsToIncludeById must be valid arrays'); + } + // Remove any duplicates from the input array + var columnsAsSet = new Set(columns); + return Array.from(columnsAsSet); + }; + GetDataServiceImpl.prototype.processResultsTable = function (responseData, isSummary) { + var headers = responseData.headers.map(function (h) { return new GetDataModels_1.Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index); }); + // TODO This should be controlled by a flag indicating whether this api will respond marks info or not + var marks; + if (responseData.marks) { + marks = responseData.marks.map(function (h) { return new GetDataModels_1.MarkInfo(h.type, h.color, h.tupleId); }); + } + // Limit+1 is our sentinal that underlying data contains more rows than user is allowed to fetch. + // Remove the last element so we always return MaxRowLimit + var isTotalRowCountLimited = isSummary === false && responseData.dataTable.length === this.getMaxRowLimit() + 1; + if (isTotalRowCountLimited) { + responseData.dataTable.length -= 1; + } + var table = responseData.dataTable.map(function (row) { + return row.map(function (cell, index) { + return DataValueFactory_1.DataValueFactory.MakeTableDataValue(cell, headers[index].dataType); + }); + }); + if (marks) { + return new GetDataModels_1.DataTable(table, headers, table.length, isTotalRowCountLimited, isSummary, marks); + } + return new GetDataModels_1.DataTable(table, headers, table.length, isTotalRowCountLimited, isSummary); + }; + GetDataServiceImpl.prototype.processResultsPage = function (responseData, isSummary) { + var headers = responseData.headers.map(function (h) { return new GetDataModels_1.Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index); }); + var marks; + if (responseData.marks) { + marks = responseData.marks.map(function (h) { return new GetDataModels_1.MarkInfo(h.type, h.color, h.tupleId); }); + } + var table = responseData.dataTable.map(function (row) { + return row.map(function (cell, index) { + return DataValueFactory_1.DataValueFactory.MakeTableDataValue(cell, headers[index].dataType); + }); + }); + if (marks) { + return new GetDataModels_1.DataTable(table, headers, table.length, false, isSummary, marks); + } + return new GetDataModels_1.DataTable(table, headers, table.length, false, isSummary); + }; + GetDataServiceImpl.summaryTableId = ''; + return GetDataServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.GetDataServiceImpl = GetDataServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/NotificationServiceImpl.js": +/*!***********************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/NotificationServiceImpl.js ***! + \***********************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var NotificationServiceImplBase_1 = __webpack_require__(/*! ./NotificationServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/NotificationServiceImplBase.js"); +var NotificationServiceImpl = /** @class */ (function (_super) { + __extends(NotificationServiceImpl, _super); + function NotificationServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(NotificationServiceImpl.prototype, "serviceName", { + get: function () { + return "notification-service" /* Notification */; + }, + enumerable: true, + configurable: true + }); + return NotificationServiceImpl; +}(NotificationServiceImplBase_1.NotificationServiceImplBase)); +exports.NotificationServiceImpl = NotificationServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/NotificationServiceImplBase.js": +/*!***************************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/NotificationServiceImplBase.js ***! + \***************************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Registration = /** @class */ (function () { + function Registration(_filterFn, _callbackFn) { + this._filterFn = _filterFn; + this._callbackFn = _callbackFn; + // Nothing Here + } + Registration.prototype.onNotification = function (notificationModel) { + if (this._filterFn(notificationModel)) { + this._callbackFn(notificationModel); + } + }; + return Registration; +}()); +exports.Registration = Registration; +var NotificationServiceImplBase = /** @class */ (function () { + function NotificationServiceImplBase(dispatcher) { + this.dispatcher = dispatcher; + this._handlers = {}; + this.dispatcher.registerNotificationHandler(this.onNotification.bind(this)); + } + NotificationServiceImplBase.prototype.registerHandler = function (id, filterFn, handler) { + var _this = this; + var handlers = this._handlers[id] || new Array(); + var registration = new Registration(filterFn, handler); + handlers.push(registration); + this._handlers[id] = handlers; + return function () { return _this.removeRegistration(id, registration); }; + }; + NotificationServiceImplBase.prototype.hasHandlersForNotificationType = function (id) { + // eslint-disable-next-line no-prototype-builtins + return this._handlers.hasOwnProperty(id); + }; + NotificationServiceImplBase.prototype.onNotification = function (notification) { + if (!this.hasHandlersForNotificationType(notification.notificationId)) { + return; + } + // Go through and check for all the handlers of this particular notification + this._handlers[notification.notificationId].forEach(function (h) { return h.onNotification(notification.data); }); + }; + NotificationServiceImplBase.prototype.removeRegistration = function (id, registration) { + if (!this.hasHandlersForNotificationType(id)) { + return; + } + this._handlers[id] = this._handlers[id].filter(function (reg) { return reg !== registration; }); + }; + return NotificationServiceImplBase; +}()); +exports.NotificationServiceImplBase = NotificationServiceImplBase; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/ParametersServiceImpl.js": +/*!*********************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/ParametersServiceImpl.js ***! + \*********************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var ParameterImpl_1 = __webpack_require__(/*! ../../Impl/ParameterImpl */ "../api-shared-js/lib/src/ApiShared/Impl/ParameterImpl.js"); +var TableauError_1 = __webpack_require__(/*! ../../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var ParametersServiceImpl = /** @class */ (function (_super) { + __extends(ParametersServiceImpl, _super); + function ParametersServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(ParametersServiceImpl.prototype, "serviceName", { + get: function () { + return "parameters-service" /* Parameters */; + }, + enumerable: true, + configurable: true + }); + ParametersServiceImpl.prototype.getParametersForSheetAsync = function (sheetPath) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getParametersForSheetAsync', + _a[api_internal_contract_js_1.ParameterId.SheetPath] = sheetPath, + _a); + return this.getParametersAsync(parameters); + }; + ParametersServiceImpl.prototype.getAllParametersAsync = function () { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getParametersForSheetAsync', + _a); + return this.getParametersAsync(parameters); + }; + ParametersServiceImpl.prototype.getParametersAsync = function (inputParameters) { + var _this = this; + return this.execute(api_internal_contract_js_1.VerbId.GetParametersForSheet, inputParameters).then(function (response) { + var result = response.result; + return result.map(function (parameterInfo) { + return new ParameterImpl_1.ParameterImpl(parameterInfo, _this._registryId); + }); + }); + }; + ParametersServiceImpl.prototype.changeParameterValueAsync = function (fieldName, newValue) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'changeParameterValueAsync', + _a[api_internal_contract_js_1.ParameterId.ParameterFieldName] = fieldName, + _a[api_internal_contract_js_1.ParameterId.ParameterValue] = newValue, + _a); + return this.execute(api_internal_contract_js_1.VerbId.ChangeParameterValue, parameters).then(function (response) { + var result = response.result; + return result; + }); + }; + ParametersServiceImpl.prototype.findParameterByNameAsync = function (name) { + return this.findParameterAsync(name, undefined); + }; + ParametersServiceImpl.prototype.findParameterByGlobalFieldNameAsync = function (fieldName) { + return this.findParameterAsync(undefined, fieldName); + }; + ParametersServiceImpl.prototype.findParameterAsync = function (name, fieldName) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'findParameterAsync', + _a); + if (name !== undefined) { + parameters[api_internal_contract_js_1.ParameterId.ParameterCaption] = name; + } + else if (fieldName !== undefined) { + parameters[api_internal_contract_js_1.ParameterId.ParameterFieldName] = fieldName; + } + else { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, 'name or fieldName must be provided to find parameter'); + } + return this.execute(api_internal_contract_js_1.VerbId.FindParameter, parameters).then(function (response) { + var instanceOfParameterInfo = function (object) { + return 'fieldName' in object; + }; + // We need to check to see if we got a valid response back again + if (instanceOfParameterInfo(response.result)) { + var result = response.result; + return new ParameterImpl_1.ParameterImpl(result, _this._registryId); + } + else { + return undefined; + } + }); + }; + return ParametersServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.ParametersServiceImpl = ParametersServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/SelectionServiceImpl.js": +/*!********************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/SelectionServiceImpl.js ***! + \********************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var SelectionModels_1 = __webpack_require__(/*! ../../Models/SelectionModels */ "../api-shared-js/lib/src/ApiShared/Models/SelectionModels.js"); +var TableauError_1 = __webpack_require__(/*! ../../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var Param_1 = __webpack_require__(/*! ../../Utils/Param */ "../api-shared-js/lib/src/ApiShared/Utils/Param.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var SelectionServiceImpl = /** @class */ (function (_super) { + __extends(SelectionServiceImpl, _super); + function SelectionServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(SelectionServiceImpl.prototype, "serviceName", { + get: function () { + return "selection-service" /* Selection */; + }, + enumerable: true, + configurable: true + }); + /** + * Method to clear all the selected marks for the given worksheet. + * + * @param visualId + */ + SelectionServiceImpl.prototype.clearSelectedMarksAsync = function (visualId) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'clearSelectedMarksAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a); + return this.execute(api_internal_contract_js_1.VerbId.ClearSelectedMarks, parameters).then(function (response) { + return; // Expecting an empty model and hence the void response. + }); + }; + /** + * Method to select marks for the given worksheet. + * + * @param visualId + * @param selectionCriteria + * @param selectionUpdateType + */ + SelectionServiceImpl.prototype.selectMarksByValueAsync = function (visualId, selectionCriterias, selectionUpdateType) { + var _a; + var _this = this; + if (selectionCriterias.length === 0) { + throw new TableauError_1.TableauError(Contract.ErrorCodes.InvalidParameter, 'Selection criteria missing for selecting marks by value'); + } + var selectionType = this.validateSelectionUpdateType(selectionUpdateType); + var selectionModelContainer = this.parseSelectionMarks(selectionCriterias); + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'selectMarksByValueAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_js_1.ParameterId.SelectionUpdateType] = selectionType, + _a); + if (selectionModelContainer.hierModelArr && selectionModelContainer.hierModelArr.length) { + parameters[api_internal_contract_js_1.ParameterId.HierValSelectionModels] = selectionModelContainer.hierModelArr; + } + if (selectionModelContainer.quantModelArr && selectionModelContainer.quantModelArr.length) { + parameters[api_internal_contract_js_1.ParameterId.QuantRangeSelectionModels] = selectionModelContainer.quantModelArr; + } + if (selectionModelContainer.dimModelArr && selectionModelContainer.dimModelArr.length) { + parameters[api_internal_contract_js_1.ParameterId.DimValSelectionModels] = selectionModelContainer.dimModelArr; + } + return this.execute(api_internal_contract_js_1.VerbId.SelectByValue, parameters).then(function (response) { + _this.apiFilterHandlerCheckForCommandError(response.result); + return; + }); + }; + /** + * Method to execute hover actions and render tooltip for a given tuple representing a mark in the visualization. + * If the tooltip parameter is included it will show the tooltip on hover. If not, no tooltip is shown. + * + * @param visualId + * @param hoveredTuple + * @param tooltip + * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error + */ + SelectionServiceImpl.prototype.hoverTupleAsync = function (visualId, hoveredTuple, tooltip, allowHoverActions) { + var _a; + var interactionModel = new SelectionModels_1.HoverTupleInteractionModel(visualId, this.ensureTupleIDIsNonNegative(hoveredTuple), tooltip, allowHoverActions); + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'hoverTupleAsync', + _a[api_internal_contract_js_1.ParameterId.HoverTupleInteraction] = interactionModel, + _a); + return this.execute(api_internal_contract_js_1.VerbId.RaiseHoverTupleNotification, parameters).then(function (response) { + return; + }); + }; + /** + * Method to modify selection, execute select actions and render tooltip for a given list of tuples representing a mark or marks in the visualization. + * If the tooltip parameter is included it will show the tooltip on select. If not, no tooltip is shown. + * + * @param visualId + * @param selectedTuples + * @param selectOption + * @param tooltip + * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error + */ + SelectionServiceImpl.prototype.selectTuplesAsync = function (visualId, selectedTuples, selectOption, tooltip) { + var _a; + var interactionModel = new SelectionModels_1.SelectTuplesInteractionModel(visualId, selectedTuples, selectOption, tooltip); + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'selectTuplesAsync', + _a[api_internal_contract_js_1.ParameterId.SelectTuplesInteraction] = interactionModel, + _a); + return this.execute(api_internal_contract_js_1.VerbId.RaiseSelectTuplesNotification, parameters).then(function (response) { + return; + }); + }; + SelectionServiceImpl.prototype.apiFilterHandlerCheckForCommandError = function (serverPm) { + if (!serverPm[api_internal_contract_js_1.ParameterId.ParameterError]) { + return; + } + if (serverPm[api_internal_contract_js_1.ParameterId.InvalidFields]) { + throw new TableauError_1.TableauError(Contract.SharedErrorCodes.InvalidSelectionFieldName, serverPm[api_internal_contract_js_1.ParameterId.InvalidFields]); + } + if (serverPm[api_internal_contract_js_1.ParameterId.InvalidValues]) { + throw new TableauError_1.TableauError(Contract.SharedErrorCodes.InvalidSelectionValue, serverPm[api_internal_contract_js_1.ParameterId.InvalidValues]); + } + if (serverPm[api_internal_contract_js_1.ParameterId.InvalidDates]) { + throw new TableauError_1.TableauError(Contract.SharedErrorCodes.InvalidSelectionDate, serverPm[api_internal_contract_js_1.ParameterId.InvalidDates]); + } + }; + /** + * Method to select marks for the given worksheet. + * + * @param visualId + * @param MarkInfo + * @param selectionUpdateType + */ + SelectionServiceImpl.prototype.selectMarksByIdAsync = function (visualId, marks, selectionUpdateType) { + var _a; + if (marks.length === 0) { + throw new TableauError_1.TableauError(Contract.ErrorCodes.InvalidParameter, 'Marks info missing for selecting marks by Id'); + } + var selectionType = this.validateSelectionUpdateType(selectionUpdateType); + var selectionModelContainer = this.parseSelectionIds(marks); + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'selectMarksByIdAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a[api_internal_contract_js_1.ParameterId.SelectionUpdateType] = selectionType, + _a[api_internal_contract_js_1.ParameterId.Selection] = selectionModelContainer.selection, + _a); + return this.execute(api_internal_contract_js_1.VerbId.SelectByValue, parameters).then(function (response) { + // Expecting an empty model and hence the void response. + return; + // TODO Investigate the error response with multiple output params and throw error accordingly. + }); + }; + /** + * Method to prepare the pres models for selection by MarksInfo + * @param marks + */ + SelectionServiceImpl.prototype.parseSelectionIds = function (marks) { + var ids = []; + var selectionModelContainer = new SelectionModels_1.SelectionModelsContainer(); + for (var i = 0; i < marks.length; i++) { + var tupleId = marks[i].tupleId; + if (tupleId !== undefined && tupleId !== null) { + // If tuple id is provided use that instead of pair + ids.push(tupleId.toString()); // collect the tuple ids + } + else { + throw new TableauError_1.TableauError(Contract.ErrorCodes.InternalError, 'tupleId parsing error'); + } + } + if (ids.length !== 0) { + // tuple ids based selection + var tupleSelectionModel = new SelectionModels_1.TupleSelectionModel(); + tupleSelectionModel.selectionType = 'tuples'; + tupleSelectionModel.objectIds = ids; + selectionModelContainer.selection = tupleSelectionModel; + } + return selectionModelContainer; + }; + /** + * Method to prepare the pres models for selection by values. + * + * Supports 3 types for selection: + * 1) Hierarchical value based selection + * 2) Range value based selection + * 3) Dimension value based selection + * + * @param marks + */ + SelectionServiceImpl.prototype.parseSelectionMarks = function (selectionCriterias) { + var selectionModelContainer = new SelectionModels_1.SelectionModelsContainer(); + for (var i = 0; i < selectionCriterias.length; i++) { + var st = selectionCriterias[i]; + if (!(st.fieldName && st.value !== undefined && st.value !== null)) { + throw new TableauError_1.TableauError(Contract.ErrorCodes.InternalError, 'Selection Criteria parsing error'); + } + var catRegex = new RegExp('([[A-Za-z0-9]+]).*', 'g'); + var rangeOption = st.value; + if (catRegex.test(st.fieldName)) { + // Hierarchical value selection + var hierModel = this.addToParamsList(st.fieldName, st.value); + selectionModelContainer.hierModelArr.push(hierModel); + } + else if (rangeOption.min !== undefined && rangeOption.max !== undefined) { + // Range value selection + var quantModel = this.addToRangeParamsList(st.fieldName, rangeOption); + selectionModelContainer.quantModelArr.push(quantModel); + } + else { + // Dimension value selection + var dimModel = this.addToParamsList(st.fieldName, st.value); + selectionModelContainer.dimModelArr.push(dimModel); + } + } + return selectionModelContainer; + }; + /** + * Method to transform the key value pair into value based pres model object. + * + * @param valueSelectionModel + * @param fieldName + * @param value + */ + SelectionServiceImpl.prototype.addToParamsList = function (fieldName, value) { + var valueSelectionModel = new SelectionModels_1.ValueSelectionModel(); + var markValues = []; + if (value instanceof Array) { + var valueArr = value; + for (var i = 0; i < valueArr.length; i++) { + markValues.push(Param_1.Param.serializeParameterValue(valueArr[i])); + } + } + else { + markValues.push(Param_1.Param.serializeParameterValue(value)); + } + valueSelectionModel.qualifiedFieldCaption = fieldName; + valueSelectionModel.selectValues = markValues; + return valueSelectionModel; + }; + /** + * Method to transform the key value pair into range based selection pres model. + * + * TODO: Need to handle the parsing of date type values. + * + * @param valueSelectionModel + * @param fieldName + * @param value + */ + SelectionServiceImpl.prototype.addToRangeParamsList = function (fieldName, value) { + var rangeSelectionModel = new SelectionModels_1.RangeSelectionModel(); + rangeSelectionModel.qualifiedFieldCaption = fieldName; + if (value.max !== undefined && value.max !== null) { + rangeSelectionModel.maxValue = Param_1.Param.serializeParameterValue(value.max); + } + if (value.min !== undefined && value.min !== null) { + rangeSelectionModel.minValue = Param_1.Param.serializeParameterValue(value.min); + } + rangeSelectionModel.included = this.validateNullOptionType(value.nullOption); + return rangeSelectionModel; + }; + /** + * Method to validate the selection update type. + * + * @param selectionUpdateType + */ + SelectionServiceImpl.prototype.validateSelectionUpdateType = function (selectionUpdateType) { + if (selectionUpdateType === Contract.SelectionUpdateType.Replace) { + return api_internal_contract_js_1.SelectionUpdateType.Replace; + } + else if (selectionUpdateType === Contract.SelectionUpdateType.Add) { + return api_internal_contract_js_1.SelectionUpdateType.Add; + } + else if (selectionUpdateType === Contract.SelectionUpdateType.Remove) { + return api_internal_contract_js_1.SelectionUpdateType.Remove; + } + return api_internal_contract_js_1.SelectionUpdateType.Replace; + }; + /** + * Method to validate the include type for range selection. + * + * @param nullOption + */ + SelectionServiceImpl.prototype.validateNullOptionType = function (nullOption) { + if (nullOption) { + if (nullOption === Contract.FilterNullOption.NullValues) { + return api_internal_contract_js_1.QuantitativeIncludedValues.IncludeNull; + } + else if (nullOption === Contract.FilterNullOption.NonNullValues) { + return api_internal_contract_js_1.QuantitativeIncludedValues.IncludeNonNull; + } + else if (nullOption === Contract.FilterNullOption.AllValues) { + return api_internal_contract_js_1.QuantitativeIncludedValues.IncludeAll; + } + } + return api_internal_contract_js_1.QuantitativeIncludedValues.IncludeAll; + }; + SelectionServiceImpl.prototype.ensureTupleIDIsNonNegative = function (tupleId) { + if (tupleId && tupleId > 0) { + return tupleId; + } + // 0 will not refer to a valid tuple (since tuple ids are 1-based), + // but can be used for clearing the current hover or selection + return 0; + }; + return SelectionServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.SelectionServiceImpl = SelectionServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js": +/*!***************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js ***! + \***************************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var InternalToExternalEnumMappings_1 = __webpack_require__(/*! ../../EnumMappings/InternalToExternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js"); +var TableauError_1 = __webpack_require__(/*! ../../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var EnumConverter_1 = __webpack_require__(/*! ../../Utils/EnumConverter */ "../api-shared-js/lib/src/ApiShared/Utils/EnumConverter.js"); +/** + * Each ServceImpl should extend this base class for the sake of + * proper error handling. This base handles the conversion + * from internal errors to external errors that we throw to developers + */ +var ServiceImplBase = /** @class */ (function () { + function ServiceImplBase(_dispatcher, _registryId) { + this._dispatcher = _dispatcher; + this._registryId = _registryId; + } + ServiceImplBase.prototype.execute = function (verb, params) { + return this._dispatcher.execute(verb, params).catch(function (error) { + // Any internal error that comes from the dispatcher should be converted + // to an external error using the enum mapper for error codes. + var internalError = error; + var externalErrorCode = InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.errorCode.convert(internalError.errorCode, EnumConverter_1.ShouldThrow.No); + throw new TableauError_1.TableauError(externalErrorCode, internalError.message); + }); + }; + return ServiceImplBase; +}()); +exports.ServiceImplBase = ServiceImplBase; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/SizeServiceImpl.js": +/*!***************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/SizeServiceImpl.js ***! + \***************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var SizeServiceImpl = /** @class */ (function (_super) { + __extends(SizeServiceImpl, _super); + function SizeServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(SizeServiceImpl.prototype, "serviceName", { + get: function () { + return "size-service" /* Size */; + }, + enumerable: true, + configurable: true + }); + SizeServiceImpl.prototype.changeSizeAsync = function (name, newSize) { + var _a; + var _b, _c, _d, _e; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'changeSizeAsync', + _a[api_internal_contract_js_1.ParameterId.SheetName] = name, + _a[api_internal_contract_js_1.ParameterId.MinHeight] = ((_b = newSize.minSize) === null || _b === void 0 ? void 0 : _b.height) || 0, + _a[api_internal_contract_js_1.ParameterId.MinWidth] = ((_c = newSize.minSize) === null || _c === void 0 ? void 0 : _c.width) || 0, + _a[api_internal_contract_js_1.ParameterId.MaxHeight] = ((_d = newSize.maxSize) === null || _d === void 0 ? void 0 : _d.height) || 0, + _a[api_internal_contract_js_1.ParameterId.MaxWidth] = ((_e = newSize.maxSize) === null || _e === void 0 ? void 0 : _e.width) || 0, + _a); + return this.execute(api_internal_contract_js_1.VerbId.SetSheetSize, parameters).then(function (_response) { + return; + }); + }; + return SizeServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.SizeServiceImpl = SizeServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/StoryActivationServiceImpl.js": +/*!**************************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/StoryActivationServiceImpl.js ***! + \**************************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var StoryActivationServiceImpl = /** @class */ (function (_super) { + __extends(StoryActivationServiceImpl, _super); + function StoryActivationServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(StoryActivationServiceImpl.prototype, "serviceName", { + get: function () { + return "story-activation-service" /* StoryActivation */; + }, + enumerable: true, + configurable: true + }); + StoryActivationServiceImpl.prototype.activateNextStoryPointAsync = function () { + var _a; + var verb = api_internal_contract_js_1.VerbId.ActivateNextStoryPoint; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'activateNextStoryPointAsync', + _a); + return this.execute(verb, parameters).then(function (response) { + return; + }); + }; + StoryActivationServiceImpl.prototype.activatePreviousStoryPointAsync = function () { + var _a; + var verb = api_internal_contract_js_1.VerbId.ActivatePreviousStoryPoint; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'activatePreviousStoryPointAsync', + _a); + return this.execute(verb, parameters).then(function (response) { + return; + }); + }; + StoryActivationServiceImpl.prototype.activateStoryPointAsync = function (index) { + var _a; + var verb = api_internal_contract_js_1.VerbId.ActivateStoryPoint; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'activateStoryPointAsync', + _a); + parameters[api_internal_contract_js_1.ParameterId.StoryPointIndex] = index; + return this.execute(verb, parameters).then(function (response) { + return; + }); + }; + StoryActivationServiceImpl.prototype.revertStoryPointAsync = function (index) { + var _a; + var verb = api_internal_contract_js_1.VerbId.RevertStoryPoint; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'revertStoryPointAsync', + _a); + parameters[api_internal_contract_js_1.ParameterId.StoryPointIndex] = index; + return this.execute(verb, parameters).then(function (response) { + return response.result; + }); + }; + return StoryActivationServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.StoryActivationServiceImpl = StoryActivationServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/VisualModelServiceImpl.js": +/*!**********************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/VisualModelServiceImpl.js ***! + \**********************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var VisualModelServiceImpl = /** @class */ (function (_super) { + __extends(VisualModelServiceImpl, _super); + function VisualModelServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(VisualModelServiceImpl.prototype, "serviceName", { + get: function () { + return "visual-model-service" /* VisualModel */; + }, + enumerable: true, + configurable: true + }); + VisualModelServiceImpl.prototype.getVisualSpecificationAsync = function (visualId) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getVisualSpecificationAsync', + _a[api_internal_contract_js_1.ParameterId.WorksheetName] = visualId.worksheet, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetVisualSpecification, parameters).then(function (response) { + var result = response.result; + return result; + }); + }; + return VisualModelServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.VisualModelServiceImpl = VisualModelServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/VizServiceImpl.js": +/*!**************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/VizServiceImpl.js ***! + \**************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var CustomViewImpl_1 = __webpack_require__(/*! ../../Impl/CustomViewImpl */ "../api-shared-js/lib/src/ApiShared/Impl/CustomViewImpl.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var VizServiceImpl = /** @class */ (function (_super) { + __extends(VizServiceImpl, _super); + function VizServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(VizServiceImpl.prototype, "serviceName", { + get: function () { + return "viz-service" /* Viz */; + }, + enumerable: true, + configurable: true + }); + VizServiceImpl.prototype.createVizImageAsync = function (inputSpec) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'createVizImageAsync', + _a[api_internal_contract_js_1.ParameterId.VizAPIInputJson] = JSON.stringify(inputSpec), + _a); + return this.execute(api_internal_contract_js_1.VerbId.VizAPI, parameters).then(function (response) { + var result = response.result; + return result; + }); + }; + VizServiceImpl.prototype.activateSheetAsync = function (name) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'activateSheetAsync', + _a[api_internal_contract_js_1.ParameterId.SwitchToSheetName] = name, + _a); + return this.execute(api_internal_contract_js_1.VerbId.ActivateSheet, parameters).then(function () { + return; + }); + }; + VizServiceImpl.prototype.getCustomViewsAsync = function () { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getCustomViewsAsync', + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetCustomViews, parameters).then(function (response) { + var customViews = response.result; + return customViews.map(function (customView) { + return new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId); + }); + }); + }; + VizServiceImpl.prototype.showCustomViewAsync = function (customViewName) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'showCustomViewAsync', + _a[api_internal_contract_js_1.ParameterId.CustomViewName] = customViewName || '', + _a); + return this.execute(api_internal_contract_js_1.VerbId.ShowCustomView, parameters).then(function (response) { + var _a; + var customView = response.result; + return ((_a = customView) === null || _a === void 0 ? void 0 : _a.luid) ? new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId) : undefined; + }); + }; + VizServiceImpl.prototype.removeCustomViewAsync = function (customViewName) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'removeCustomViewAsync', + _a[api_internal_contract_js_1.ParameterId.CustomViewName] = customViewName, + _a); + return this.execute(api_internal_contract_js_1.VerbId.RemoveCustomView, parameters).then(function (response) { + var customView = response.result; + return new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId); + }); + }; + VizServiceImpl.prototype.saveCustomViewAsync = function (customViewName) { + var _a; + var _this = this; + // CustomViewIsDefault is a required parameter, but our API has not been updated to allow it to be specified yet. + // We should add a 'default' parameter to the interface. + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'saveCustomViewAsync', + _a[api_internal_contract_js_1.ParameterId.CustomViewName] = customViewName, + _a[api_internal_contract_js_1.ParameterId.CustomViewIsDefault] = false, + _a); + return this.execute(api_internal_contract_js_1.VerbId.SaveWorkbookAsCustomView, parameters).then(function (response) { + var customView = response.result; + return new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId); + }); + }; + VizServiceImpl.prototype.setActiveCustomViewAsDefaultAsync = function () { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'setActiveCustomViewAsDefaultAsync', + _a); + return this.execute(api_internal_contract_js_1.VerbId.SetActiveCustomViewAsDefault, parameters).then(function () { + return; + }); + }; + VizServiceImpl.prototype.saveAsync = function (customView) { + var _a; + var _this = this; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'saveAsync', + _a[api_internal_contract_js_1.ParameterId.CustomViewLuid] = customView.luid, + _a[api_internal_contract_js_1.ParameterId.CustomViewName] = customView.name, + _a[api_internal_contract_js_1.ParameterId.CustomViewIsDefault] = customView.isDefault, + _a[api_internal_contract_js_1.ParameterId.CustomViewIsPublic] = customView.shared, + _a); + return this.execute(api_internal_contract_js_1.VerbId.UpdateCustomView, parameters).then(function (response) { + var customView = response.result; + return new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId); + }); + }; + VizServiceImpl.prototype.getCurrentSrcAsync = function () { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getCurrentSrcAsync', + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetCurrentSrc, parameters).then(function (response) { return response.result; }); + }; + return VizServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.VizServiceImpl = VizServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/ZoneServiceImpl.js": +/*!***************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/ZoneServiceImpl.js ***! + \***************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var ExternalToInternalEnumMappings_1 = __webpack_require__(/*! ../../EnumMappings/ExternalToInternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ../../Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var Param_1 = __webpack_require__(/*! ../../Utils/Param */ "../api-shared-js/lib/src/ApiShared/Utils/Param.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var ZoneServiceImpl = /** @class */ (function (_super) { + __extends(ZoneServiceImpl, _super); + function ZoneServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(ZoneServiceImpl.prototype, "serviceName", { + get: function () { + return "zone-service" /* Zone */; + }, + enumerable: true, + configurable: true + }); + ZoneServiceImpl.prototype.setVisibilityAsync = function (dashboard, dashboardZoneMap, zoneVisibilityMap) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'setVisibilityAsync', + _a[api_internal_contract_js_1.ParameterId.Dashboard] = dashboard, + _a[api_internal_contract_js_1.ParameterId.ZoneIdsVisibilityMap] = {}, + _a); + // zoneVisibilityMap can be either an object or a Map - convert it to a Map + var parameterAsMap = Param_1.Param.convertParameterToMap(zoneVisibilityMap, 'zoneVisibilityMap'); + parameterAsMap.forEach(function (value, key) { + ErrorHelpers_1.ErrorHelpers.verifyZoneIsValid(dashboardZoneMap, Number.parseInt(key, 10)); + ErrorHelpers_1.ErrorHelpers.verifyEnumValue(value, api_external_contract_js_1.DashboardObjectVisibilityType, 'DashboardObjectVisibilityType'); + parameters[api_internal_contract_js_1.ParameterId.ZoneIdsVisibilityMap][key] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.setVisibilityType.convert(value); + }); + return this.execute(api_internal_contract_js_1.VerbId.SetZoneVisibility, parameters).then(function (response) { + return; + }); + }; + ZoneServiceImpl.prototype.moveAndResizeAsync = function (dashboard, dashboardZoneMap, dashboardObjectPositionAndSizeUpdateArray) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.Dashboard] = dashboard, + _a[api_internal_contract_js_1.ParameterId.DashboardObjectPositionAndSizeUpdateList] = dashboardObjectPositionAndSizeUpdateArray, + _a); + dashboardObjectPositionAndSizeUpdateArray.forEach(function (dashboardObject) { + ErrorHelpers_1.ErrorHelpers.verifyZoneIsValidAndFloating(dashboardZoneMap, dashboardObject.dashboardObjectID); + ErrorHelpers_1.ErrorHelpers.verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate(dashboardObject); + }); + return this.execute(api_internal_contract_js_1.VerbId.MoveAndResizeZones, parameters).then(function (response) { + return; + }); + }; + return ZoneServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.ZoneServiceImpl = ZoneServiceImpl; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/TableSummary.js": +/*!**********************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/TableSummary.js ***! + \**********************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Implementation of a table summary. + * This does not follow the Impl pattern as it is just a property bag. + */ +var TableSummary = /** @class */ (function () { + function TableSummary(_tableInfo) { + this._tableInfo = _tableInfo; + } + Object.defineProperty(TableSummary.prototype, "name", { + get: function () { + return this._tableInfo.name; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TableSummary.prototype, "id", { + get: function () { + return this._tableInfo.id; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TableSummary.prototype, "connectionId", { + get: function () { + return this._tableInfo.connectionId; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(TableSummary.prototype, "customSQL", { + get: function () { + return this._tableInfo.customSQL; + }, + enumerable: true, + configurable: true + }); + return TableSummary; +}()); +exports.TableSummary = TableSummary; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/TableauError.js": +/*!**********************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/TableauError.js ***! + \**********************************************************/ +/***/ (function(__unused_webpack_module, exports) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * Custom error class that extends the default JavaScript Error object. + * This allows us to provide a field with a specific error code + * so that developers can more easily programmatically respond + * to error scenarios. + */ +var TableauError = /** @class */ (function (_super) { + __extends(TableauError, _super); + function TableauError(_errorCode, message) { + var _this = _super.call(this, _errorCode + ": " + message) || this; + _this._errorCode = _errorCode; + /*tslint:disable-next-line */ + // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work + // Error inheritance does not work propertly when compiling to ES5, this is a workaround to force + // the proto chain to be built correctly. See the github link above for details. + Object.setPrototypeOf(_this, TableauError.prototype); + return _this; + } + Object.defineProperty(TableauError.prototype, "errorCode", { + get: function () { + return this._errorCode; + }, + enumerable: true, + configurable: true + }); + return TableauError; +}(Error)); +exports.TableauError = TableauError; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Utils/DataValueFactory.js": +/*!********************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Utils/DataValueFactory.js ***! + \********************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var InternalContract = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var GetDataModels_1 = __webpack_require__(/*! ../Models/GetDataModels */ "../api-shared-js/lib/src/ApiShared/Models/GetDataModels.js"); +/** + * In version 2 of the interface, we should collapse value into nativeValue, and do all this work over + * in the platform. + */ +var DataValueFactory = /** @class */ (function () { + function DataValueFactory() { + } + DataValueFactory.MakeParameterDataValue = function (internalDataValue, dataType) { + // Parameter values are all strings, convert from string to value + return new GetDataModels_1.DataValue(internalDataValue.value, InternalContract.DataTypeConverter.convertStringValueToNativeValue(internalDataValue.value, dataType), internalDataValue.formattedValue); + }; + DataValueFactory.MakeFilterDataValue = function (internalDataValue) { + // Filters already have native type in value, just use that for nativeValue also + return new GetDataModels_1.DataValue(internalDataValue.value, internalDataValue.value, internalDataValue.formattedValue); + }; + DataValueFactory.MakeTableDataValue = function (internalDataValue, dataType) { + // DataTables contain boolean | number | string | date as string | '%null% + // convertValueToNativeValue converts dates as string to dates, and any special to null + // (boolean, numbers, strings are passed through) + // Because of IncludeDataValuesOption - we can have undefined values, which are different than any special + return new GetDataModels_1.DataValue(internalDataValue.value, internalDataValue.value !== undefined + ? InternalContract.DataTypeConverter.convertValueToNativeValue(internalDataValue.value, dataType) + : undefined, internalDataValue.formattedValue); + }; + return DataValueFactory; +}()); +exports.DataValueFactory = DataValueFactory; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Utils/Deferred.js": +/*!************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Utils/Deferred.js ***! + \************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +/** + * A Promise wrapper class allowing for resolving/rejecting the Promise outside the context of its constructor. + * + * @export + * @class Deferred + * @template TResolve The type used to resolve the promise. + * @template TReject The type used to reject the promise. Defaults to any. + * @link https://stackoverflow.com/a/34637436 + */ +var Deferred = /** @class */ (function () { + /** + * Creates an instance of Deferred. + */ + function Deferred() { + var _this = this; + this._promise = new Promise(function (resolve, reject) { + _this._resolve = resolve; + _this._reject = reject; + }); + } + Object.defineProperty(Deferred.prototype, "promise", { + /** + * Gets the Promise. + * + * @readonly + * @type {Promise} + */ + get: function () { + return this._promise; + }, + enumerable: true, + configurable: true + }); + /** + * Resolves the wrapped Promise. + * + * @param {(TResolve | PromiseLike)} response The argument to be resolved by the Promise. + * @returns {*} {void} + */ + Deferred.prototype.resolve = function (response) { + if (!this._resolve) { + return; + } + this._resolve(response); + }; + /** + * + * + * @param {TReject} [reason] The reason why the Promise rejected. + * @returns {*} {void} + */ + Deferred.prototype.reject = function (reason) { + if (!this._reject) { + return; + } + this._reject(reason); + }; + return Deferred; +}()); +exports.Deferred = Deferred; +exports.UnregisterTimeoutInMilliseconds = 30000; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Utils/EnumConverter.js": +/*!*****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Utils/EnumConverter.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +/** + * This class converts from a source enum value to destination enum + * value given a mapping from source to destination when constructed. + * + * Note: This exact same class is defined in api-core. Given its small + * nature, it is not worth having in a separate project to share this between + * api-core and api-shared. If more utility functionality is added that is used by api-core + * and api-shared but has no other dependecies, a utiltity project might be merited, + * and this class could be moved. + */ +var EnumConverter = /** @class */ (function () { + function EnumConverter(_mappings, _defaultVal) { + this._mappings = _mappings; + this._defaultVal = _defaultVal; + } + EnumConverter.prototype.convert = function (enumVal, throwIfMissing) { + if (throwIfMissing === void 0) { throwIfMissing = ShouldThrow.Yes; } + if (this._mappings.hasOwnProperty(enumVal)) { + return this._mappings[enumVal]; + } + if (this._defaultVal !== undefined && throwIfMissing !== ShouldThrow.Yes) { + return this._defaultVal; + } + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, "Enum Mapping not found for: " + enumVal); + }; + return EnumConverter; +}()); +exports.EnumConverter = EnumConverter; +var ShouldThrow; +(function (ShouldThrow) { + ShouldThrow["Yes"] = "yes"; + ShouldThrow["No"] = "no"; +})(ShouldThrow = exports.ShouldThrow || (exports.ShouldThrow = {})); + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js": +/*!****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js ***! + \****************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var Param_1 = __webpack_require__(/*! ./Param */ "../api-shared-js/lib/src/ApiShared/Utils/Param.js"); +/** + * This class is used to construct common errors throughout the external + * projects (api-shared, extensions-api, etc.). It has some duplication with + * the ErrorHelpers class in api-core, but is separate due to the need to throw + * an external TableauError vs. an InternalTableauError. + */ +var ErrorHelpers = /** @class */ (function () { + function ErrorHelpers() { + } + /** + * Throws with code InternalError. + * + * @param apiName name of api that was called. + */ + ErrorHelpers.apiNotImplemented = function (apiName) { + return new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, apiName + " API not yet implemented."); + }; + /** + * Throws an internal error if argument is null or undefined. + * + * @param argumentValue value to verify + * @param argumentName name of argument to verify + */ + /*tslint:disable-next-line */ + ErrorHelpers.verifyInternalValue = function (argumentValue, argumentName) { + if (argumentValue === null || argumentValue === undefined) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, argumentValue + " is invalid value for: " + argumentName); + } + }; + /** + * Throws an InvalidParameter error if argument is null or undefined. + * + * @param argumentValue value to verify + * @param argumentName name of argument to verify + */ + /*tslint:disable-next-line */ + ErrorHelpers.verifyParameter = function (argumentValue, argumentName) { + if (argumentValue === null || argumentValue === undefined) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, argumentValue + " is invalid value for parameter: " + argumentName); + } + }; + /** + * Throws an InvalidParameter error if argument is not the specified type. + * For objects, it just tests that it is an object + * + * @param argumentValue value to verify + * @param expectedType expected result of typeof + * @param argumentName name of argument to verify + */ + /*tslint:disable-next-line */ + ErrorHelpers.verifyParameterType = function (argumentValue, expectedType, argumentName) { + if (typeof argumentValue !== expectedType) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, argumentValue + " has invalid type for parameter: " + argumentName + "."); + } + }; + /** + * Throws an InvalidParameter error if argument is empty string, null or undefined. + * + * @param argumentValue value to verify + * @param argumentName name of argument to verify + */ + /*tslint:disable-next-line */ + ErrorHelpers.verifyStringParameter = function (argumentValue, argumentName) { + if (argumentValue === null || argumentValue === undefined || argumentValue === '') { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, argumentValue + " is invalid value for paramter: " + argumentName); + } + }; + /** + * Verifies passed value is a valid value for that enum. + * Throws an InvalidParameter error if the enum value is not valid. + * + * String enums are {string : string} dictionaries which are not reverse mappable + * This is an ugly workaround + * + * @param enumValue value to verify + * @param enumType enum to verify against + * @param enumName enum name for clear error message + */ + /*tslint:disable-next-line */ + ErrorHelpers.verifyEnumValue = function (enumValue, enumType, enumName) { + var isValid = false; + Object.keys(enumType).forEach(function (enumKey) { + if (enumType[enumKey] === enumValue.toString()) { + isValid = true; + } + }); + if (!isValid) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, enumValue + " is invalid value for enum: " + enumName + "."); + } + }; + /** + * Verifies passed value is between [min, max) ... min <= value < max + * Throws an InvalidParameter error if the value is not valid. + * + * + * @param value value to verify + * @param min value must be >= min + * @param max value must be < max + */ + /*tslint:disable-next-line */ + ErrorHelpers.verifyRange = function (value, min, max) { + var isValid = min <= value && value < max; + if (!isValid) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, value + " is invalid value for range: [" + min + ".." + max + ")"); + } + }; + /** + * Verifies the params min and max for applying range filter. + * Throws with error code InvalidParameter if range is invalid. + * + * @param min range min + * @param max range max + */ + /*tslint:disable-next-line */ + ErrorHelpers.verifyRangeParamType = function (min, max) { + if (!min && !max) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, at least one of min or max is required.'); + } + if (min && !Param_1.Param.isTypeNumber(min) && !Param_1.Param.isTypeDate(min)) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, only Date and number are allowed for parameter min.'); + } + if (max && !Param_1.Param.isTypeNumber(max) && !Param_1.Param.isTypeDate(max)) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, only Date and number are allowed for parameter max.'); + } + if (min && max && typeof min !== typeof max) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, parameters min and max should be of the same type.'); + } + }; + /** + * Verifies that the zoneId is present in the current dashboard. + * Throws with error code InvalidParameter if either condition is false. + * + * @param dashboardZoneMap A map of zoneId's to the corresponding dashboard object. + * @param zoneID ZoneId to be validated + */ + ErrorHelpers.verifyZoneIsValid = function (dashboardZoneMap, zoneID) { + if (dashboardZoneMap.has(zoneID)) { + return; + } + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, "Unexpected invalid param value, Dashboard Object Id: " + zoneID + " is not present in dashboard."); + }; + /** + * Verifies that the zone is present and floating in the current dashboard. + * Throws with error code InvalidParameter if either condition is false. + * + * @param dashboardZoneMap A map of zoneId's to the corresponding dashboard object. + * @param zoneID ZoneId to be validated + */ + ErrorHelpers.verifyZoneIsValidAndFloating = function (dashboardZoneMap, zoneID) { + if (dashboardZoneMap.has(zoneID) && dashboardZoneMap.get(zoneID).isFloating) { + return; + } + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, "Unexpected invalid param value, Dashboard Object Id: " + zoneID + " is not present or is a fixed zone in the dashboard."); + }; + /** + * Verifies that width and height are > 0 for each DashboardObjectPositionAndSizeUpdate object. + * Throws with error code InvalidParameter if either condition is false. + * + * @param dashboardObjectPositionAndSizeUpdate DashboardObjectPositionAndSizeUpdate object for which width and height will be validated + */ + ErrorHelpers.verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate = function (dashboardObjectPositionAndSizeUpdate) { + if (dashboardObjectPositionAndSizeUpdate.width < 0 || dashboardObjectPositionAndSizeUpdate.height < 0) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, "Unexpected invalid param value for dashboard object ID " + dashboardObjectPositionAndSizeUpdate.dashboardObjectID + ":" + + " negative widths and heights are not allowed."); + } + }; + /** + * Verifies is the given sheet name is in the list of sheets names allowed for exporting. + * Throws with error code InvalidParameter if the condition above is false. + * + * @param exportableSheetNames A list of sheet names allowed for exporting + * @param sheetName the name of the sheet selected for export + */ + ErrorHelpers.verifySheetName = function (exportableSheetNames, sheetName) { + if (!exportableSheetNames.includes(sheetName)) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidSelectionSheet, 'sheetName parameter must belong to a worksheet within the current view'); + } + }; + /** + * Verifies the ExportDataOptions object + * Throws with error code InvalidParameter if the parameter is not of ExportDataOptions type. + * + * @param options The ExportDataOptions object used to configure the output CSV file for exportDataAsync. + */ + ErrorHelpers.verifyExportDataOptions = function (options) { + if ((!Param_1.Param.isNullOrUndefined(options.ignoreAliases) && !Param_1.Param.isTypeBool(options.ignoreAliases)) || + (!Param_1.Param.isNullOrUndefined(options.columnsToIncludeById) && !Array.isArray(options.columnsToIncludeById))) + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'options paramater must be of type ExportDataOptions'); + }; + /** + * Verifies if the sheet names are included in any of the export scenarios. + * Throws with error code InvalidParameter if the parameter is not an array. + * Throws with error code InvalidSelectionSheet if there are array entries that dont exist or if there is mixing between sheets from the dashboard and sheet from the workbook. + * + * @param sheetNames List of sheet names selected for exporting. + * @param exportScenarios an object containing the current sheet name, exportable sheets from the dashboard, and exportable sheets from the workbook. + */ + ErrorHelpers.verifySheetNamesForPDFAndPPT = function (sheetNames, exportScenarios) { + if (!Array.isArray(sheetNames)) + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'sheetNames parameter must be an array'); + if (sheetNames.length === 0) + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'sheetNames should not be empty'); + var isIncludedInDashboard = sheetNames.every(function (sheetName) { + return exportScenarios.exportableSheetNamesFromDashboard.includes(sheetName); + }); + if (isIncludedInDashboard) { + return; + } + var isIncludedInWorkbook = sheetNames.every(function (sheetName) { + return exportScenarios.exportableSheetNamesFromWorkbook.includes(sheetName); + }); + if (isIncludedInWorkbook) { + return; + } + var isCurrentSheet = sheetNames.length === 1 && sheetNames[0] === exportScenarios.currentSheetName; + if (isCurrentSheet) { + return; + } + // Export requirement: all sheet names must be included in the list of exportable sheets in the dashboard or + // all sheet names must be included in the list of exportable sheets in the workbook, or the sheet name is the current sheet + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidSelectionSheet, 'sheetNames parameter must have all its entries be exportable sheet names from the dashboard or all its entries be exportable sheet names from the workbook'); + }; + /** + * Verifies the external ExportPDFOptions object's properties. + * Throws with error code InvalidParameter if the parameter is not of external ExportPDFOptions type. + * + * @param options The external user-facing ExportPDFOptions object used to configure the output PDF file for exportPDFAsync. + */ + ErrorHelpers.verifyExportPDFOptions = function (options) { + try { + this.verifyEnumValue(options.orientation, api_external_contract_js_1.PrintOrientation, 'PrintOrientation'); + this.verifyEnumValue(options.pageSize, api_external_contract_js_1.PrintPageSize, 'PrintPageSize'); + this.verifyEnumValue(options.scaling, api_external_contract_js_1.PrintScaling, 'PrintScaling'); + } + catch (_a) { + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InvalidParameter, 'options parameter must be of type ExportPDFOptions'); + } + }; + return ErrorHelpers; +}()); +exports.ErrorHelpers = ErrorHelpers; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Utils/ExportHelpers.js": +/*!*****************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Utils/ExportHelpers.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +/** + * Helper methods for Export APIs. + * + * @class ExportHelpers + */ +var ExportHelpers = /** @class */ (function () { + function ExportHelpers() { + } + /** + * Modifies the internal ExportPDFOptions' properties based on the given PDF export configuration. + * This method will construct the internal ExportPDFOptions identically to how the 'Export PDF' dialog constructs the ExportPdfOptionsPresModel. + * See the handleExportClick method in @browser-clients/export-pdf-options-dialog for reference. + * + * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file. + * @param externalExportPdfOptions The external ExportPDFOptions user-facing object passed to exportPDFAsync. + * @param sheetNames The list of sheets selected for export. + */ + ExportHelpers.updateInternalExportPDFOptions = function (internalExportPdfOptions, externalExportPdfOptions, sheetNames) { + internalExportPdfOptions.currentSheet = sheetNames[0]; + this.updateExportLayoutOptions(internalExportPdfOptions, externalExportPdfOptions); + this.updateSheetOptions(internalExportPdfOptions, sheetNames); + }; + /** + * Helper method for updateInternalExportPDFOptions. + * Modifies the exportLayoutOptions property of the internal ExportPDFOptions based on the external ExportPDFOptions. + * See the getExportLayoutOptions method in @browser-clients/export-pdf-options-dialog for reference. + * + * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file. + * @param externalExportPdfOptions The external ExportPDFOptions user-facing object passed to exportPDFAsync. + */ + ExportHelpers.updateExportLayoutOptions = function (internalExportPdfOptions, externalExportPdfOptions) { + var exportLayoutOptions = internalExportPdfOptions.exportLayoutOptions; + // setting the image height and width properties to their default values + exportLayoutOptions.imageHeight = this.DefaultLayoutOptions.imageHeight; + exportLayoutOptions.imageWidth = this.DefaultLayoutOptions.imageWidth; + // setting the orientation value for the exportLayoutOptions + switch (externalExportPdfOptions.orientation) { + case api_external_contract_js_1.PrintOrientation.Landscape: + exportLayoutOptions.pageOrientationOption = api_internal_contract_js_1.PageOrientation.Landscape; + break; + case api_external_contract_js_1.PrintOrientation.Portrait: + exportLayoutOptions.pageOrientationOption = api_internal_contract_js_1.PageOrientation.Portrait; + break; + default: + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'invalid orientation for ExportPDFOption'); + } + // setting the page size value for the exportLayoutOptions + switch (externalExportPdfOptions.pageSize) { + case api_external_contract_js_1.PrintPageSize.A3: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.A3; + break; + case api_external_contract_js_1.PrintPageSize.A4: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.A4; + break; + case api_external_contract_js_1.PrintPageSize.A5: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.A5; + break; + case api_external_contract_js_1.PrintPageSize.B4: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.B4; + break; + case api_external_contract_js_1.PrintPageSize.B5: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.B5; + break; + case api_external_contract_js_1.PrintPageSize.Executive: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Executive; + break; + case api_external_contract_js_1.PrintPageSize.Folio: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Folio; + break; + case api_external_contract_js_1.PrintPageSize.Ledger: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Ledger; + break; + case api_external_contract_js_1.PrintPageSize.Legal: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Legal; + break; + case api_external_contract_js_1.PrintPageSize.Letter: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Letter; + break; + case api_external_contract_js_1.PrintPageSize.Note: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Note; + break; + case api_external_contract_js_1.PrintPageSize.Quarto: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Quarto; + break; + case api_external_contract_js_1.PrintPageSize.Statement: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Statement; + break; + case api_external_contract_js_1.PrintPageSize.Tabloid: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Tabloid; + break; + case api_external_contract_js_1.PrintPageSize.Unspecified: + exportLayoutOptions.pageSizeOption = api_internal_contract_js_1.PageSizeOption.Unspecified; + break; + default: + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'invalid pageSize for ExportPDFOption'); + } + // setting the scaling values for the exportLayoutOptions + switch (externalExportPdfOptions.scaling) { + case api_external_contract_js_1.PrintScaling.AtMost1PageHigh: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.FitPages.FitOneHigh); + break; + case api_external_contract_js_1.PrintScaling.AtMost1PageWide: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.FitPages.FitOneWide); + break; + case api_external_contract_js_1.PrintScaling.AtMost2PagesHigh: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.FitPages.FitTwoHigh); + break; + case api_external_contract_js_1.PrintScaling.AtMost2PagesWide: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.FitPages.FitTwoWide); + break; + case api_external_contract_js_1.PrintScaling.Automatic: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePctAuto); + break; + case api_external_contract_js_1.PrintScaling.Perc100: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct100); + break; + case api_external_contract_js_1.PrintScaling.Perc200: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct200); + break; + case api_external_contract_js_1.PrintScaling.Perc25: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct25); + break; + case api_external_contract_js_1.PrintScaling.Perc400: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct400); + break; + case api_external_contract_js_1.PrintScaling.Perc50: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct50); + break; + case api_external_contract_js_1.PrintScaling.Perc60: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct60); + break; + case api_external_contract_js_1.PrintScaling.Perc75: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct75); + break; + case api_external_contract_js_1.PrintScaling.Perc80: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct80); + break; + case api_external_contract_js_1.PrintScaling.Perc90: + this.setFitAndScaleValues(exportLayoutOptions, api_internal_contract_js_1.PageScalingOption.ScalePct90); + break; + default: + throw new TableauError_1.TableauError(api_external_contract_js_1.SharedErrorCodes.InternalError, 'invalid scaling for ExportPDFOption'); + } + }; + /** + * Helper method for updateInternalExportPDFOptions. + * Modifies the sheetOptions property of the internal ExportPDFOptions based on the sheets selected for export. + * See the handleExportClick method in @browser-clients/export-pdf-options-dialog for reference. + * + * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file. + * @param sheetNames The list of sheets selected for export. + */ + ExportHelpers.updateSheetOptions = function (internalExportPdfOptions, sheetNames) { + var exportLayoutOptions = internalExportPdfOptions.exportLayoutOptions, sheetOptions = internalExportPdfOptions.sheetOptions; + // updating the export layouts options for each sheet and selecting sheet for export if included in list + for (var _i = 0, sheetOptions_1 = sheetOptions; _i < sheetOptions_1.length; _i++) { + var sheetOption = sheetOptions_1[_i]; + sheetOption.exportLayoutOptions = exportLayoutOptions; + sheetOption.isSelected = sheetNames.includes(sheetOption.sheet); + } + }; + /** + * Helper method for updateExportLayoutOptons. + * This method is a spoof of the getFitAndScaleValues method used in @browser-clients/export-pdf-options to set the exportLayoutOptions' scaling properties. + * In the future, this file should be refactored to import the method directly from @browser-clients/export-pdf-options. + * + * @param scalingSelection string used for setting the exportLayoutOptions based on the PrintScaling property from the ExternalExportPDFOptions. + * @param exportLayoutOptions the ExportLayoutOptions used by the internal ExportPDFOptions pres model. + */ + ExportHelpers.setFitAndScaleValues = function (exportLayoutOptions, scalingSelection) { + var _a; + var _b = this.DefaultLayoutOptions, pageFitHorizontal = _b.pageFitHorizontal, pageFitVertical = _b.pageFitVertical, pageScaleMode = _b.pageScaleMode, pageScalePercent = _b.pageScalePercent; + var fitMatch = this.fitRegex.exec(scalingSelection); + var percentMatch = this.pctRegex.exec(scalingSelection); + if (fitMatch) { + _a = fitMatch.slice(1).map(function (value) { return Number(value); }), pageFitHorizontal = _a[0], pageFitVertical = _a[1]; + pageScaleMode = api_internal_contract_js_1.ScaleMode.ScaleFitPages; + } + else if (percentMatch) { + pageScalePercent = percentMatch.slice(1).map(function (value) { return Number(value); })[0]; + pageScaleMode = api_internal_contract_js_1.ScaleMode.ScalePercentage; + } + // getFitAndScaleValues returns the properties below, but instead this method will set them. + exportLayoutOptions.pageFitHorizontal = pageFitHorizontal; + exportLayoutOptions.pageFitVertical = pageFitVertical; + exportLayoutOptions.pageScaleMode = pageScaleMode; + exportLayoutOptions.pageScalePercent = pageScalePercent; + }; + ExportHelpers.DefaultDataOptions = { + ignoreAliases: false, + columnsToIncludeById: [], + }; + ExportHelpers.DefaultPDFOptions = { + scaling: api_external_contract_js_1.PrintScaling.Automatic, + pageSize: api_external_contract_js_1.PrintPageSize.Letter, + orientation: api_external_contract_js_1.PrintOrientation.Portrait, + }; + ExportHelpers.DefaultLayoutOptions = { + imageHeight: 0, + imageWidth: 0, + pageFitHorizontal: 1, + pageFitVertical: 1, + pageOrientationOption: api_internal_contract_js_1.PageOrientation.Portrait, + pageScaleMode: api_internal_contract_js_1.ScaleMode.ScaleAuto, + pageScalePercent: 100, + pageSizeOption: api_internal_contract_js_1.PageSizeOption.Letter, + }; + ExportHelpers.fitRegex = new RegExp('fit([0-9]+)x([0-9]+)'); + ExportHelpers.pctRegex = new RegExp('pct([0-9]+)'); + return ExportHelpers; +}()); +exports.ExportHelpers = ExportHelpers; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Utils/Param.js": +/*!*********************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Utils/Param.js ***! + \*********************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var ErrorHelpers_1 = __webpack_require__(/*! ./ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); +var Param = /** @class */ (function () { + function Param() { + } + /** + * serializes the date into the format that the server expects. + * @param date the date to serialize + */ + Param.serializeDateForPlatform = function (date) { + var year = date.getUTCFullYear(); + var month = date.getUTCMonth() + 1; + var day = date.getUTCDate(); + var hh = date.getUTCHours(); + var mm = date.getUTCMinutes(); + var sec = date.getUTCSeconds(); + return year + "-" + month + "-" + day + " " + hh + ":" + mm + ":" + sec; + }; + Param.serializeBooleanForPlatform = function (bool) { + return bool ? 'true' : 'false'; + }; + Param.serializeNumberForPlatform = function (num) { + return num.toString(10); + }; + /** + * Verifies the input is a number + */ + /* tslint:disable-next-line:no-any */ + Param.isTypeNumber = function (input) { + return typeof input === 'number' || input instanceof Number; + }; + /** + * Verifies the input is a Date + */ + /* tslint:disable-next-line:no-any */ + Param.isTypeDate = function (input) { + return input instanceof Date; + }; + /* tslint:disable-next-line:no-any */ + Param.isTypeString = function (input) { + return typeof input === 'string' || input instanceof String; + }; + /* tslint:disable-next-line:no-any */ + Param.isTypeBool = function (input) { + return typeof input === 'boolean' || input instanceof Boolean; + }; + /** + * Determines if the input is null or undefined + */ + /* tslint:disable-next-line:no-any */ + Param.isNullOrUndefined = function (input) { + return input === null || input === undefined; + }; + /* tslint:disable-next-line:no-any */ + Param.serializeParameterValue = function (value) { + if (Param.isTypeNumber(value)) { + return Param.serializeNumberForPlatform(value); + } + else if (Param.isTypeDate(value)) { + return Param.serializeDateForPlatform(value); + } + else if (Param.isTypeBool(value)) { + return Param.serializeBooleanForPlatform(value); + } + else if (Param.isTypeString(value)) { + return value; + } + else { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, "Unexpected invalid value for: " + value); + } + }; + /** + * Verifies that the parameter is already a Map, or converts an object to a Map. + * If the parameter is an object, we convert it to a Map using Object.entries. + * @throws if the parameter is not an object or Map + */ + // tslint:disable-next-line:no-any + Param.convertParameterToMap = function (param, paramName) { + ErrorHelpers_1.ErrorHelpers.verifyParameterType(param, 'object', paramName); + if (Array.isArray(param)) { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InvalidParameter, "Expecting object or Map for: " + paramName + "."); + } + return param instanceof Map ? param : new Map(Object.entries(param)); + }; + /* tslint:disable-next-line:no-any */ + Param.tryParseNumber = function (value) { + if (Param.isNullOrUndefined(value)) { + return { success: false }; + } + if (Param.isTypeNumber(value)) { + return { parsed: value, success: true }; + } + var valueString = value.toString(); + if (valueString === 'NaN') { + // 'NaN' parses as NaN which is indistinguishable from a failed parse. + return { parsed: NaN, success: true }; + } + var parsed = parseFloat(valueString); + if (isNaN(parsed)) { + return { success: false }; + } + return { parsed: parsed, success: true }; + }; + return Param; +}()); +exports.Param = Param; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Utils/SheetUtils.js": +/*!**************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Utils/SheetUtils.js ***! + \**************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var SheetUtils = /** @class */ (function () { + function SheetUtils() { + } + // This is a direct port from SheetSize.cs - SheetSizeFactory + SheetUtils.getSheetSizeFromSizeConstraints = function (sizeConstraint) { + var minWidth = sizeConstraint.minWidth, minHeight = sizeConstraint.minHeight, maxWidth = sizeConstraint.maxWidth, maxHeight = sizeConstraint.maxHeight; + if (minHeight === 0 && minWidth === 0) { + if (maxHeight === 0 && maxWidth === 0) { + return { + behavior: Contract.SheetSizeBehavior.Automatic, + }; + } + return { + behavior: Contract.SheetSizeBehavior.AtMost, + maxSize: { width: maxWidth, height: maxHeight }, + }; + } + if (maxHeight === 0 && maxWidth === 0) { + return { + behavior: Contract.SheetSizeBehavior.AtLeast, + minSize: { width: minWidth, height: minHeight }, + }; + } + if (maxHeight === minHeight && maxWidth === minWidth && minWidth > 0) { + return { + behavior: Contract.SheetSizeBehavior.Exactly, + minSize: { width: minWidth, height: minHeight }, + maxSize: { width: minWidth, height: minHeight }, + }; + } + // 'Fit Width' for a DSD layout + var isDsdLayout = minWidth === 0 && maxWidth === 0; + return { + behavior: Contract.SheetSizeBehavior.Range, + minSize: { width: minWidth, height: minHeight }, + maxSize: { width: isDsdLayout ? 2147483647 : maxWidth, height: maxHeight }, + }; + }; + SheetUtils.createAutomaticSize = function () { + var behavior = Contract.SheetSizeBehavior.Automatic; + var minSize = { width: 0, height: 0 }; + var maxSize = { width: 0, height: 0 }; + return { behavior: behavior, minSize: minSize, maxSize: maxSize }; + }; + SheetUtils.getPublishedSheetInfoByName = function (name, sheetInfos) { + var sheetInfo = sheetInfos.find(function (sheet) { return sheet.name === name; }); + return sheetInfo; + }; + SheetUtils.getSheetTypeEnum = function (internalSheetType) { + var sheetType; + switch (internalSheetType) { + case api_internal_contract_js_1.SheetType.Worksheet: { + sheetType = Contract.SheetType.Worksheet; + break; + } + case api_internal_contract_js_1.SheetType.Dashboard: { + sheetType = Contract.SheetType.Dashboard; + break; + } + case api_internal_contract_js_1.SheetType.Story: { + sheetType = Contract.SheetType.Story; + break; + } + default: { + throw new TableauError_1.TableauError(Contract.SharedErrorCodes.ServerError, 'Invalid SheetType'); + } + } + return sheetType; + }; + SheetUtils.isValidSheetSize = function (sizeObject) { + return sizeObject.behavior !== undefined; + }; + return SheetUtils; +}()); +exports.SheetUtils = SheetUtils; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Utils/ShortLivedDeferred.js": +/*!**********************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Utils/ShortLivedDeferred.js ***! + \**********************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var TableauError_1 = __webpack_require__(/*! ../TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +var Deferred_1 = __webpack_require__(/*! ./Deferred */ "../api-shared-js/lib/src/ApiShared/Utils/Deferred.js"); +/** + * A Deferred wrapper class adding functionality to reject unresponsive promises after timeout + * + * this class handles two things: + + * 1. Adds timeout logic for deferred + * 2. It blocks multiple calls from executing at the same time. + * + * @export + * @class ShortLivedDeferred + * @template TResolve The type used to resolve the promise. + * @template TReject The type used to reject the promise. Defaults to any. + * + */ +var ShortLivedDeferred = /** @class */ (function () { + function ShortLivedDeferred(_timeoutInMilliseconds) { + if (_timeoutInMilliseconds === void 0) { _timeoutInMilliseconds = Deferred_1.UnregisterTimeoutInMilliseconds; } + this._timeoutInMilliseconds = _timeoutInMilliseconds; + } + ShortLivedDeferred.prototype.getNewPromiseOrThrowIfBusy = function () { + var _this = this; + if (this._deferred) { + throw new TableauError_1.TableauError(Contract.SharedErrorCodes.ApiExecutionError, 'This api cannot be executed till previous call is resolved.'); + } + this._deferred = new Deferred_1.Deferred(); + this._timeoutId = setTimeout(function () { + var error = new TableauError_1.TableauError(Contract.SharedErrorCodes.Timeout, "Api failed to complete in " + _this._timeoutInMilliseconds / 1000 + " seconds"); + _this.reject(error); + }, this._timeoutInMilliseconds); + return this._deferred.promise; + }; + ShortLivedDeferred.prototype.resolve = function (response) { + if (this._deferred) { + clearTimeout(this._timeoutId); + this._deferred.resolve(response); + this._deferred = undefined; + } + }; + ShortLivedDeferred.prototype.reject = function (error) { + if (this._deferred) { + clearTimeout(this._timeoutId); + this._deferred.reject(error); + this._deferred = undefined; + } + }; + return ShortLivedDeferred; +}()); +exports.ShortLivedDeferred = ShortLivedDeferred; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/VersionNumber.js": +/*!***********************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/VersionNumber.js ***! + \***********************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var TableauError_1 = __webpack_require__(/*! ./TableauError */ "../api-shared-js/lib/src/ApiShared/TableauError.js"); +/** + * Represents the current version of the extensions, embedding + * and extensions-api-types library + */ +var VersionNumber = /** @class */ (function () { + // private constructor so everyone uses the singleton instance + // build numbers have this form: M.m.f-pre.N + function VersionNumber(versionString, isAlpha) { + var partStr = versionString.split('-'); + this.build = this.getBuildNumber(partStr[1]); + versionString = partStr[0]; + var parts = versionString.split('.').map(function (p) { return parseInt(p, 10); }); + if (parts.length !== 3) { + throw new TableauError_1.TableauError(api_external_contract_js_1.ErrorCodes.InternalError, "Invalid version number: " + versionString); + } + this.major = parts[0]; + this.minor = parts[1]; + this.fix = parts[2]; + this.isAlpha = isAlpha; + } + VersionNumber.prototype.getBuildNumber = function (preReleaseString) { + var noBuildNumber = -1; + if (!preReleaseString) { + return noBuildNumber; + } + // The preRelease string has this form: pre.N, but we don't depend on the actual string being 'pre' + var partStr = preReleaseString.split('.'); + return partStr[1] ? parseInt(partStr[1], 10) : noBuildNumber; + }; + Object.defineProperty(VersionNumber.prototype, "formattedValue", { + get: function () { + return this.major + "." + this.minor + "." + this.fix; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(VersionNumber.prototype, "fullFormattedValue", { + get: function () { + return this.major + "." + this.minor + "." + this.fix + "-pre." + this.build; + }, + enumerable: true, + configurable: true + }); + return VersionNumber; +}()); +exports.VersionNumber = VersionNumber; + + +/***/ }), + +/***/ "../api-shared-js/lib/src/VersionedExternalApiDispatcher.js": +/*!******************************************************************!*\ + !*** ../api-shared-js/lib/src/VersionedExternalApiDispatcher.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, exports, __webpack_require__) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +/** + * Implementation of the InternalApiDispatcher which supports upgrading and downgrading the input + * internal contract to the version that this module is built against + * + * @class VersionedExternalApiDispatcher + * @implements {InternalApiDispatcher} + */ +var VersionedExternalApiDispatcher = /** @class */ (function () { + /** + * Creates a new instance of the VersionedExternalApiDispatcher + * We have multiple version converting dispatchers that work together. + * If needed, the VersionedExternalApiDispatcher wraps either the InternalApiDispatcher (desktop) + * or the CrossFrameDispatcher (server). + * The Internal/CrossFrame dispatchers handle an updated platform with an older external library. + * (The CrossFrameDispatcher sends messages across the frame, and it is handled by the PresLayerHandler.) + * Meanwhile, the VersionedExternalApiDispatcher handles an updated external library with an older platform. + + * @param _apiDelegateDispatcher The delegate that does the actual work. + * @param platformVersionNumber The version of the internal contract which the platform module is using. + * This number will be used to figure out how to downgrade incoming commands and upgrade the results + */ + function VersionedExternalApiDispatcher(_apiDelegateDispatcher, platformVersionNumber) { + var _this = this; + this._apiDelegateDispatcher = _apiDelegateDispatcher; + this._versionConverter = api_internal_contract_js_1.CreateExternalCompatibleVersionConverter(api_internal_contract_js_1.INTERNAL_CONTRACT_VERSION, platformVersionNumber); + this._notificationHandlers = []; + _apiDelegateDispatcher.registerNotificationHandler(function (notification) { + if (_this._notificationHandlers.length === 0) { + return; + } + var upgradedNotification = _this._versionConverter.upgradeNotification(notification); + _this._notificationHandlers.forEach(function (handler) { + handler(upgradedNotification); + }); + }); + } + VersionedExternalApiDispatcher.needsVersionConverter = function (platformVersion) { + // If our platform is less than external library version, then we need a converter + return api_internal_contract_js_1.VersionLessThan(platformVersion, api_internal_contract_js_1.INTERNAL_CONTRACT_VERSION); + }; + VersionedExternalApiDispatcher.prototype.execute = function (verb, parameters) { + var _this = this; + try { + var downgradeParameters = this._versionConverter.downgradeExecuteCall(verb, parameters); + return this._apiDelegateDispatcher.execute(downgradeParameters.verb, downgradeParameters.parameters).then(function (response) { + var upgradeResponse = _this._versionConverter.upgradeExecuteReturn(response, verb, parameters); + return upgradeResponse; + }); + } + catch (e) { + return Promise.reject(e); + } + }; + VersionedExternalApiDispatcher.prototype.registerNotificationHandler = function (handler) { + this._notificationHandlers.push(handler); + }; + VersionedExternalApiDispatcher.prototype.unregisterNotificationHandler = function (handler) { + this._notificationHandlers = this._notificationHandlers.filter(function (h) { return h !== handler; }); + }; + return VersionedExternalApiDispatcher; +}()); +exports.VersionedExternalApiDispatcher = VersionedExternalApiDispatcher; + + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/index.js": +/*!********************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/index.js ***! + \********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ NIL: () => (/* reexport safe */ _nil_js__WEBPACK_IMPORTED_MODULE_4__["default"]), +/* harmony export */ parse: () => (/* reexport safe */ _parse_js__WEBPACK_IMPORTED_MODULE_8__["default"]), +/* harmony export */ stringify: () => (/* reexport safe */ _stringify_js__WEBPACK_IMPORTED_MODULE_7__["default"]), +/* harmony export */ v1: () => (/* reexport safe */ _v1_js__WEBPACK_IMPORTED_MODULE_0__["default"]), +/* harmony export */ v3: () => (/* reexport safe */ _v3_js__WEBPACK_IMPORTED_MODULE_1__["default"]), +/* harmony export */ v4: () => (/* reexport safe */ _v4_js__WEBPACK_IMPORTED_MODULE_2__["default"]), +/* harmony export */ v5: () => (/* reexport safe */ _v5_js__WEBPACK_IMPORTED_MODULE_3__["default"]), +/* harmony export */ validate: () => (/* reexport safe */ _validate_js__WEBPACK_IMPORTED_MODULE_6__["default"]), +/* harmony export */ version: () => (/* reexport safe */ _version_js__WEBPACK_IMPORTED_MODULE_5__["default"]) +/* harmony export */ }); +/* harmony import */ var _v1_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./v1.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/v1.js"); +/* harmony import */ var _v3_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./v3.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/v3.js"); +/* harmony import */ var _v4_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./v4.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/v4.js"); +/* harmony import */ var _v5_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./v5.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/v5.js"); +/* harmony import */ var _nil_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./nil.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/nil.js"); +/* harmony import */ var _version_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./version.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/version.js"); +/* harmony import */ var _validate_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./validate.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/validate.js"); +/* harmony import */ var _stringify_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./stringify.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js"); +/* harmony import */ var _parse_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./parse.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/parse.js"); + + + + + + + + + + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/md5.js": +/*!******************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/md5.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* + * Browser-compatible JavaScript MD5 + * + * Modification of JavaScript MD5 + * https://github.com/blueimp/JavaScript-MD5 + * + * Copyright 2011, Sebastian Tschan + * https://blueimp.net + * + * Licensed under the MIT license: + * https://opensource.org/licenses/MIT + * + * Based on + * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message + * Digest Algorithm, as defined in RFC 1321. + * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009 + * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet + * Distributed under the BSD License + * See http://pajhome.org.uk/crypt/md5 for more info. + */ +function md5(bytes) { + if (typeof bytes === 'string') { + var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape + + bytes = new Uint8Array(msg.length); + + for (var i = 0; i < msg.length; ++i) { + bytes[i] = msg.charCodeAt(i); + } + } + + return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8)); +} +/* + * Convert an array of little-endian words to an array of bytes + */ + + +function md5ToHexEncodedArray(input) { + var output = []; + var length32 = input.length * 32; + var hexTab = '0123456789abcdef'; + + for (var i = 0; i < length32; i += 8) { + var x = input[i >> 5] >>> i % 32 & 0xff; + var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16); + output.push(hex); + } + + return output; +} +/** + * Calculate output length with padding and bit length + */ + + +function getOutputLength(inputLength8) { + return (inputLength8 + 64 >>> 9 << 4) + 14 + 1; +} +/* + * Calculate the MD5 of an array of little-endian words, and a bit length. + */ + + +function wordsToMd5(x, len) { + /* append padding */ + x[len >> 5] |= 0x80 << len % 32; + x[getOutputLength(len) - 1] = len; + var a = 1732584193; + var b = -271733879; + var c = -1732584194; + var d = 271733878; + + for (var i = 0; i < x.length; i += 16) { + var olda = a; + var oldb = b; + var oldc = c; + var oldd = d; + a = md5ff(a, b, c, d, x[i], 7, -680876936); + d = md5ff(d, a, b, c, x[i + 1], 12, -389564586); + c = md5ff(c, d, a, b, x[i + 2], 17, 606105819); + b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330); + a = md5ff(a, b, c, d, x[i + 4], 7, -176418897); + d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426); + c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341); + b = md5ff(b, c, d, a, x[i + 7], 22, -45705983); + a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416); + d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417); + c = md5ff(c, d, a, b, x[i + 10], 17, -42063); + b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162); + a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682); + d = md5ff(d, a, b, c, x[i + 13], 12, -40341101); + c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290); + b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329); + a = md5gg(a, b, c, d, x[i + 1], 5, -165796510); + d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632); + c = md5gg(c, d, a, b, x[i + 11], 14, 643717713); + b = md5gg(b, c, d, a, x[i], 20, -373897302); + a = md5gg(a, b, c, d, x[i + 5], 5, -701558691); + d = md5gg(d, a, b, c, x[i + 10], 9, 38016083); + c = md5gg(c, d, a, b, x[i + 15], 14, -660478335); + b = md5gg(b, c, d, a, x[i + 4], 20, -405537848); + a = md5gg(a, b, c, d, x[i + 9], 5, 568446438); + d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690); + c = md5gg(c, d, a, b, x[i + 3], 14, -187363961); + b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501); + a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467); + d = md5gg(d, a, b, c, x[i + 2], 9, -51403784); + c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473); + b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734); + a = md5hh(a, b, c, d, x[i + 5], 4, -378558); + d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463); + c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562); + b = md5hh(b, c, d, a, x[i + 14], 23, -35309556); + a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060); + d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353); + c = md5hh(c, d, a, b, x[i + 7], 16, -155497632); + b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640); + a = md5hh(a, b, c, d, x[i + 13], 4, 681279174); + d = md5hh(d, a, b, c, x[i], 11, -358537222); + c = md5hh(c, d, a, b, x[i + 3], 16, -722521979); + b = md5hh(b, c, d, a, x[i + 6], 23, 76029189); + a = md5hh(a, b, c, d, x[i + 9], 4, -640364487); + d = md5hh(d, a, b, c, x[i + 12], 11, -421815835); + c = md5hh(c, d, a, b, x[i + 15], 16, 530742520); + b = md5hh(b, c, d, a, x[i + 2], 23, -995338651); + a = md5ii(a, b, c, d, x[i], 6, -198630844); + d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415); + c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905); + b = md5ii(b, c, d, a, x[i + 5], 21, -57434055); + a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571); + d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606); + c = md5ii(c, d, a, b, x[i + 10], 15, -1051523); + b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799); + a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359); + d = md5ii(d, a, b, c, x[i + 15], 10, -30611744); + c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380); + b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649); + a = md5ii(a, b, c, d, x[i + 4], 6, -145523070); + d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379); + c = md5ii(c, d, a, b, x[i + 2], 15, 718787259); + b = md5ii(b, c, d, a, x[i + 9], 21, -343485551); + a = safeAdd(a, olda); + b = safeAdd(b, oldb); + c = safeAdd(c, oldc); + d = safeAdd(d, oldd); + } + + return [a, b, c, d]; +} +/* + * Convert an array bytes to an array of little-endian words + * Characters >255 have their high-byte silently ignored. + */ + + +function bytesToWords(input) { + if (input.length === 0) { + return []; + } + + var length8 = input.length * 8; + var output = new Uint32Array(getOutputLength(length8)); + + for (var i = 0; i < length8; i += 8) { + output[i >> 5] |= (input[i / 8] & 0xff) << i % 32; + } + + return output; +} +/* + * Add integers, wrapping at 2^32. This uses 16-bit operations internally + * to work around bugs in some JS interpreters. + */ + + +function safeAdd(x, y) { + var lsw = (x & 0xffff) + (y & 0xffff); + var msw = (x >> 16) + (y >> 16) + (lsw >> 16); + return msw << 16 | lsw & 0xffff; +} +/* + * Bitwise rotate a 32-bit number to the left. + */ + + +function bitRotateLeft(num, cnt) { + return num << cnt | num >>> 32 - cnt; +} +/* + * These functions implement the four basic operations the algorithm uses. + */ + + +function md5cmn(q, a, b, x, s, t) { + return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b); +} + +function md5ff(a, b, c, d, x, s, t) { + return md5cmn(b & c | ~b & d, a, b, x, s, t); +} + +function md5gg(a, b, c, d, x, s, t) { + return md5cmn(b & d | c & ~d, a, b, x, s, t); +} + +function md5hh(a, b, c, d, x, s, t) { + return md5cmn(b ^ c ^ d, a, b, x, s, t); +} + +function md5ii(a, b, c, d, x, s, t) { + return md5cmn(c ^ (b | ~d), a, b, x, s, t); +} + +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (md5); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/nil.js": +/*!******************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/nil.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ('00000000-0000-0000-0000-000000000000'); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/parse.js": +/*!********************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/parse.js ***! + \********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _validate_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./validate.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/validate.js"); + + +function parse(uuid) { + if (!(0,_validate_js__WEBPACK_IMPORTED_MODULE_0__["default"])(uuid)) { + throw TypeError('Invalid UUID'); + } + + var v; + var arr = new Uint8Array(16); // Parse ########-....-....-....-............ + + arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24; + arr[1] = v >>> 16 & 0xff; + arr[2] = v >>> 8 & 0xff; + arr[3] = v & 0xff; // Parse ........-####-....-....-............ + + arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8; + arr[5] = v & 0xff; // Parse ........-....-####-....-............ + + arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8; + arr[7] = v & 0xff; // Parse ........-....-....-####-............ + + arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8; + arr[9] = v & 0xff; // Parse ........-....-....-....-############ + // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes) + + arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff; + arr[11] = v / 0x100000000 & 0xff; + arr[12] = v >>> 24 & 0xff; + arr[13] = v >>> 16 & 0xff; + arr[14] = v >>> 8 & 0xff; + arr[15] = v & 0xff; + return arr; +} + +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (parse); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/regex.js": +/*!********************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/regex.js ***! + \********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/rng.js": +/*!******************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/rng.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (/* binding */ rng) +/* harmony export */ }); +// Unique ID creation requires a high quality random # generator. In the browser we therefore +// require the crypto API and do not support built-in fallback to lower quality random number +// generators (like Math.random()). +var getRandomValues; +var rnds8 = new Uint8Array(16); +function rng() { + // lazy load so that environments that need to polyfill have a chance to do so + if (!getRandomValues) { + // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also, + // find the complete implementation of crypto (msCrypto) on IE11. + getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto); + + if (!getRandomValues) { + throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported'); + } + } + + return getRandomValues(rnds8); +} + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/sha1.js": +/*!*******************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/sha1.js ***! + \*******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +// Adapted from Chris Veness' SHA1 code at +// http://www.movable-type.co.uk/scripts/sha1.html +function f(s, x, y, z) { + switch (s) { + case 0: + return x & y ^ ~x & z; + + case 1: + return x ^ y ^ z; + + case 2: + return x & y ^ x & z ^ y & z; + + case 3: + return x ^ y ^ z; + } +} + +function ROTL(x, n) { + return x << n | x >>> 32 - n; +} + +function sha1(bytes) { + var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]; + var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0]; + + if (typeof bytes === 'string') { + var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape + + bytes = []; + + for (var i = 0; i < msg.length; ++i) { + bytes.push(msg.charCodeAt(i)); + } + } else if (!Array.isArray(bytes)) { + // Convert Array-like to Array + bytes = Array.prototype.slice.call(bytes); + } + + bytes.push(0x80); + var l = bytes.length / 4 + 2; + var N = Math.ceil(l / 16); + var M = new Array(N); + + for (var _i = 0; _i < N; ++_i) { + var arr = new Uint32Array(16); + + for (var j = 0; j < 16; ++j) { + arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3]; + } + + M[_i] = arr; + } + + M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32); + M[N - 1][14] = Math.floor(M[N - 1][14]); + M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff; + + for (var _i2 = 0; _i2 < N; ++_i2) { + var W = new Uint32Array(80); + + for (var t = 0; t < 16; ++t) { + W[t] = M[_i2][t]; + } + + for (var _t = 16; _t < 80; ++_t) { + W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1); + } + + var a = H[0]; + var b = H[1]; + var c = H[2]; + var d = H[3]; + var e = H[4]; + + for (var _t2 = 0; _t2 < 80; ++_t2) { + var s = Math.floor(_t2 / 20); + var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0; + e = d; + d = c; + c = ROTL(b, 30) >>> 0; + b = a; + a = T; + } + + H[0] = H[0] + a >>> 0; + H[1] = H[1] + b >>> 0; + H[2] = H[2] + c >>> 0; + H[3] = H[3] + d >>> 0; + H[4] = H[4] + e >>> 0; + } + + return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff]; +} + +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (sha1); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js": +/*!************************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js ***! + \************************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _validate_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./validate.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/validate.js"); + +/** + * Convert array of 16 byte values to UUID string format of the form: + * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX + */ + +var byteToHex = []; + +for (var i = 0; i < 256; ++i) { + byteToHex.push((i + 0x100).toString(16).substr(1)); +} + +function stringify(arr) { + var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + // Note: Be careful editing this code! It's been tuned for performance + // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434 + var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one + // of the following: + // - One or more input array values don't map to a hex octet (leading to + // "undefined" in the uuid) + // - Invalid input values for the RFC `version` or `variant` fields + + if (!(0,_validate_js__WEBPACK_IMPORTED_MODULE_0__["default"])(uuid)) { + throw TypeError('Stringified UUID is invalid'); + } + + return uuid; +} + +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (stringify); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/v1.js": +/*!*****************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/v1.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _rng_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./rng.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/rng.js"); +/* harmony import */ var _stringify_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./stringify.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js"); + + // **`v1()` - Generate time-based UUID** +// +// Inspired by https://github.com/LiosK/UUID.js +// and http://docs.python.org/library/uuid.html + +var _nodeId; + +var _clockseq; // Previous uuid creation time + + +var _lastMSecs = 0; +var _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details + +function v1(options, buf, offset) { + var i = buf && offset || 0; + var b = buf || new Array(16); + options = options || {}; + var node = options.node || _nodeId; + var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not + // specified. We do this lazily to minimize issues related to insufficient + // system entropy. See #189 + + if (node == null || clockseq == null) { + var seedBytes = options.random || (options.rng || _rng_js__WEBPACK_IMPORTED_MODULE_0__["default"])(); + + if (node == null) { + // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) + node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]]; + } + + if (clockseq == null) { + // Per 4.2.2, randomize (14 bit) clockseq + clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff; + } + } // UUID timestamps are 100 nano-second units since the Gregorian epoch, + // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so + // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' + // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. + + + var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock + // cycle to simulate higher resolution clock + + var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs) + + var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression + + if (dt < 0 && options.clockseq === undefined) { + clockseq = clockseq + 1 & 0x3fff; + } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new + // time interval + + + if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) { + nsecs = 0; + } // Per 4.2.1.2 Throw error if too many uuids are requested + + + if (nsecs >= 10000) { + throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); + } + + _lastMSecs = msecs; + _lastNSecs = nsecs; + _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch + + msecs += 12219292800000; // `time_low` + + var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; + b[i++] = tl >>> 24 & 0xff; + b[i++] = tl >>> 16 & 0xff; + b[i++] = tl >>> 8 & 0xff; + b[i++] = tl & 0xff; // `time_mid` + + var tmh = msecs / 0x100000000 * 10000 & 0xfffffff; + b[i++] = tmh >>> 8 & 0xff; + b[i++] = tmh & 0xff; // `time_high_and_version` + + b[i++] = tmh >>> 24 & 0xf | 0x10; // include version + + b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) + + b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low` + + b[i++] = clockseq & 0xff; // `node` + + for (var n = 0; n < 6; ++n) { + b[i + n] = node[n]; + } + + return buf || (0,_stringify_js__WEBPACK_IMPORTED_MODULE_1__["default"])(b); +} + +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (v1); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/v3.js": +/*!*****************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/v3.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _v35_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./v35.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/v35.js"); +/* harmony import */ var _md5_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./md5.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/md5.js"); + + +var v3 = (0,_v35_js__WEBPACK_IMPORTED_MODULE_0__["default"])('v3', 0x30, _md5_js__WEBPACK_IMPORTED_MODULE_1__["default"]); +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (v3); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/v35.js": +/*!******************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/v35.js ***! + \******************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ DNS: () => (/* binding */ DNS), +/* harmony export */ URL: () => (/* binding */ URL), +/* harmony export */ "default": () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _stringify_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./stringify.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js"); +/* harmony import */ var _parse_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./parse.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/parse.js"); + + + +function stringToBytes(str) { + str = unescape(encodeURIComponent(str)); // UTF8 escape + + var bytes = []; + + for (var i = 0; i < str.length; ++i) { + bytes.push(str.charCodeAt(i)); + } + + return bytes; +} + +var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8'; +var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8'; +/* harmony default export */ function __WEBPACK_DEFAULT_EXPORT__(name, version, hashfunc) { + function generateUUID(value, namespace, buf, offset) { + if (typeof value === 'string') { + value = stringToBytes(value); + } + + if (typeof namespace === 'string') { + namespace = (0,_parse_js__WEBPACK_IMPORTED_MODULE_0__["default"])(namespace); + } + + if (namespace.length !== 16) { + throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)'); + } // Compute hash of namespace and value, Per 4.3 + // Future: Use spread syntax when supported on all platforms, e.g. `bytes = + // hashfunc([...namespace, ... value])` + + + var bytes = new Uint8Array(16 + value.length); + bytes.set(namespace); + bytes.set(value, namespace.length); + bytes = hashfunc(bytes); + bytes[6] = bytes[6] & 0x0f | version; + bytes[8] = bytes[8] & 0x3f | 0x80; + + if (buf) { + offset = offset || 0; + + for (var i = 0; i < 16; ++i) { + buf[offset + i] = bytes[i]; + } + + return buf; + } + + return (0,_stringify_js__WEBPACK_IMPORTED_MODULE_1__["default"])(bytes); + } // Function#name is not settable on some platforms (#270) + + + try { + generateUUID.name = name; // eslint-disable-next-line no-empty + } catch (err) {} // For CommonJS default export support + + + generateUUID.DNS = DNS; + generateUUID.URL = URL; + return generateUUID; +} + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/v4.js": +/*!*****************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/v4.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _rng_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./rng.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/rng.js"); +/* harmony import */ var _stringify_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./stringify.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js"); + + + +function v4(options, buf, offset) { + options = options || {}; + var rnds = options.random || (options.rng || _rng_js__WEBPACK_IMPORTED_MODULE_0__["default"])(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved` + + rnds[6] = rnds[6] & 0x0f | 0x40; + rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided + + if (buf) { + offset = offset || 0; + + for (var i = 0; i < 16; ++i) { + buf[offset + i] = rnds[i]; + } + + return buf; + } + + return (0,_stringify_js__WEBPACK_IMPORTED_MODULE_1__["default"])(rnds); +} + +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (v4); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/v5.js": +/*!*****************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/v5.js ***! + \*****************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _v35_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./v35.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/v35.js"); +/* harmony import */ var _sha1_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./sha1.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/sha1.js"); + + +var v5 = (0,_v35_js__WEBPACK_IMPORTED_MODULE_0__["default"])('v5', 0x50, _sha1_js__WEBPACK_IMPORTED_MODULE_1__["default"]); +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (v5); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/validate.js": +/*!***********************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/validate.js ***! + \***********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _regex_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./regex.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/regex.js"); + + +function validate(uuid) { + return typeof uuid === 'string' && _regex_js__WEBPACK_IMPORTED_MODULE_0__["default"].test(uuid); +} + +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (validate); + +/***/ }), + +/***/ "../api-shared-js/node_modules/uuid/dist/esm-browser/version.js": +/*!**********************************************************************!*\ + !*** ../api-shared-js/node_modules/uuid/dist/esm-browser/version.js ***! + \**********************************************************************/ +/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) +/* harmony export */ }); +/* harmony import */ var _validate_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./validate.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/validate.js"); + + +function version(uuid) { + if (!(0,_validate_js__WEBPACK_IMPORTED_MODULE_0__["default"])(uuid)) { + throw TypeError('Invalid UUID'); + } + + return parseInt(uuid.substr(14, 1), 16); +} + +/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (version); + +/***/ }), + +/***/ "../api-internal-contract-js/lib/internal-contract-version.json": +/*!**********************************************************************!*\ + !*** ../api-internal-contract-js/lib/internal-contract-version.json ***! + \**********************************************************************/ +/***/ ((module) => { + +"use strict"; +module.exports = /*#__PURE__*/JSON.parse('{"major":1,"minor":162,"fix":0}'); + +/***/ }) + +/******/ }); +/************************************************************************/ +/******/ // 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"; +var exports = __webpack_exports__; +/*!**********************************!*\ + !*** ./lib/src/ExtensionsApi.js ***! + \**********************************/ + +/** + * This is your main. This is where you re-export everything you want to be publicly available. + * + * The build enforces that the file has the same name as the global variable that is exported. + */ +Object.defineProperty(exports, "__esModule", ({ value: true })); +// The following polyfills are needed for IE11 +var api_shared_js_1 = __webpack_require__(/*! @tableau/api-shared-js */ "../api-shared-js/lib/src/ApiShared.js"); +__webpack_require__(/*! core-js/es/array/find */ "../../node_modules/core-js/es/array/find.js"); +__webpack_require__(/*! core-js/es/array/from */ "../../node_modules/core-js/es/array/from.js"); +__webpack_require__(/*! core-js/es/map */ "../../node_modules/core-js/es/map/index.js"); +__webpack_require__(/*! core-js/es/number/is-integer */ "../../node_modules/core-js/es/number/is-integer.js"); +__webpack_require__(/*! core-js/es/number/is-nan */ "../../node_modules/core-js/es/number/is-nan.js"); +__webpack_require__(/*! core-js/es/number/parse-float */ "../../node_modules/core-js/es/number/parse-float.js"); +__webpack_require__(/*! core-js/es/number/parse-int */ "../../node_modules/core-js/es/number/parse-int.js"); +__webpack_require__(/*! core-js/es/object/assign */ "../../node_modules/core-js/es/object/assign.js"); +__webpack_require__(/*! core-js/es/object/entries */ "../../node_modules/core-js/es/object/entries.js"); +__webpack_require__(/*! core-js/es/object/set-prototype-of */ "../../node_modules/core-js/es/object/set-prototype-of.js"); +__webpack_require__(/*! core-js/es/promise */ "../../node_modules/core-js/es/promise/index.js"); +// Due to the way we configured webpack, we should be exporting things which will be under +// a global variable called "tableau". Export everything we want to be visible under tableau +// from this file. +var ExtensionsImpl_1 = __webpack_require__(/*! ./ExtensionsApi/Impl/ExtensionsImpl */ "./lib/src/ExtensionsApi/Impl/ExtensionsImpl.js"); +var Extensions_1 = __webpack_require__(/*! ./ExtensionsApi/Namespaces/Extensions */ "./lib/src/ExtensionsApi/Namespaces/Extensions.js"); +var isAlpha = typeof VERSION_IS_ALPHA !== 'undefined' ? VERSION_IS_ALPHA : false; +api_shared_js_1.ApiVersion.SetVersionNumber( true ? "1.12.0-pre.16" : 0, isAlpha); +var extensionImpl = new ExtensionsImpl_1.ExtensionsImpl(); +exports.extensions = new Extensions_1.Extensions(extensionImpl); +// Export Enums +// These show up under the tableau object. I.e. tableau.ExtensionContext.Server +var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +exports.AnalyticsObjectType = api_external_contract_js_1.AnalyticsObjectType; +exports.AnnotationType = api_external_contract_js_1.AnnotationType; +exports.ClassNameKey = api_external_contract_js_1.ClassNameKey; +exports.ColumnType = api_external_contract_js_1.ColumnType; +exports.DashboardLayoutChange = api_external_contract_js_1.DashboardLayoutChange; +exports.DashboardObjectType = api_external_contract_js_1.DashboardObjectType; +exports.DashboardObjectVisibilityType = api_external_contract_js_1.DashboardObjectVisibilityType; +exports.DataType = api_external_contract_js_1.DataType; +exports.DateRangeType = api_external_contract_js_1.DateRangeType; +exports.DialogStyle = api_external_contract_js_1.DialogStyle; +exports.EncodingType = api_external_contract_js_1.EncodingType; +exports.ErrorCodes = api_external_contract_js_1.ErrorCodes; +exports.ExtensionContext = api_external_contract_js_1.ExtensionContext; +exports.ExtensionMode = api_external_contract_js_1.ExtensionMode; +exports.FieldAggregationType = api_external_contract_js_1.FieldAggregationType; +exports.FieldRoleType = api_external_contract_js_1.FieldRoleType; +exports.FilterDomainType = api_external_contract_js_1.FilterDomainType; +exports.FilterNullOption = api_external_contract_js_1.FilterNullOption; +exports.FilterType = api_external_contract_js_1.FilterType; +exports.FilterUpdateType = api_external_contract_js_1.FilterUpdateType; +exports.HierarchicalLevelSelectionState = api_external_contract_js_1.HierarchicalLevelSelectionState; +exports.IncludeDataValuesOption = api_external_contract_js_1.IncludeDataValuesOption; +exports.MarkType = api_external_contract_js_1.MarkType; +exports.ParameterValueType = api_external_contract_js_1.ParameterValueType; +exports.PeriodType = api_external_contract_js_1.PeriodType; +exports.QuickTableCalcType = api_external_contract_js_1.QuickTableCalcType; +exports.ReplaySpeedType = api_external_contract_js_1.ReplaySpeedType; +exports.SelectOptions = api_external_contract_js_1.SelectOptions; +exports.SelectionUpdateType = api_external_contract_js_1.SelectionUpdateType; +exports.SheetType = api_external_contract_js_1.SheetType; +exports.SortDirection = api_external_contract_js_1.SortDirection; +exports.TableauEventType = api_external_contract_js_1.TableauEventType; +exports.TrendLineModelType = api_external_contract_js_1.TrendLineModelType; +exports.VizImageEncodingType = api_external_contract_js_1.VizImageEncodingType; +exports.VizImagePaletteType = api_external_contract_js_1.VizImagePaletteType; +exports.VizImageSizeSettingAlignmentType = api_external_contract_js_1.VizImageSizeSettingAlignmentType; +exports.VizImageSizeSettingType = api_external_contract_js_1.VizImageSizeSettingType; +exports.VizImageSortDirectionType = api_external_contract_js_1.VizImageSortDirectionType; +exports.ZoneVisibilityType = api_external_contract_js_1.ZoneVisibilityType; + +})(); + +window.tableau = __webpack_exports__; +/******/ })() +; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tableau.extensions.1.12.0-pre.16.js","mappings":"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iD;AAC/D,0BAA0B,mBAAO,CAAC,2FAA6B;;AAE/D;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,kEAAkE,gCAAgC;AAClG,KAAK;;AAEL;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,OAAO;AACvC;AACA;AACA;;AAEA;AACA,YAAY,UAAU;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,YAAY,UAAU;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,OAAO;AACP,YAAY,UAAU;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,YAAY,SAAS;AACrB;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,UAAU,UAAU,aAAa,mCAAmC;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,mCAAmC;AACnC,qCAAqC;AACrC,eAAe;AACf,KAAK;;AAEL,UAAU,UAAU;AACpB;AACA;AACA;AACA;AACA;;;;;;;;;;;;AC3Ma;AACb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BAAoB,mBAAO,CAAC,2FAA6B;;AAEzD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,+BAA+B,MAAM,2BAA2B;AAChE;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,GAAG,KAAK,MAAM;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,eAAe;AAC7D,mBAAmB,0CAA0C;AAC7D,CAAC,sCAAsC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ,EAAE;;;;;;;;;;;ACxDF;AACA,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,uBAAuB,mBAAO,CAAC,+GAAuC;AACtE,kBAAkB,mBAAO,CAAC,yFAA4B;AACtD,iBAAiB,mBAAO,CAAC,qFAA0B;AACnD,WAAW,mBAAO,CAAC,uEAAmB;AACtC,4BAA4B,mBAAO,CAAC,6GAAsC;AAC1E,gBAAgB,mBAAO,CAAC,mFAAyB;;AAEjD;AACA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,gBAAgB;AACpB;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;;;;;;;;;;;ACjFA,kBAAkB,mBAAO,CAAC,qFAA0B;AACpD,2BAA2B,mBAAO,CAAC,2GAAqC;AACxE,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,sBAAsB,mBAAO,CAAC,iGAAgC;AAC9D,iBAAiB,mBAAO,CAAC,qFAA0B;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;AClBA,aA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O,CAAC,+GAAuC;AAC5E,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,kBAAkB,mBAAO,CAAC,qFAA0B;;AAEpD;AACA;AACA;AACA;;AAEA,uBAAuB,+CAA+C;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yBAAyB,qBAAqB;AAC9C;AACA;AACA,yBAAyB,oBAAoB;AAC7C;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;AC9BA,aAAa,mBAAO,CAAC,2EAAqB;AAC1C,YAAY,mBAAO,CAAC,2FAA6B;AACjD,WAAW,mBAAO,CAAC,yGAAoC;AACvD,iBAAiB,mBAAO,CAAC,qFAA0B;AACnD,aAAa,mBAAO,CAAC,+FAA+B;AACpD,YAAY,mBAAO,CAAC,yEAAoB;AACxC,WAAW,mBAAO,CAAC,uEAAmB;AACtC,iBAAiB,mBAAO,CAAC,qFAA0B;AACnD,oBAAoB,mBAAO,CAAC,6GAAsC;AAClE,aAAa,mBAAO,CAAC,yFAA4B;AACjD,cAAc,mBAAO,CAAC,2FAA6B;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,EAAE,gBAAgB;;AAElB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;;;;;;;;;;AChHA,0BAA0B,mBAAO,CAAC,2GAAqC;;AAEvE;AACA;;AAEA;AACA;AACA,6DAA6D;AAC7D;AACA;AACA;AACA;;;;;;;;;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hE,iCAAiC,mBAAO,CAAC,2GAAqC;AAC9E,cAAc,mBAAO,CAAC,6EAAsB;AAC5C,0BAA0B,mBAAO,CAAC,2FAA6B;AAC/D,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,sBAAsB,mBAAO,CAAC,iGAAgC;AAC9D,iBAAiB,mBAAO,CAAC,iGAAgC;AACzD,cAAc,mBAAO,CAAC,2FAA6B;AACnD,iBAAiB,mBAAO,CAAC,iGAAgC;;AAEzD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,aAAa;AACzE;AACA,uBAAuB,aAAa,gBAAgB,aAAa;AACjE;AACA;AACA;AACA,2CAA2C,aAAa;AACxD;AACA;AACA;AACA,CAAC;;AAED;AACA,0DAA0D,aAAa;AACvE,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,YAAY;AACZ,UAAU;AACV,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,eAAe;AACnB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,OAAO;AACP;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,OAAO;AACP,MAAM;AACN;AACA;AACA;AACA;AACA,IAAI;AACJ,qBAAqB,aAAa;AAClC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,OAAO,IAAI,cAAc;;AAEzB;AACA,6EAA6E,cAAc;AAC3F;;AAEA;AACA;AACA;AACA,MAAM,gBAAgB;;AAEtB;AACA;AACA;AACA;AACA;AACA;;AAEA,IAAI,0CAA0C;AAC9C;AACA,CAAC;;AAED;AACA;;AAEA;;AAEA;AACA,IAAI,6CAA6C;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED,IAAI,wDAAwD;AAC5D;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED,IAAI,0DAA0D;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA,CAAC;;;;;;;;;;;;AC7YY;AACb,aAAa,6HAA+C;AAC5D,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,0BAA0B,mBAAO,CAA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A;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,aAAa;AAC/B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,iEAAe,GAAG;;;;;;;;;;;;;;;ACtNlB,iEAAe,sCAAsC;;;;;;;;;;;;;;;;ACAhB;;AAErC;AACA,OAAO,wDAAQ;AACf;AACA;;AAEA;AACA,gCAAgC;;AAEhC;AACA;AACA;AACA,qBAAqB;;AAErB;AACA,qBAAqB;;AAErB;AACA,qBAAqB;;AAErB;AACA,qBAAqB;AACrB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,iEAAe,KAAK;;;;;;;;;;;;;;;AClCpB,iEAAe,cAAc,EAAE,UAAU,EAAE,eAAe,EAAE,gBAAgB,EAAE,UAAU,GAAG,yCAAyC;;;;;;;;;;;;;;;ACApI;AACA;AACA;AACA;AACA;AACe;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;;;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,mDAAmD;;AAEnD;;AAEA,oBAAoB,gBAAgB;AACpC;AACA;AACA,IAAI;AACJ;AACA;AACA;;A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","sources":["webpack://tableau/../../node_modules/core-js/es/array/find.js","webpack://tableau/../../node_modules/core-js/es/array/from.js","webpack://tableau/../../node_modules/core-js/es/map/index.js","webpack://tableau/../../node_modules/core-js/es/number/is-integer.js","webpack://tableau/../../node_modules/core-js/es/number/is-nan.js","webpack://tableau/../../node_modules/core-js/es/number/parse-float.js","webpack://tableau/../../node_modules/core-js/es/number/parse-int.js","webpack://tableau/../../node_modules/core-js/es/object/assign.js","webpack://tableau/../../node_modules/core-js/es/object/entries.js","webpack://tableau/../../node_modules/core-js/es/object/set-prototype-of.js","webpack://tableau/../../node_modules/core-js/es/promise/index.js","webpack://tableau/../../node_modules/core-js/internals/a-callable.js","webpack://tableau/../../node_modules/core-js/internals/a-constructor.js","webpack://tableau/../../node_modules/core-js/internals/a-possible-prototype.js","webpack://tableau/../../node_modules/core-js/internals/add-to-unscopables.js","webpack://tableau/../../node_modules/core-js/internals/an-instance.js","webpack://tableau/../../node_modules/core-js/internals/an-object.js","webpack://tableau/../../node_modules/core-js/internals/array-from.js","webpack://tableau/../../node_modules/core-js/internals/array-includes.js","webpack://tableau/../../node_modules/core-js/internals/array-iteration.js","webpack://tableau/../../node_modules/core-js/internals/array-slice.js","webpack://tableau/../../node_modules/core-js/internals/array-species-constructor.js","webpack://tableau/../../node_modules/core-js/internals/array-species-create.js","webpack://tableau/../../node_modules/core-js/internals/call-with-safe-iteration-closing.js","webpack://tableau/../../node_modules/core-js/internals/check-correctness-of-iteration.js","webpack://tableau/../../node_modules/core-js/internals/classof-raw.js","webpack://tableau/../../node_modules/core-js/internals/classof.js","webpack://tableau/../../node_modules/core-js/internals/clear-error-stack.js","webpack://tableau/../../node_modules/core-js/internals/collection-strong.js","webpack://tableau/../../node_modules/core-js/internals/collection.js","webpack://tableau/../../node_modules/core-js/internals/copy-constructor-properties.js","webpack://tableau/../../node_modules/core-js/internals/correct-prototype-getter.js","webpack://tableau/../../node_modules/core-js/internals/create-iterator-constructor.js","webpack://tableau/../../node_modules/core-js/internals/create-non-enumerable-property.js","webpack://tableau/../../node_modules/core-js/internals/create-property-descriptor.js","webpack://tableau/../../node_modules/core-js/internals/create-property.js","webpack://tableau/../../node_modules/core-js/internals/define-iterator.js","webpack://tableau/../../node_modules/core-js/internals/descriptors.js","webpack://tableau/../../node_modules/core-js/internals/document-create-element.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-browser.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-ios-pebble.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-ios.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-node.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-webos-webkit.js","webpack://tableau/../../node_modules/core-js/internals/engine-user-agent.js","webpack://tableau/../../node_modules/core-js/internals/engine-v8-version.js","webpack://tableau/../../node_modules/core-js/internals/entry-unbind.js","webpack://tableau/../../node_modules/core-js/internals/enum-bug-keys.js","webpack://tableau/../../node_modules/core-js/internals/error-stack-installable.js","webpack://tableau/../../node_modules/core-js/internals/export.js","webpack://tableau/../../node_modules/core-js/internals/fails.js","webpack://tableau/../../node_modules/core-js/internals/freezing.js","webpack://tableau/../../node_modules/core-js/internals/function-apply.js","webpack://tableau/../../node_modules/core-js/internals/function-bind-context.js","webpack://tableau/../../node_modules/core-js/internals/function-call.js","webpack://tableau/../../node_modules/core-js/internals/function-name.js","webpack://tableau/../../node_modules/core-js/internals/function-uncurry-this.js","webpack://tableau/../../node_modules/core-js/internals/get-built-in.js","webpack://tableau/../../node_modules/core-js/internals/get-iterator-method.js","webpack://tableau/../../node_modules/core-js/internals/get-iterator.js","webpack://tableau/../../node_modules/core-js/internals/get-method.js","webpack://tableau/../../node_modules/core-js/internals/global.js","webpack://tableau/../../node_modules/core-js/internals/has-own-property.js","webpack://tableau/../../node_modules/core-js/internals/hidden-keys.js","webpack://tableau/../../node_modules/core-js/internals/host-report-errors.js","webpack://tableau/../../node_modules/core-js/internals/html.js","webpack://tableau/../../node_modules/core-js/internals/ie8-dom-define.js","webpack://tableau/../../node_modules/core-js/internals/indexed-object.js","webpack://tableau/../../node_modules/core-js/internals/inherit-if-required.js","webpack://tableau/../../node_modules/core-js/internals/inspect-source.js","webpack://tableau/../../node_modules/core-js/internals/install-error-cause.js","webpack://tableau/../../node_modules/core-js/internals/internal-metadata.js","webpack://tableau/../../node_modules/core-js/internals/internal-state.js","webpack://tableau/../../node_modules/core-js/internals/is-array-iterator-method.js","webpack://tableau/../../node_modules/core-js/internals/is-array.js","webpack://tableau/../../node_modules/core-js/internals/is-callable.js","webpack://tableau/../../node_modules/core-js/internals/is-constructor.js","webpack://tableau/../../node_modules/core-js/internals/is-forced.js","webpack://tableau/../../node_modules/core-js/internals/is-integral-number.js","webpack://tableau/../../node_modules/core-js/internals/is-object.js","webpack://tableau/../../node_modules/core-js/internals/is-pure.js","webpack://tableau/../../node_modules/core-js/internals/is-symbol.js","webpack://tableau/../../node_modules/core-js/internals/iterate.js","webpack://tableau/../../node_modules/core-js/internals/iterator-close.js","webpack://tableau/../../node_modules/core-js/internals/iterators-core.js","webpack://tableau/../../node_modules/core-js/internals/iterators.js","webpack://tableau/../../node_modules/core-js/internals/length-of-array-like.js","webpack://tableau/../../node_modules/core-js/internals/microtask.js","webpack://tableau/../../node_modules/core-js/internals/native-promise-constructor.js","webpack://tableau/../../node_modules/core-js/internals/native-symbol.js","webpack://tableau/../../node_modules/core-js/internals/native-weak-map.js","webpack://tableau/../../node_modules/core-js/internals/new-promise-capability.js","webpack://tableau/../../node_modules/core-js/internals/normalize-string-argument.js","webpack://tableau/../../node_modules/core-js/internals/number-parse-float.js","webpack://tableau/../../node_modules/core-js/internals/number-parse-int.js","webpack://tableau/../../node_modules/core-js/internals/object-assign.js","webpack://tableau/../../node_modules/core-js/internals/object-create.js","webpack://tableau/../../node_modules/core-js/internals/object-define-properties.js","webpack://tableau/../../node_modules/core-js/internals/object-define-property.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-descriptor.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-names-external.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-names.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-symbols.js","webpack://tableau/../../node_modules/core-js/internals/object-get-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-is-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-keys-internal.js","webpack://tableau/../../node_modules/core-js/internals/object-keys.js","webpack://tableau/../../node_modules/core-js/internals/object-property-is-enumerable.js","webpack://tableau/../../node_modules/core-js/internals/object-set-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-to-array.js","webpack://tableau/../../node_modules/core-js/internals/object-to-string.js","webpack://tableau/../../node_modules/core-js/internals/ordinary-to-primitive.js","webpack://tableau/../../node_modules/core-js/internals/own-keys.js","webpack://tableau/../../node_modules/core-js/internals/path.js","webpack://tableau/../../node_modules/core-js/internals/perform.js","webpack://tableau/../../node_modules/core-js/internals/promise-resolve.js","webpack://tableau/../../node_modules/core-js/internals/redefine-all.js","webpack://tableau/../../node_modules/core-js/internals/redefine.js","webpack://tableau/../../node_modules/core-js/internals/require-object-coercible.js","webpack://tableau/../../node_modules/core-js/internals/set-global.js","webpack://tableau/../../node_modules/core-js/internals/set-species.js","webpack://tableau/../../node_modules/core-js/internals/set-to-string-tag.js","webpack://tableau/../../node_modules/core-js/internals/shared-key.js","webpack://tableau/../../node_modules/core-js/internals/shared-store.js","webpack://tableau/../../node_modules/core-js/internals/shared.js","webpack://tableau/../../node_modules/core-js/internals/species-constructor.js","webpack://tableau/../../node_modules/core-js/internals/string-multibyte.js","webpack://tableau/../../node_modules/core-js/internals/string-trim.js","webpack://tableau/../../node_modules/core-js/internals/task.js","webpack://tableau/../../node_modules/core-js/internals/to-absolute-index.js","webpack://tableau/../../node_modules/core-js/internals/to-indexed-object.js","webpack://tableau/../../node_modules/core-js/internals/to-integer-or-infinity.js","webpack://tableau/../../node_modules/core-js/internals/to-length.js","webpack://tableau/../../node_modules/core-js/internals/to-object.js","webpack://tableau/../../node_modules/core-js/internals/to-primitive.js","webpack://tableau/../../node_modules/core-js/internals/to-property-key.js","webpack://tableau/../../node_modules/core-js/internals/to-string-tag-support.js","webpack://tableau/../../node_modules/core-js/internals/to-string.js","webpack://tableau/../../node_modules/core-js/internals/try-to-string.js","webpack://tableau/../../node_modules/core-js/internals/uid.js","webpack://tableau/../../node_modules/core-js/internals/use-symbol-as-uid.js","webpack://tableau/../../node_modules/core-js/internals/well-known-symbol.js","webpack://tableau/../../node_modules/core-js/internals/whitespaces.js","webpack://tableau/../../node_modules/core-js/modules/es.aggregate-error.js","webpack://tableau/../../node_modules/core-js/modules/es.array.find.js","webpack://tableau/../../node_modules/core-js/modules/es.array.from.js","webpack://tableau/../../node_modules/core-js/modules/es.array.iterator.js","webpack://tableau/../../node_modules/core-js/modules/es.map.js","webpack://tableau/../../node_modules/core-js/modules/es.number.is-integer.js","webpack://tableau/../../node_modules/core-js/modules/es.number.is-nan.js","webpack://tableau/../../node_modules/core-js/modules/es.number.parse-float.js","webpack://tableau/../../node_modules/core-js/modules/es.number.parse-int.js","webpack://tableau/../../node_modules/core-js/modules/es.object.assign.js","webpack://tableau/../../node_modules/core-js/modules/es.object.entries.js","webpack://tableau/../../node_modules/core-js/modules/es.object.set-prototype-of.js","webpack://tableau/../../node_modules/core-js/modules/es.object.to-string.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.all-settled.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.any.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.finally.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.js","webpack://tableau/../../node_modules/core-js/modules/es.string.iterator.js","webpack://tableau/../../node_modules/guid/guid.js","webpack://tableau/./src/ExtensionsApi/Events/DashboardLayoutChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/FilterChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/MarksSelectedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/ParameterChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/SummaryDataChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/TableauEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/TableauSheetEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/TableauWorksheetEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/WorkbookFormattingChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Impl/BentonSansFontNameConstants.ts","webpack://tableau/./src/ExtensionsApi/Impl/ConnectedServer.ts","webpack://tableau/./src/ExtensionsApi/Impl/ExtensionWorkbookImpl.ts","webpack://tableau/./src/ExtensionsApi/Impl/ExtensionsImpl.ts","webpack://tableau/./src/ExtensionsApi/Impl/LegacyInternalApiDispatcherHolder.ts","webpack://tableau/./src/ExtensionsApi/Impl/SettingsImpl.ts","webpack://tableau/./src/ExtensionsApi/Impl/TableauBookFontNameConstants.ts","webpack://tableau/./src/ExtensionsApi/Impl/UIImpl.ts","webpack://tableau/./src/ExtensionsApi/Models/Dashboard.ts","webpack://tableau/./src/ExtensionsApi/Models/DashboardObject.ts","webpack://tableau/./src/ExtensionsApi/Models/Parameter.ts","webpack://tableau/./src/ExtensionsApi/Models/Sheet.ts","webpack://tableau/./src/ExtensionsApi/Models/Workbook.ts","webpack://tableau/./src/ExtensionsApi/Models/Worksheet.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/DashboardContent.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/Environment.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/Extensions.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/Settings.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/UI.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/WorkbookFormattingEnvUtil.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/WorksheetContent.ts","webpack://tableau/./src/ExtensionsApi/Services/Impl/InitializationServiceImpl.ts","webpack://tableau/./src/ExtensionsApi/Services/Impl/SettingsServiceImpl.ts","webpack://tableau/./src/ExtensionsApi/Services/Impl/UIServiceImpl.ts","webpack://tableau/./src/ExtensionsApi/Services/RegisterAllExtensionsServices.ts","webpack://tableau/./src/ExtensionsApi/Services/ServiceRegistryUtil.ts","webpack://tableau/../api-external-contract-js/src/EmbeddingApiExternalContract.ts","webpack://tableau/../api-external-contract-js/src/ExtensionsApiExternalContract.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/AskDataInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/Enums.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/PulseInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/VizInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/WebComponentInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Extensions/Namespaces/Tableau.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Shared/Enums.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Shared/Namespaces/Tableau.ts","webpack://tableau/../api-external-contract-js/src/SharedApiExternalContract.ts","webpack://tableau/../api-internal-contract-js/src/JsApiInternalContract.ts","webpack://tableau/../api-internal-contract-js/src/contract/DataTypeConverter.ts","webpack://tableau/../api-internal-contract-js/src/contract/Enums.ts","webpack://tableau/../api-internal-contract-js/src/contract/Notifications.ts","webpack://tableau/../api-internal-contract-js/src/contract/Parameters.ts","webpack://tableau/../api-internal-contract-js/src/contract/Verbs.ts","webpack://tableau/../api-internal-contract-js/src/interface/AskDataInterface.ts","webpack://tableau/../api-internal-contract-js/src/interface/PulseInterface.ts","webpack://tableau/../api-internal-contract-js/src/interface/VqlInterface.ts","webpack://tableau/../api-internal-contract-js/src/messaging/CrossFrameMessenger.ts","webpack://tableau/../api-internal-contract-js/src/messaging/CrossFramePreparedMessage.ts","webpack://tableau/../api-internal-contract-js/src/messaging/MessageTypeChecks.ts","webpack://tableau/../api-internal-contract-js/src/messaging/interface/MessageTypes.ts","webpack://tableau/../api-internal-contract-js/src/versioning/IdentityVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/StackingVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/VersionConverterFactory.ts","webpack://tableau/../api-internal-contract-js/src/versioning/VersionTranslations.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalIdentityVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalStackingVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalVersionConverterFactory.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalVersionTranslations.ts","webpack://tableau/../api-shared-js/src/ApiShared.ts","webpack://tableau/../api-shared-js/src/ApiShared/ApiVersion.ts","webpack://tableau/../api-shared-js/src/ApiShared/ConnectionSummary.ts","webpack://tableau/../api-shared-js/src/ApiShared/CrossFrame/CrossFrameBootstrap.ts","webpack://tableau/../api-shared-js/src/ApiShared/CrossFrame/CrossFrameDispatcher.ts","webpack://tableau/../api-shared-js/src/ApiShared/DataSource.ts","webpack://tableau/../api-shared-js/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.ts","webpack://tableau/../api-shared-js/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.ts","webpack://tableau/../api-shared-js/src/ApiShared/EventListenerManager.ts","webpack://tableau/../api-shared-js/src/ApiShared/Field.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/CustomViewImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/DashboardImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/DashboardObjectImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/DataSourceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/FieldImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/ParameterImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/SheetImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/SheetInfoImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/SingleEventManagerImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/StoryImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/StoryPointImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/StoryPointInfoImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/WorkbookImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/WorksheetImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/LogicalTable.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/AccessibilityModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/FilterModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/GetDataModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/GetDataTableReaderModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/SelectionModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Point.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/GetDataService.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/RegisterAllSharedServices.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/ServiceRegistry.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/AccessibilityServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/AnimationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/AnnotationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ClientInfoServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/DataSourceServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ExportServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ExternalContextMenuServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/FilterServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/GetDataServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/NotificationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/NotificationServiceImplBase.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ParametersServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/SelectionServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ServiceImplBase.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/SizeServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/StoryActivationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/VisualModelServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/VizServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ZoneServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/TableSummary.ts","webpack://tableau/../api-shared-js/src/ApiShared/TableauError.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/DataValueFactory.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/Deferred.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/EnumConverter.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/ErrorHelpers.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/ExportHelpers.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/Param.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/SheetUtils.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/ShortLivedDeferred.ts","webpack://tableau/../api-shared-js/src/ApiShared/VersionNumber.ts","webpack://tableau/../api-shared-js/src/VersionedExternalApiDispatcher.ts","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/index.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/md5.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/nil.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/parse.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/regex.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/rng.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/sha1.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v1.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v3.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v35.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v4.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v5.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/validate.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/version.js","webpack://tableau/webpack/bootstrap","webpack://tableau/webpack/runtime/define property getters","webpack://tableau/webpack/runtime/global","webpack://tableau/webpack/runtime/hasOwnProperty shorthand","webpack://tableau/webpack/runtime/make namespace object","webpack://tableau/./src/ExtensionsApi.ts"],"sourcesContent":["require('../../modules/es.array.find');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('Array', 'find');\n","require('../../modules/es.string.iterator');\nrequire('../../modules/es.array.from');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Array.from;\n","require('../../modules/es.array.iterator');\nrequire('../../modules/es.map');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Map;\n","require('../../modules/es.number.is-integer');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.isInteger;\n","require('../../modules/es.number.is-nan');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.isNaN;\n","require('../../modules/es.number.parse-float');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.parseFloat;\n","require('../../modules/es.number.parse-int');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.parseInt;\n","require('../../modules/es.object.assign');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.assign;\n","require('../../modules/es.object.entries');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.entries;\n","require('../../modules/es.object.set-prototype-of');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.setPrototypeOf;\n","require('../../modules/es.aggregate-error');\nrequire('../../modules/es.array.iterator');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.promise');\nrequire('../../modules/es.promise.all-settled');\nrequire('../../modules/es.promise.any');\nrequire('../../modules/es.promise.finally');\nrequire('../../modules/es.string.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Promise;\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar TypeError = global.TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n  if (isCallable(argument)) return argument;\n  throw TypeError(tryToString(argument) + ' is not a function');\n};\n","var global = require('../internals/global');\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar TypeError = global.TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n  if (isConstructor(argument)) return argument;\n  throw TypeError(tryToString(argument) + ' is not a constructor');\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar String = global.String;\nvar TypeError = global.TypeError;\n\nmodule.exports = function (argument) {\n  if (typeof argument == 'object' || isCallable(argument)) return argument;\n  throw TypeError(\"Can't set \" + String(argument) + ' as a prototype');\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","var global = require('../internals/global');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar TypeError = global.TypeError;\n\nmodule.exports = function (it, Prototype) {\n  if (isPrototypeOf(Prototype, it)) return it;\n  throw TypeError('Incorrect invocation');\n};\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar String = global.String;\nvar TypeError = global.TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n  if (isObject(argument)) return argument;\n  throw TypeError(String(argument) + ' is not an object');\n};\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar toObject = require('../internals/to-object');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar isConstructor = require('../internals/is-constructor');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar Array = global.Array;\n\n// `Array.from` method implementation\n// https://tc39.es/ecma262/#sec-array.from\nmodule.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n  var O = toObject(arrayLike);\n  var IS_CONSTRUCTOR = isConstructor(this);\n  var argumentsLength = arguments.length;\n  var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n  var mapping = mapfn !== undefined;\n  if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);\n  var iteratorMethod = getIteratorMethod(O);\n  var index = 0;\n  var length, result, step, iterator, next, value;\n  // if the target is not iterable or it's an array with the default iterator - use a simple case\n  if (iteratorMethod && !(this == Array && isArrayIteratorMethod(iteratorMethod))) {\n    iterator = getIterator(O, iteratorMethod);\n    next = iterator.next;\n    result = IS_CONSTRUCTOR ? new this() : [];\n    for (;!(step = call(next, iterator)).done; index++) {\n      value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;\n      createProperty(result, index, value);\n    }\n  } else {\n    length = lengthOfArrayLike(O);\n    result = IS_CONSTRUCTOR ? new this(length) : Array(length);\n    for (;length > index; index++) {\n      value = mapping ? mapfn(O[index], index) : O[index];\n      createProperty(result, index, value);\n    }\n  }\n  result.length = index;\n  return result;\n};\n","var toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = lengthOfArrayLike(O);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare -- NaN check\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.includes` method\n  // https://tc39.es/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.es/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n","var bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n  var IS_MAP = TYPE == 1;\n  var IS_FILTER = TYPE == 2;\n  var IS_SOME = TYPE == 3;\n  var IS_EVERY = TYPE == 4;\n  var IS_FIND_INDEX = TYPE == 6;\n  var IS_FILTER_REJECT = TYPE == 7;\n  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;\n  return function ($this, callbackfn, that, specificCreate) {\n    var O = toObject($this);\n    var self = IndexedObject(O);\n    var boundFunction = bind(callbackfn, that);\n    var length = lengthOfArrayLike(self);\n    var index = 0;\n    var create = specificCreate || arraySpeciesCreate;\n    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n    var value, result;\n    for (;length > index; index++) if (NO_HOLES || index in self) {\n      value = self[index];\n      result = boundFunction(value, index, O);\n      if (TYPE) {\n        if (IS_MAP) target[index] = result; // map\n        else if (result) switch (TYPE) {\n          case 3: return true;              // some\n          case 5: return value;             // find\n          case 6: return index;             // findIndex\n          case 2: push(target, value);      // filter\n        } else switch (TYPE) {\n          case 4: return false;             // every\n          case 7: push(target, value);      // filterReject\n        }\n      }\n    }\n    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.forEach` method\n  // https://tc39.es/ecma262/#sec-array.prototype.foreach\n  forEach: createMethod(0),\n  // `Array.prototype.map` method\n  // https://tc39.es/ecma262/#sec-array.prototype.map\n  map: createMethod(1),\n  // `Array.prototype.filter` method\n  // https://tc39.es/ecma262/#sec-array.prototype.filter\n  filter: createMethod(2),\n  // `Array.prototype.some` method\n  // https://tc39.es/ecma262/#sec-array.prototype.some\n  some: createMethod(3),\n  // `Array.prototype.every` method\n  // https://tc39.es/ecma262/#sec-array.prototype.every\n  every: createMethod(4),\n  // `Array.prototype.find` method\n  // https://tc39.es/ecma262/#sec-array.prototype.find\n  find: createMethod(5),\n  // `Array.prototype.findIndex` method\n  // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n  findIndex: createMethod(6),\n  // `Array.prototype.filterReject` method\n  // https://github.com/tc39/proposal-array-filtering\n  filterReject: createMethod(7)\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","var global = require('../internals/global');\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar Array = global.Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n  var C;\n  if (isArray(originalArray)) {\n    C = originalArray.constructor;\n    // cross-realm fallback\n    if (isConstructor(C) && (C === Array || isArray(C.prototype))) C = undefined;\n    else if (isObject(C)) {\n      C = C[SPECIES];\n      if (C === null) C = undefined;\n    }\n  } return C === undefined ? Array : C;\n};\n","var arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","var anObject = require('../internals/an-object');\nvar iteratorClose = require('../internals/iterator-close');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n  try {\n    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n  } catch (error) {\n    iteratorClose(iterator, 'throw', error);\n  }\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n  var called = 0;\n  var iteratorWithReturn = {\n    next: function () {\n      return { done: !!called++ };\n    },\n    'return': function () {\n      SAFE_CLOSING = true;\n    }\n  };\n  iteratorWithReturn[ITERATOR] = function () {\n    return this;\n  };\n  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n  Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n  var ITERATION_SUPPORT = false;\n  try {\n    var object = {};\n    object[ITERATOR] = function () {\n      return {\n        next: function () {\n          return { done: ITERATION_SUPPORT = true };\n        }\n      };\n    };\n    exec(object);\n  } catch (error) { /* empty */ }\n  return ITERATION_SUPPORT;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n  return stringSlice(toString(it), 8, -1);\n};\n","var global = require('../internals/global');\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar Object = global.Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n  var O, tag, result;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag\n    // builtinTag case\n    : CORRECT_ARGUMENTS ? classofRaw(O)\n    // ES3 arguments fallback\n    : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar arraySlice = require('../internals/array-slice');\n\nvar replace = uncurryThis(''.replace);\nvar split = uncurryThis(''.split);\nvar join = uncurryThis([].join);\n\nvar TEST = (function (arg) { return String(Error(arg).stack); })('zxcasd');\nvar V8_OR_CHAKRA_STACK_ENTRY = /\\n\\s*at [^:]*:[^\\n]*/;\nvar IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);\nvar IS_FIREFOX_OR_SAFARI_STACK = /@[^\\n]*\\n/.test(TEST) && !/zxcasd/.test(TEST);\n\nmodule.exports = function (stack, dropEntries) {\n  if (typeof stack != 'string') return stack;\n  if (IS_V8_OR_CHAKRA_STACK) {\n    while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');\n  } else if (IS_FIREFOX_OR_SAFARI_STACK) {\n    return join(arraySlice(split(stack, '\\n'), dropEntries), '\\n');\n  } return stack;\n};\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar create = require('../internals/object-create');\nvar redefineAll = require('../internals/redefine-all');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/define-iterator');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n    var Constructor = wrapper(function (that, iterable) {\n      anInstance(that, Prototype);\n      setInternalState(that, {\n        type: CONSTRUCTOR_NAME,\n        index: create(null),\n        first: undefined,\n        last: undefined,\n        size: 0\n      });\n      if (!DESCRIPTORS) that.size = 0;\n      if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n    });\n\n    var Prototype = Constructor.prototype;\n\n    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n    var define = function (that, key, value) {\n      var state = getInternalState(that);\n      var entry = getEntry(that, key);\n      var previous, index;\n      // change existing entry\n      if (entry) {\n        entry.value = value;\n      // create new entry\n      } else {\n        state.last = entry = {\n          index: index = fastKey(key, true),\n          key: key,\n          value: value,\n          previous: previous = state.last,\n          next: undefined,\n          removed: false\n        };\n        if (!state.first) state.first = entry;\n        if (previous) previous.next = entry;\n        if (DESCRIPTORS) state.size++;\n        else that.size++;\n        // add to index\n        if (index !== 'F') state.index[index] = entry;\n      } return that;\n    };\n\n    var getEntry = function (that, key) {\n      var state = getInternalState(that);\n      // fast case\n      var index = fastKey(key);\n      var entry;\n      if (index !== 'F') return state.index[index];\n      // frozen object case\n      for (entry = state.first; entry; entry = entry.next) {\n        if (entry.key == key) return entry;\n      }\n    };\n\n    redefineAll(Prototype, {\n      // `{ Map, Set }.prototype.clear()` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.clear\n      // https://tc39.es/ecma262/#sec-set.prototype.clear\n      clear: function clear() {\n        var that = this;\n        var state = getInternalState(that);\n        var data = state.index;\n        var entry = state.first;\n        while (entry) {\n          entry.removed = true;\n          if (entry.previous) entry.previous = entry.previous.next = undefined;\n          delete data[entry.index];\n          entry = entry.next;\n        }\n        state.first = state.last = undefined;\n        if (DESCRIPTORS) state.size = 0;\n        else that.size = 0;\n      },\n      // `{ Map, Set }.prototype.delete(key)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.delete\n      // https://tc39.es/ecma262/#sec-set.prototype.delete\n      'delete': function (key) {\n        var that = this;\n        var state = getInternalState(that);\n        var entry = getEntry(that, key);\n        if (entry) {\n          var next = entry.next;\n          var prev = entry.previous;\n          delete state.index[entry.index];\n          entry.removed = true;\n          if (prev) prev.next = next;\n          if (next) next.previous = prev;\n          if (state.first == entry) state.first = next;\n          if (state.last == entry) state.last = prev;\n          if (DESCRIPTORS) state.size--;\n          else that.size--;\n        } return !!entry;\n      },\n      // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.foreach\n      // https://tc39.es/ecma262/#sec-set.prototype.foreach\n      forEach: function forEach(callbackfn /* , that = undefined */) {\n        var state = getInternalState(this);\n        var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n        var entry;\n        while (entry = entry ? entry.next : state.first) {\n          boundFunction(entry.value, entry.key, this);\n          // revert to the last existing entry\n          while (entry && entry.removed) entry = entry.previous;\n        }\n      },\n      // `{ Map, Set}.prototype.has(key)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.has\n      // https://tc39.es/ecma262/#sec-set.prototype.has\n      has: function has(key) {\n        return !!getEntry(this, key);\n      }\n    });\n\n    redefineAll(Prototype, IS_MAP ? {\n      // `Map.prototype.get(key)` method\n      // https://tc39.es/ecma262/#sec-map.prototype.get\n      get: function get(key) {\n        var entry = getEntry(this, key);\n        return entry && entry.value;\n      },\n      // `Map.prototype.set(key, value)` method\n      // https://tc39.es/ecma262/#sec-map.prototype.set\n      set: function set(key, value) {\n        return define(this, key === 0 ? 0 : key, value);\n      }\n    } : {\n      // `Set.prototype.add(value)` method\n      // https://tc39.es/ecma262/#sec-set.prototype.add\n      add: function add(value) {\n        return define(this, value = value === 0 ? 0 : value, value);\n      }\n    });\n    if (DESCRIPTORS) defineProperty(Prototype, 'size', {\n      get: function () {\n        return getInternalState(this).size;\n      }\n    });\n    return Constructor;\n  },\n  setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {\n    var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n    var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n    var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n    // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods\n    // https://tc39.es/ecma262/#sec-map.prototype.entries\n    // https://tc39.es/ecma262/#sec-map.prototype.keys\n    // https://tc39.es/ecma262/#sec-map.prototype.values\n    // https://tc39.es/ecma262/#sec-map.prototype-@@iterator\n    // https://tc39.es/ecma262/#sec-set.prototype.entries\n    // https://tc39.es/ecma262/#sec-set.prototype.keys\n    // https://tc39.es/ecma262/#sec-set.prototype.values\n    // https://tc39.es/ecma262/#sec-set.prototype-@@iterator\n    defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {\n      setInternalState(this, {\n        type: ITERATOR_NAME,\n        target: iterated,\n        state: getInternalCollectionState(iterated),\n        kind: kind,\n        last: undefined\n      });\n    }, function () {\n      var state = getInternalIteratorState(this);\n      var kind = state.kind;\n      var entry = state.last;\n      // revert to the last existing entry\n      while (entry && entry.removed) entry = entry.previous;\n      // get next entry\n      if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n        // or finish the iteration\n        state.target = undefined;\n        return { value: undefined, done: true };\n      }\n      // return step by kind\n      if (kind == 'keys') return { value: entry.key, done: false };\n      if (kind == 'values') return { value: entry.value, done: false };\n      return { value: [entry.key, entry.value], done: false };\n    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n    // `{ Map, Set }.prototype[@@species]` accessors\n    // https://tc39.es/ecma262/#sec-get-map-@@species\n    // https://tc39.es/ecma262/#sec-get-set-@@species\n    setSpecies(CONSTRUCTOR_NAME);\n  }\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar redefine = require('../internals/redefine');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n  var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n  var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n  var ADDER = IS_MAP ? 'set' : 'add';\n  var NativeConstructor = global[CONSTRUCTOR_NAME];\n  var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n  var Constructor = NativeConstructor;\n  var exported = {};\n\n  var fixMethod = function (KEY) {\n    var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n    redefine(NativePrototype, KEY,\n      KEY == 'add' ? function add(value) {\n        uncurriedNativeMethod(this, value === 0 ? 0 : value);\n        return this;\n      } : KEY == 'delete' ? function (key) {\n        return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : KEY == 'get' ? function get(key) {\n        return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : KEY == 'has' ? function has(key) {\n        return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : function set(key, value) {\n        uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n        return this;\n      }\n    );\n  };\n\n  var REPLACE = isForced(\n    CONSTRUCTOR_NAME,\n    !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n      new NativeConstructor().entries().next();\n    }))\n  );\n\n  if (REPLACE) {\n    // create collection constructor\n    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n    InternalMetadataModule.enable();\n  } else if (isForced(CONSTRUCTOR_NAME, true)) {\n    var instance = new Constructor();\n    // early implementations not supports chaining\n    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n    // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n    // most early implementations doesn't supports iterables, most modern - not close it correctly\n    // eslint-disable-next-line no-new -- required for testing\n    var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n    // for early implementations -0 and +0 not the same\n    var BUGGY_ZERO = !IS_WEAK && fails(function () {\n      // V8 ~ Chromium 42- fails only with 5+ elements\n      var $instance = new NativeConstructor();\n      var index = 5;\n      while (index--) $instance[ADDER](index, index);\n      return !$instance.has(-0);\n    });\n\n    if (!ACCEPT_ITERABLES) {\n      Constructor = wrapper(function (dummy, iterable) {\n        anInstance(dummy, NativePrototype);\n        var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n        if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n        return that;\n      });\n      Constructor.prototype = NativePrototype;\n      NativePrototype.constructor = Constructor;\n    }\n\n    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n      fixMethod('delete');\n      fixMethod('has');\n      IS_MAP && fixMethod('get');\n    }\n\n    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n    // weak collections should not contains .clear method\n    if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n  }\n\n  exported[CONSTRUCTOR_NAME] = Constructor;\n  $({ global: true, forced: Constructor != NativeConstructor }, exported);\n\n  setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n  return Constructor;\n};\n","var hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n  var keys = ownKeys(source);\n  var defineProperty = definePropertyModule.f;\n  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!hasOwn(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next) {\n  var TO_STRING_TAG = NAME + ' Iterator';\n  IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });\n  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n  Iterators[TO_STRING_TAG] = returnThis;\n  return IteratorConstructor;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n  var propertyKey = toPropertyKey(key);\n  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n  else object[propertyKey] = value;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n  createIteratorConstructor(IteratorConstructor, NAME, next);\n\n  var getIterationMethod = function (KIND) {\n    if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];\n    switch (KIND) {\n      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n    } return function () { return new IteratorConstructor(this); };\n  };\n\n  var TO_STRING_TAG = NAME + ' Iterator';\n  var INCORRECT_VALUES_NAME = false;\n  var IterablePrototype = Iterable.prototype;\n  var nativeIterator = IterablePrototype[ITERATOR]\n    || IterablePrototype['@@iterator']\n    || DEFAULT && IterablePrototype[DEFAULT];\n  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n  var CurrentIteratorPrototype, methods, KEY;\n\n  // fix native\n  if (anyNativeIterator) {\n    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n    if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n        if (setPrototypeOf) {\n          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n        } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n          redefine(CurrentIteratorPrototype, ITERATOR, returnThis);\n        }\n      }\n      // Set @@toStringTag to native iterators\n      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n      if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n    }\n  }\n\n  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n  if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n    if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n      createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n    } else {\n      INCORRECT_VALUES_NAME = true;\n      defaultIterator = function values() { return call(nativeIterator, this); };\n    }\n  }\n\n  // export additional methods\n  if (DEFAULT) {\n    methods = {\n      values: getIterationMethod(VALUES),\n      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n      entries: getIterationMethod(ENTRIES)\n    };\n    if (FORCED) for (KEY in methods) {\n      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n        redefine(IterablePrototype, KEY, methods[KEY]);\n      }\n    } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n  }\n\n  // define iterator\n  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n    redefine(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n  }\n  Iterators[NAME] = defaultIterator;\n\n  return methods;\n};\n","var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n  return EXISTS ? document.createElement(it) : {};\n};\n","module.exports = typeof window == 'object';\n","var userAgent = require('../internals/engine-user-agent');\nvar global = require('../internals/global');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && global.Pebble !== undefined;\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","var classof = require('../internals/classof-raw');\nvar global = require('../internals/global');\n\nmodule.exports = classof(global.process) == 'process';\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\n","var global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n  match = v8.split('.');\n  // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n  // but their correct versions are not interesting for us\n  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n  match = userAgent.match(/Edge\\/(\\d+)/);\n  if (!match || match[1] >= 74) {\n    match = userAgent.match(/Chrome\\/(\\d+)/);\n    if (match) version = +match[1];\n  }\n}\n\nmodule.exports = version;\n","var global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (CONSTRUCTOR, METHOD) {\n  return uncurryThis(global[CONSTRUCTOR].prototype[METHOD]);\n};\n","// IE8- don't enum bug keys\nmodule.exports = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf'\n];\n","var fails = require('../internals/fails');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = !fails(function () {\n  var error = Error('a');\n  if (!('stack' in error)) return true;\n  // eslint-disable-next-line es/no-object-defineproperty -- safe\n  Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));\n  return error.stack !== 7;\n});\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n  options.target      - name of the target object\n  options.global      - target is the global object\n  options.stat        - export as static methods of target\n  options.proto       - export as prototype methods of target\n  options.real        - real prototype method for the `pure` version\n  options.forced      - export even if the native feature is available\n  options.bind        - bind methods to the target, required for the `pure` version\n  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n  options.sham        - add a flag to not completely full polyfills\n  options.enumerable  - export as enumerable property\n  options.noTargetGet - prevent calling a getter on target\n  options.name        - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global;\n  } else if (STATIC) {\n    target = global[TARGET] || setGlobal(TARGET, {});\n  } else {\n    target = (global[TARGET] || {}).prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.noTargetGet) {\n      descriptor = getOwnPropertyDescriptor(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty == typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || (targetProperty && targetProperty.sham)) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    // extend global\n    redefine(target, key, sourceProperty, options);\n  }\n};\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n  return Object.isExtensible(Object.preventExtensions({}));\n});\n","var FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar bind = FunctionPrototype.bind;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (bind ? call.bind(apply) : function () {\n  return call.apply(apply, arguments);\n});\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n  aCallable(fn);\n  return that === undefined ? fn : bind ? bind(fn, that) : function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","var call = Function.prototype.call;\n\nmodule.exports = call.bind ? call.bind(call) : function () {\n  return call.apply(call, arguments);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n  EXISTS: EXISTS,\n  PROPER: PROPER,\n  CONFIGURABLE: CONFIGURABLE\n};\n","var FunctionPrototype = Function.prototype;\nvar bind = FunctionPrototype.bind;\nvar call = FunctionPrototype.call;\nvar callBind = bind && bind.bind(call);\n\nmodule.exports = bind ? function (fn) {\n  return fn && callBind(call, fn);\n} : function (fn) {\n  return fn && function () {\n    return call.apply(fn, arguments);\n  };\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n  return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","var classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n  if (it != undefined) return getMethod(it, ITERATOR)\n    || getMethod(it, '@@iterator')\n    || Iterators[classof(it)];\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar TypeError = global.TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n  throw TypeError(tryToString(argument) + ' is not iterable');\n};\n","var aCallable = require('../internals/a-callable');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n  var func = V[P];\n  return func == null ? undefined : aCallable(func);\n};\n","var check = function (it) {\n  return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n  // eslint-disable-next-line es/no-global-this -- safe\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  // eslint-disable-next-line no-restricted-globals -- safe\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  // eslint-disable-next-line no-new-func -- fallback\n  (function () { return this; })() || Function('return this')();\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n  return hasOwnProperty(toObject(it), key);\n};\n","module.exports = {};\n","var global = require('../internals/global');\n\nmodule.exports = function (a, b) {\n  var console = global.console;\n  if (console && console.error) {\n    arguments.length == 1 ? console.error(a) : console.error(a, b);\n  }\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- requied for testing\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a != 7;\n});\n","var global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar Object = global.Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins -- safe\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) == 'String' ? split(it, '') : Object(it);\n} : Object;\n","var isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n  var NewTarget, NewTargetPrototype;\n  if (\n    // it can work only with native `setPrototypeOf`\n    setPrototypeOf &&\n    // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n    isCallable(NewTarget = dummy.constructor) &&\n    NewTarget !== Wrapper &&\n    isObject(NewTargetPrototype = NewTarget.prototype) &&\n    NewTargetPrototype !== Wrapper.prototype\n  ) setPrototypeOf($this, NewTargetPrototype);\n  return $this;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n  store.inspectSource = function (it) {\n    return functionToString(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n","var isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\n// `InstallErrorCause` abstract operation\n// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause\nmodule.exports = function (O, options) {\n  if (isObject(options) && 'cause' in options) {\n    createNonEnumerableProperty(O, 'cause', options.cause);\n  }\n};\n","var $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar isExtensible = Object.isExtensible || function () {\n  return true;\n};\n\nvar setMetadata = function (it) {\n  defineProperty(it, METADATA, { value: {\n    objectID: 'O' + id++, // object ID\n    weakData: {}          // weak collections IDs\n  } });\n};\n\nvar fastKey = function (it, create) {\n  // return a primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!hasOwn(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMetadata(it);\n  // return object ID\n  } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n  if (!hasOwn(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMetadata(it);\n  // return the store of weak collections IDs\n  } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n  return it;\n};\n\nvar enable = function () {\n  meta.enable = function () { /* empty */ };\n  REQUIRED = true;\n  var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n  var splice = uncurryThis([].splice);\n  var test = {};\n  test[METADATA] = 1;\n\n  // prevent exposing of metadata key\n  if (getOwnPropertyNames(test).length) {\n    getOwnPropertyNamesModule.f = function (it) {\n      var result = getOwnPropertyNames(it);\n      for (var i = 0, length = result.length; i < length; i++) {\n        if (result[i] === METADATA) {\n          splice(result, i, 1);\n          break;\n        }\n      } return result;\n    };\n\n    $({ target: 'Object', stat: true, forced: true }, {\n      getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n    });\n  }\n};\n\nvar meta = module.exports = {\n  enable: enable,\n  fastKey: fastKey,\n  getWeakData: getWeakData,\n  onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n  return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n    } return state;\n  };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n  var store = shared.state || (shared.state = new WeakMap());\n  var wmget = uncurryThis(store.get);\n  var wmhas = uncurryThis(store.has);\n  var wmset = uncurryThis(store.set);\n  set = function (it, metadata) {\n    if (wmhas(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    wmset(store, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget(store, it) || {};\n  };\n  has = function (it) {\n    return wmhas(store, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return hasOwn(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return hasOwn(it, STATE);\n  };\n}\n\nmodule.exports = {\n  set: set,\n  get: get,\n  has: has,\n  enforce: enforce,\n  getterFor: getterFor\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","var classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n  return classof(argument) == 'Array';\n};\n","// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = function (argument) {\n  return typeof argument == 'function';\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.exec(noop);\n\nvar isConstructorModern = function (argument) {\n  if (!isCallable(argument)) return false;\n  try {\n    construct(noop, empty, argument);\n    return true;\n  } catch (error) {\n    return false;\n  }\n};\n\nvar isConstructorLegacy = function (argument) {\n  if (!isCallable(argument)) return false;\n  switch (classof(argument)) {\n    case 'AsyncFunction':\n    case 'GeneratorFunction':\n    case 'AsyncGeneratorFunction': return false;\n    // we can't check .prototype since constructors produced by .bind haven't it\n  } return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n};\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n  var called;\n  return isConstructorModern(isConstructorModern.call)\n    || !isConstructorModern(Object)\n    || !isConstructorModern(function () { called = true; })\n    || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","var fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value == POLYFILL ? true\n    : value == NATIVE ? false\n    : isCallable(detection) ? fails(detection)\n    : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","var isObject = require('../internals/is-object');\n\nvar floor = Math.floor;\n\n// `IsIntegralNumber` abstract operation\n// https://tc39.es/ecma262/#sec-isintegralnumber\n// eslint-disable-next-line es/no-number-isinteger -- safe\nmodule.exports = Number.isInteger || function isInteger(it) {\n  return !isObject(it) && isFinite(it) && floor(it) === it;\n};\n","var isCallable = require('../internals/is-callable');\n\nmodule.exports = function (it) {\n  return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","module.exports = false;\n","var global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Object = global.Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n  return typeof it == 'symbol';\n} : function (it) {\n  var $Symbol = getBuiltIn('Symbol');\n  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, Object(it));\n};\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar TypeError = global.TypeError;\n\nvar Result = function (stopped, result) {\n  this.stopped = stopped;\n  this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n  var that = options && options.that;\n  var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n  var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n  var INTERRUPTED = !!(options && options.INTERRUPTED);\n  var fn = bind(unboundFunction, that);\n  var iterator, iterFn, index, length, result, next, step;\n\n  var stop = function (condition) {\n    if (iterator) iteratorClose(iterator, 'normal', condition);\n    return new Result(true, condition);\n  };\n\n  var callFn = function (value) {\n    if (AS_ENTRIES) {\n      anObject(value);\n      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n    } return INTERRUPTED ? fn(value, stop) : fn(value);\n  };\n\n  if (IS_ITERATOR) {\n    iterator = iterable;\n  } else {\n    iterFn = getIteratorMethod(iterable);\n    if (!iterFn) throw TypeError(tryToString(iterable) + ' is not iterable');\n    // optimisation for array iterators\n    if (isArrayIteratorMethod(iterFn)) {\n      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n        result = callFn(iterable[index]);\n        if (result && isPrototypeOf(ResultPrototype, result)) return result;\n      } return new Result(false);\n    }\n    iterator = getIterator(iterable, iterFn);\n  }\n\n  next = iterator.next;\n  while (!(step = call(next, iterator)).done) {\n    try {\n      result = callFn(step.value);\n    } catch (error) {\n      iteratorClose(iterator, 'throw', error);\n    }\n    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n  } return new Result(false);\n};\n","var call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n  var innerResult, innerError;\n  anObject(iterator);\n  try {\n    innerResult = getMethod(iterator, 'return');\n    if (!innerResult) {\n      if (kind === 'throw') throw value;\n      return value;\n    }\n    innerResult = call(innerResult, iterator);\n  } catch (error) {\n    innerError = true;\n    innerResult = error;\n  }\n  if (kind === 'throw') throw value;\n  if (innerError) throw innerResult;\n  anObject(innerResult);\n  return value;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n  arrayIterator = [].keys();\n  // Safari 8 has buggy iterators w/o `next`\n  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n  else {\n    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n  }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () {\n  var test = {};\n  // FF44- legacy iterators case\n  return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n  redefine(IteratorPrototype, ITERATOR, function () {\n    return this;\n  });\n}\n\nmodule.exports = {\n  IteratorPrototype: IteratorPrototype,\n  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","module.exports = {};\n","var toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n  return toLength(obj.length);\n};\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\n\nvar flush, head, last, notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!queueMicrotask) {\n  flush = function () {\n    var parent, fn;\n    if (IS_NODE && (parent = process.domain)) parent.exit();\n    while (head) {\n      fn = head.fn;\n      head = head.next;\n      try {\n        fn();\n      } catch (error) {\n        if (head) notify();\n        else last = undefined;\n        throw error;\n      }\n    } last = undefined;\n    if (parent) parent.enter();\n  };\n\n  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n  if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n    toggle = true;\n    node = document.createTextNode('');\n    new MutationObserver(flush).observe(node, { characterData: true });\n    notify = function () {\n      node.data = toggle = !toggle;\n    };\n  // environments with maybe non-completely correct, but existent Promise\n  } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n    // Promise.resolve without an argument throws an error in LG WebOS 2\n    promise = Promise.resolve(undefined);\n    // workaround of WebKit ~ iOS Safari 10.1 bug\n    promise.constructor = Promise;\n    then = bind(promise.then, promise);\n    notify = function () {\n      then(flush);\n    };\n  // Node.js without promises\n  } else if (IS_NODE) {\n    notify = function () {\n      process.nextTick(flush);\n    };\n  // for other environments - macrotask based on:\n  // - setImmediate\n  // - MessageChannel\n  // - window.postMessag\n  // - onreadystatechange\n  // - setTimeout\n  } else {\n    // strange IE + webpack dev server bug - use .bind(global)\n    macrotask = bind(macrotask, global);\n    notify = function () {\n      macrotask(flush);\n    };\n  }\n}\n\nmodule.exports = queueMicrotask || function (fn) {\n  var task = { fn: fn, next: undefined };\n  if (last) last.next = task;\n  if (!head) {\n    head = task;\n    notify();\n  } last = task;\n};\n","var global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  var symbol = Symbol();\n  // Chrome 38 Symbol has incorrect toString conversion\n  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n  return !String(symbol) || !(Object(symbol) instanceof Symbol) ||\n    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n    !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(inspectSource(WeakMap));\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar PromiseCapability = function (C) {\n  var resolve, reject;\n  this.promise = new C(function ($$resolve, $$reject) {\n    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');\n    resolve = $$resolve;\n    reject = $$reject;\n  });\n  this.resolve = aCallable(resolve);\n  this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n  return new PromiseCapability(C);\n};\n","var toString = require('../internals/to-string');\n\nmodule.exports = function (argument, $default) {\n  return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);\n};\n","var global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toString = require('../internals/to-string');\nvar trim = require('../internals/string-trim').trim;\nvar whitespaces = require('../internals/whitespaces');\n\nvar charAt = uncurryThis(''.charAt);\nvar n$ParseFloat = global.parseFloat;\nvar Symbol = global.Symbol;\nvar ITERATOR = Symbol && Symbol.iterator;\nvar FORCED = 1 / n$ParseFloat(whitespaces + '-0') !== -Infinity\n  // MS Edge 18- broken with boxed symbols\n  || (ITERATOR && !fails(function () { n$ParseFloat(Object(ITERATOR)); }));\n\n// `parseFloat` method\n// https://tc39.es/ecma262/#sec-parsefloat-string\nmodule.exports = FORCED ? function parseFloat(string) {\n  var trimmedString = trim(toString(string));\n  var result = n$ParseFloat(trimmedString);\n  return result === 0 && charAt(trimmedString, 0) == '-' ? -0 : result;\n} : n$ParseFloat;\n","var global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toString = require('../internals/to-string');\nvar trim = require('../internals/string-trim').trim;\nvar whitespaces = require('../internals/whitespaces');\n\nvar $parseInt = global.parseInt;\nvar Symbol = global.Symbol;\nvar ITERATOR = Symbol && Symbol.iterator;\nvar hex = /^[+-]?0x/i;\nvar exec = uncurryThis(hex.exec);\nvar FORCED = $parseInt(whitespaces + '08') !== 8 || $parseInt(whitespaces + '0x16') !== 22\n  // MS Edge 18- broken with boxed symbols\n  || (ITERATOR && !fails(function () { $parseInt(Object(ITERATOR)); }));\n\n// `parseInt` method\n// https://tc39.es/ecma262/#sec-parseint-string-radix\nmodule.exports = FORCED ? function parseInt(string, radix) {\n  var S = trim(toString(string));\n  return $parseInt(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10));\n} : $parseInt;\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n  // should have correct order of operations (Edge bug)\n  if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n    enumerable: true,\n    get: function () {\n      defineProperty(this, 'b', {\n        value: 3,\n        enumerable: false\n      });\n    }\n  }), { b: 2 })).b !== 1) return true;\n  // should work with symbols and should have deterministic property order (V8 bug)\n  var A = {};\n  var B = {};\n  // eslint-disable-next-line es/no-symbol -- safe\n  var symbol = Symbol();\n  var alphabet = 'abcdefghijklmnopqrst';\n  A[symbol] = 7;\n  alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n  return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n  var T = toObject(target);\n  var argumentsLength = arguments.length;\n  var index = 1;\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  var propertyIsEnumerable = propertyIsEnumerableModule.f;\n  while (argumentsLength > index) {\n    var S = IndexedObject(arguments[index++]);\n    var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n    var length = keys.length;\n    var j = 0;\n    var key;\n    while (length > j) {\n      key = keys[j++];\n      if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n    }\n  } return T;\n} : $assign;\n","/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar defineProperties = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    activeXDocument = new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = typeof document != 'undefined'\n    ? document.domain && activeXDocument\n      ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n      : NullProtoObjectViaIFrame()\n    : NullProtoObjectViaActiveX(activeXDocument); // WSH\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : defineProperties(result, Properties);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var props = toIndexedObject(Properties);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n  return O;\n};\n","var global = require('../internals/global');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar TypeError = global.TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPropertyKey(P);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return $defineProperty(O, P, Attributes);\n  } catch (error) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPropertyKey(P);\n  if (IE8_DOM_DEFINE) try {\n    return $getOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n  try {\n    return $getOwnPropertyNames(it);\n  } catch (error) {\n    return arraySlice(windowNames);\n  }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n  return windowNames && classof(it) == 'Window'\n    ? getWindowNames(it)\n    : $getOwnPropertyNames(toIndexedObject(it));\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","var global = require('../internals/global');\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar Object = global.Object;\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n  var object = toObject(O);\n  if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n  var constructor = object.constructor;\n  if (isCallable(constructor) && object instanceof constructor) {\n    return constructor.prototype;\n  } return object instanceof Object ? ObjectPrototype : null;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (hasOwn(O, key = names[i++])) {\n    ~indexOf(result, key) || push(result, key);\n  }\n  return result;\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","/* eslint-disable no-proto -- safe */\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n  var CORRECT_SETTER = false;\n  var test = {};\n  var setter;\n  try {\n    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n    setter = uncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);\n    setter(test, []);\n    CORRECT_SETTER = test instanceof Array;\n  } catch (error) { /* empty */ }\n  return function setPrototypeOf(O, proto) {\n    anObject(O);\n    aPossiblePrototype(proto);\n    if (CORRECT_SETTER) setter(O, proto);\n    else O.__proto__ = proto;\n    return O;\n  };\n}() : undefined);\n","var DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\nvar propertyIsEnumerable = uncurryThis($propertyIsEnumerable);\nvar push = uncurryThis([].push);\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n  return function (it) {\n    var O = toIndexedObject(it);\n    var keys = objectKeys(O);\n    var length = keys.length;\n    var i = 0;\n    var result = [];\n    var key;\n    while (length > i) {\n      key = keys[i++];\n      if (!DESCRIPTORS || propertyIsEnumerable(O, key)) {\n        push(result, TO_ENTRIES ? [key, O[key]] : O[key]);\n      }\n    }\n    return result;\n  };\n};\n\nmodule.exports = {\n  // `Object.entries` method\n  // https://tc39.es/ecma262/#sec-object.entries\n  entries: createMethod(true),\n  // `Object.values` method\n  // https://tc39.es/ecma262/#sec-object.values\n  values: createMethod(false)\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n  return '[object ' + classof(this) + ']';\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar TypeError = global.TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n  var fn, val;\n  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","var getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = getOwnPropertyNamesModule.f(anObject(it));\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","module.exports = function (exec) {\n  try {\n    return { error: false, value: exec() };\n  } catch (error) {\n    return { error: true, value: error };\n  }\n};\n","var anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n  anObject(C);\n  if (isObject(x) && x.constructor === C) return x;\n  var promiseCapability = newPromiseCapability.f(C);\n  var resolve = promiseCapability.resolve;\n  resolve(x);\n  return promiseCapability.promise;\n};\n","var redefine = require('../internals/redefine');\n\nmodule.exports = function (target, src, options) {\n  for (var key in src) redefine(target, key, src[key], options);\n  return target;\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n  var unsafe = options ? !!options.unsafe : false;\n  var simple = options ? !!options.enumerable : false;\n  var noTargetGet = options ? !!options.noTargetGet : false;\n  var name = options && options.name !== undefined ? options.name : key;\n  var state;\n  if (isCallable(value)) {\n    if (String(name).slice(0, 7) === 'Symbol(') {\n      name = '[' + String(name).replace(/^Symbol\\(([^)]*)\\)/, '$1') + ']';\n    }\n    if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n      createNonEnumerableProperty(value, 'name', name);\n    }\n    state = enforceInternalState(value);\n    if (!state.source) {\n      state.source = TEMPLATE.join(typeof name == 'string' ? name : '');\n    }\n  }\n  if (O === global) {\n    if (simple) O[key] = value;\n    else setGlobal(key, value);\n    return;\n  } else if (!unsafe) {\n    delete O[key];\n  } else if (!noTargetGet && O[key]) {\n    simple = true;\n  }\n  if (simple) O[key] = value;\n  else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n  return isCallable(this) && getInternalState(this).source || inspectSource(this);\n});\n","var global = require('../internals/global');\n\nvar TypeError = global.TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n  return it;\n};\n","var global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n  try {\n    defineProperty(global, key, { value: value, configurable: true, writable: true });\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar definePropertyModule = require('../internals/object-define-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n  var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n  var defineProperty = definePropertyModule.f;\n\n  if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n    defineProperty(Constructor, SPECIES, {\n      configurable: true,\n      get: function () { return this; }\n    });\n  }\n};\n","var defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (it, TAG, STATIC) {\n  if (it && !hasOwn(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {\n    defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });\n  }\n};\n","var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\n","var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n","var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: '3.19.0',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\n});\n","var anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n  var C = anObject(O).constructor;\n  var S;\n  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aConstructor(S);\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n  return function ($this, pos) {\n    var S = toString(requireObjectCoercible($this));\n    var position = toIntegerOrInfinity(pos);\n    var size = S.length;\n    var first, second;\n    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n    first = charCodeAt(S, position);\n    return first < 0xD800 || first > 0xDBFF || position + 1 === size\n      || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n        ? CONVERT_TO_STRING\n          ? charAt(S, position)\n          : first\n        : CONVERT_TO_STRING\n          ? stringSlice(S, position, position + 2)\n          : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.codePointAt` method\n  // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n  codeAt: createMethod(false),\n  // `String.prototype.at` method\n  // https://github.com/mathiasbynens/String.prototype.at\n  charAt: createMethod(true)\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\nvar whitespaces = require('../internals/whitespaces');\n\nvar replace = uncurryThis(''.replace);\nvar whitespace = '[' + whitespaces + ']';\nvar ltrim = RegExp('^' + whitespace + whitespace + '*');\nvar rtrim = RegExp(whitespace + whitespace + '*$');\n\n// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation\nvar createMethod = function (TYPE) {\n  return function ($this) {\n    var string = toString(requireObjectCoercible($this));\n    if (TYPE & 1) string = replace(string, ltrim, '');\n    if (TYPE & 2) string = replace(string, rtrim, '');\n    return string;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.{ trimLeft, trimStart }` methods\n  // https://tc39.es/ecma262/#sec-string.prototype.trimstart\n  start: createMethod(1),\n  // `String.prototype.{ trimRight, trimEnd }` methods\n  // https://tc39.es/ecma262/#sec-string.prototype.trimend\n  end: createMethod(2),\n  // `String.prototype.trim` method\n  // https://tc39.es/ecma262/#sec-string.prototype.trim\n  trim: createMethod(3)\n};\n","var global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar location, defer, channel, port;\n\ntry {\n  // Deno throws a ReferenceError on `location` access without `--location` flag\n  location = global.location;\n} catch (error) { /* empty */ }\n\nvar run = function (id) {\n  if (hasOwn(queue, id)) {\n    var fn = queue[id];\n    delete queue[id];\n    fn();\n  }\n};\n\nvar runner = function (id) {\n  return function () {\n    run(id);\n  };\n};\n\nvar listener = function (event) {\n  run(event.data);\n};\n\nvar post = function (id) {\n  // old engines have not location.origin\n  global.postMessage(String(id), location.protocol + '//' + location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n  set = function setImmediate(fn) {\n    var args = arraySlice(arguments, 1);\n    queue[++counter] = function () {\n      apply(isCallable(fn) ? fn : Function(fn), undefined, args);\n    };\n    defer(counter);\n    return counter;\n  };\n  clear = function clearImmediate(id) {\n    delete queue[id];\n  };\n  // Node.js 0.8-\n  if (IS_NODE) {\n    defer = function (id) {\n      process.nextTick(runner(id));\n    };\n  // Sphere (JS game engine) Dispatch API\n  } else if (Dispatch && Dispatch.now) {\n    defer = function (id) {\n      Dispatch.now(runner(id));\n    };\n  // Browsers with MessageChannel, includes WebWorkers\n  // except iOS - https://github.com/zloirock/core-js/issues/624\n  } else if (MessageChannel && !IS_IOS) {\n    channel = new MessageChannel();\n    port = channel.port2;\n    channel.port1.onmessage = listener;\n    defer = bind(port.postMessage, port);\n  // Browsers with postMessage, skip WebWorkers\n  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n  } else if (\n    global.addEventListener &&\n    isCallable(global.postMessage) &&\n    !global.importScripts &&\n    location && location.protocol !== 'file:' &&\n    !fails(post)\n  ) {\n    defer = post;\n    global.addEventListener('message', listener, false);\n  // IE8-\n  } else if (ONREADYSTATECHANGE in createElement('script')) {\n    defer = function (id) {\n      html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n        html.removeChild(this);\n        run(id);\n      };\n    };\n  // Rest old browsers\n  } else {\n    defer = function (id) {\n      setTimeout(runner(id), 0);\n    };\n  }\n}\n\nmodule.exports = {\n  set: set,\n  clear: clear\n};\n","var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n  var integer = toIntegerOrInfinity(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n  return IndexedObject(requireObjectCoercible(it));\n};\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n  var number = +argument;\n  // eslint-disable-next-line no-self-compare -- safe\n  return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number);\n};\n","var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","var global = require('../internals/global');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar Object = global.Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n  return Object(requireObjectCoercible(argument));\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TypeError = global.TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n  if (!isObject(input) || isSymbol(input)) return input;\n  var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n  var result;\n  if (exoticToPrim) {\n    if (pref === undefined) pref = 'default';\n    result = call(exoticToPrim, input, pref);\n    if (!isObject(result) || isSymbol(result)) return result;\n    throw TypeError(\"Can't convert object to primitive value\");\n  }\n  if (pref === undefined) pref = 'number';\n  return ordinaryToPrimitive(input, pref);\n};\n","var toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n  var key = toPrimitive(argument, 'string');\n  return isSymbol(key) ? key : key + '';\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","var global = require('../internals/global');\nvar classof = require('../internals/classof');\n\nvar String = global.String;\n\nmodule.exports = function (argument) {\n  if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');\n  return String(argument);\n};\n","var global = require('../internals/global');\n\nvar String = global.String;\n\nmodule.exports = function (argument) {\n  try {\n    return String(argument);\n  } catch (error) {\n    return 'Object';\n  }\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  && !Symbol.sham\n  && typeof Symbol.iterator == 'symbol';\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar symbolFor = Symbol && Symbol['for'];\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!hasOwn(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {\n    var description = 'Symbol.' + name;\n    if (NATIVE_SYMBOL && hasOwn(Symbol, name)) {\n      WellKnownSymbolsStore[name] = Symbol[name];\n    } else if (USE_SYMBOL_AS_UID && symbolFor) {\n      WellKnownSymbolsStore[name] = symbolFor(description);\n    } else {\n      WellKnownSymbolsStore[name] = createWellKnownSymbol(description);\n    }\n  } return WellKnownSymbolsStore[name];\n};\n","// a string of all valid unicode whitespaces\nmodule.exports = '\\u0009\\u000A\\u000B\\u000C\\u000D\\u0020\\u00A0\\u1680\\u2000\\u2001\\u2002' +\n  '\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF';\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar create = require('../internals/object-create');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar clearErrorStack = require('../internals/clear-error-stack');\nvar installErrorCause = require('../internals/install-error-cause');\nvar iterate = require('../internals/iterate');\nvar normalizeStringArgument = require('../internals/normalize-string-argument');\nvar ERROR_STACK_INSTALLABLE = require('../internals/error-stack-installable');\n\nvar Error = global.Error;\nvar push = [].push;\n\nvar $AggregateError = function AggregateError(errors, message /* , options */) {\n  var that = isPrototypeOf(AggregateErrorPrototype, this) ? this : create(AggregateErrorPrototype);\n  var options = arguments.length > 2 ? arguments[2] : undefined;\n  if (setPrototypeOf) {\n    that = setPrototypeOf(new Error(undefined), getPrototypeOf(that));\n  }\n  createNonEnumerableProperty(that, 'message', normalizeStringArgument(message, ''));\n  if (ERROR_STACK_INSTALLABLE) createNonEnumerableProperty(that, 'stack', clearErrorStack(that.stack, 1));\n  installErrorCause(that, options);\n  var errorsArray = [];\n  iterate(errors, push, { that: errorsArray });\n  createNonEnumerableProperty(that, 'errors', errorsArray);\n  return that;\n};\n\nif (setPrototypeOf) setPrototypeOf($AggregateError, Error);\nelse copyConstructorProperties($AggregateError, Error);\n\nvar AggregateErrorPrototype = $AggregateError.prototype = create(Error.prototype, {\n  constructor: createPropertyDescriptor(1, $AggregateError),\n  message: createPropertyDescriptor(1, ''),\n  name: createPropertyDescriptor(1, 'AggregateError')\n});\n\n// `AggregateError` constructor\n// https://tc39.es/ecma262/#sec-aggregate-error-constructor\n$({ global: true }, {\n  AggregateError: $AggregateError\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar $find = require('../internals/array-iteration').find;\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\nvar FIND = 'find';\nvar SKIPS_HOLES = true;\n\n// Shouldn't skip holes\nif (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });\n\n// `Array.prototype.find` method\n// https://tc39.es/ecma262/#sec-array.prototype.find\n$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {\n  find: function find(callbackfn /* , that = undefined */) {\n    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables(FIND);\n","var $ = require('../internals/export');\nvar from = require('../internals/array-from');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\n\nvar INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {\n  // eslint-disable-next-line es/no-array-from -- required for testing\n  Array.from(iterable);\n});\n\n// `Array.from` method\n// https://tc39.es/ecma262/#sec-array.from\n$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {\n  from: from\n});\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n  setInternalState(this, {\n    type: ARRAY_ITERATOR,\n    target: toIndexedObject(iterated), // target\n    index: 0,                          // next index\n    kind: kind                         // kind\n  });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n  var state = getInternalState(this);\n  var target = state.target;\n  var kind = state.kind;\n  var index = state.index++;\n  if (!target || index >= target.length) {\n    state.target = undefined;\n    return { value: undefined, done: true };\n  }\n  if (kind == 'keys') return { value: index, done: false };\n  if (kind == 'values') return { value: target[index], done: false };\n  return { value: [index, target[index]], done: false };\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.es/ecma262/#sec-map-objects\ncollection('Map', function (init) {\n  return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","var $ = require('../internals/export');\nvar isIntegralNumber = require('../internals/is-integral-number');\n\n// `Number.isInteger` method\n// https://tc39.es/ecma262/#sec-number.isinteger\n$({ target: 'Number', stat: true }, {\n  isInteger: isIntegralNumber\n});\n","var $ = require('../internals/export');\n\n// `Number.isNaN` method\n// https://tc39.es/ecma262/#sec-number.isnan\n$({ target: 'Number', stat: true }, {\n  isNaN: function isNaN(number) {\n    // eslint-disable-next-line no-self-compare -- NaN check\n    return number != number;\n  }\n});\n","var $ = require('../internals/export');\nvar parseFloat = require('../internals/number-parse-float');\n\n// `Number.parseFloat` method\n// https://tc39.es/ecma262/#sec-number.parseFloat\n// eslint-disable-next-line es/no-number-parsefloat -- required for testing\n$({ target: 'Number', stat: true, forced: Number.parseFloat != parseFloat }, {\n  parseFloat: parseFloat\n});\n","var $ = require('../internals/export');\nvar parseInt = require('../internals/number-parse-int');\n\n// `Number.parseInt` method\n// https://tc39.es/ecma262/#sec-number.parseint\n// eslint-disable-next-line es/no-number-parseint -- required for testing\n$({ target: 'Number', stat: true, forced: Number.parseInt != parseInt }, {\n  parseInt: parseInt\n});\n","var $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, forced: Object.assign !== assign }, {\n  assign: assign\n});\n","var $ = require('../internals/export');\nvar $entries = require('../internals/object-to-array').entries;\n\n// `Object.entries` method\n// https://tc39.es/ecma262/#sec-object.entries\n$({ target: 'Object', stat: true }, {\n  entries: function entries(O) {\n    return $entries(O);\n  }\n});\n","var $ = require('../internals/export');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n$({ target: 'Object', stat: true }, {\n  setPrototypeOf: setPrototypeOf\n});\n","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar redefine = require('../internals/redefine');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n  redefine(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-promise.allsettled\n$({ target: 'Promise', stat: true }, {\n  allSettled: function allSettled(iterable) {\n    var C = this;\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aCallable(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        remaining++;\n        call(promiseResolve, C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'fulfilled', value: value };\n          --remaining || resolve(values);\n        }, function (error) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'rejected', reason: error };\n          --remaining || resolve(values);\n        });\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar aCallable = require('../internals/a-callable');\nvar getBuiltIn = require('../internals/get-built-in');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\nvar PROMISE_ANY_ERROR = 'No one promise resolved';\n\n// `Promise.any` method\n// https://tc39.es/ecma262/#sec-promise.any\n$({ target: 'Promise', stat: true }, {\n  any: function any(iterable) {\n    var C = this;\n    var AggregateError = getBuiltIn('AggregateError');\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aCallable(C.resolve);\n      var errors = [];\n      var counter = 0;\n      var remaining = 1;\n      var alreadyResolved = false;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyRejected = false;\n        remaining++;\n        call(promiseResolve, C, promise).then(function (value) {\n          if (alreadyRejected || alreadyResolved) return;\n          alreadyResolved = true;\n          resolve(value);\n        }, function (error) {\n          if (alreadyRejected || alreadyResolved) return;\n          alreadyRejected = true;\n          errors[index] = error;\n          --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));\n        });\n      });\n      --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar fails = require('../internals/fails');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar speciesConstructor = require('../internals/species-constructor');\nvar promiseResolve = require('../internals/promise-resolve');\nvar redefine = require('../internals/redefine');\n\n// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829\nvar NON_GENERIC = !!NativePromise && fails(function () {\n  NativePromise.prototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });\n});\n\n// `Promise.prototype.finally` method\n// https://tc39.es/ecma262/#sec-promise.prototype.finally\n$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {\n  'finally': function (onFinally) {\n    var C = speciesConstructor(this, getBuiltIn('Promise'));\n    var isFunction = isCallable(onFinally);\n    return this.then(\n      isFunction ? function (x) {\n        return promiseResolve(C, onFinally()).then(function () { return x; });\n      } : onFinally,\n      isFunction ? function (e) {\n        return promiseResolve(C, onFinally()).then(function () { throw e; });\n      } : onFinally\n    );\n  }\n});\n\n// makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromise)) {\n  var method = getBuiltIn('Promise').prototype['finally'];\n  if (NativePromise.prototype['finally'] !== method) {\n    redefine(NativePromise.prototype, 'finally', method, { unsafe: true });\n  }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar call = require('../internals/function-call');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar redefine = require('../internals/redefine');\nvar redefineAll = require('../internals/redefine-all');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar inspectSource = require('../internals/inspect-source');\nvar iterate = require('../internals/iterate');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar promiseResolve = require('../internals/promise-resolve');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar InternalStateModule = require('../internals/internal-state');\nvar isForced = require('../internals/is-forced');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_NODE = require('../internals/engine-is-node');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\nvar PROMISE = 'Promise';\n\nvar getInternalState = InternalStateModule.get;\nvar setInternalState = InternalStateModule.set;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar NativePromisePrototype = NativePromise && NativePromise.prototype;\nvar PromiseConstructor = NativePromise;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar NATIVE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\nvar SUBCLASSING = false;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\nvar FORCED = isForced(PROMISE, function () {\n  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);\n  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);\n  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n  // We can't detect it synchronously, so just check versions\n  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n  // We need Promise#finally in the pure version for preventing prototype pollution\n  if (IS_PURE && !PromisePrototype['finally']) return true;\n  // We can't use @@species feature detection in V8 since it causes\n  // deoptimization and performance degradation\n  // https://github.com/zloirock/core-js/issues/679\n  if (V8_VERSION >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false;\n  // Detect correctness of subclassing with @@species support\n  var promise = new PromiseConstructor(function (resolve) { resolve(1); });\n  var FakePromise = function (exec) {\n    exec(function () { /* empty */ }, function () { /* empty */ });\n  };\n  var constructor = promise.constructor = {};\n  constructor[SPECIES] = FakePromise;\n  SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n  if (!SUBCLASSING) return true;\n  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n  return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;\n});\n\nvar INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {\n  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });\n});\n\n// helpers\nvar isThenable = function (it) {\n  var then;\n  return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar notify = function (state, isReject) {\n  if (state.notified) return;\n  state.notified = true;\n  var chain = state.reactions;\n  microtask(function () {\n    var value = state.value;\n    var ok = state.state == FULFILLED;\n    var index = 0;\n    // variable length - can't use forEach\n    while (chain.length > index) {\n      var reaction = chain[index++];\n      var handler = ok ? reaction.ok : reaction.fail;\n      var resolve = reaction.resolve;\n      var reject = reaction.reject;\n      var domain = reaction.domain;\n      var result, then, exited;\n      try {\n        if (handler) {\n          if (!ok) {\n            if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n            state.rejection = HANDLED;\n          }\n          if (handler === true) result = value;\n          else {\n            if (domain) domain.enter();\n            result = handler(value); // can throw\n            if (domain) {\n              domain.exit();\n              exited = true;\n            }\n          }\n          if (result === reaction.promise) {\n            reject(TypeError('Promise-chain cycle'));\n          } else if (then = isThenable(result)) {\n            call(then, result, resolve, reject);\n          } else resolve(result);\n        } else reject(value);\n      } catch (error) {\n        if (domain && !exited) domain.exit();\n        reject(error);\n      }\n    }\n    state.reactions = [];\n    state.notified = false;\n    if (isReject && !state.rejection) onUnhandled(state);\n  });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n  var event, handler;\n  if (DISPATCH_EVENT) {\n    event = document.createEvent('Event');\n    event.promise = promise;\n    event.reason = reason;\n    event.initEvent(name, false, true);\n    global.dispatchEvent(event);\n  } else event = { promise: promise, reason: reason };\n  if (!NATIVE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n  call(task, global, function () {\n    var promise = state.facade;\n    var value = state.value;\n    var IS_UNHANDLED = isUnhandled(state);\n    var result;\n    if (IS_UNHANDLED) {\n      result = perform(function () {\n        if (IS_NODE) {\n          process.emit('unhandledRejection', value, promise);\n        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n      });\n      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n      state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n      if (result.error) throw result.value;\n    }\n  });\n};\n\nvar isUnhandled = function (state) {\n  return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n  call(task, global, function () {\n    var promise = state.facade;\n    if (IS_NODE) {\n      process.emit('rejectionHandled', promise);\n    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n  });\n};\n\nvar bind = function (fn, state, unwrap) {\n  return function (value) {\n    fn(state, value, unwrap);\n  };\n};\n\nvar internalReject = function (state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  state.value = value;\n  state.state = REJECTED;\n  notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  try {\n    if (state.facade === value) throw TypeError(\"Promise can't be resolved itself\");\n    var then = isThenable(value);\n    if (then) {\n      microtask(function () {\n        var wrapper = { done: false };\n        try {\n          call(then, value,\n            bind(internalResolve, wrapper, state),\n            bind(internalReject, wrapper, state)\n          );\n        } catch (error) {\n          internalReject(wrapper, error, state);\n        }\n      });\n    } else {\n      state.value = value;\n      state.state = FULFILLED;\n      notify(state, false);\n    }\n  } catch (error) {\n    internalReject({ done: false }, error, state);\n  }\n};\n\n// constructor polyfill\nif (FORCED) {\n  // 25.4.3.1 Promise(executor)\n  PromiseConstructor = function Promise(executor) {\n    anInstance(this, PromisePrototype);\n    aCallable(executor);\n    call(Internal, this);\n    var state = getInternalState(this);\n    try {\n      executor(bind(internalResolve, state), bind(internalReject, state));\n    } catch (error) {\n      internalReject(state, error);\n    }\n  };\n  PromisePrototype = PromiseConstructor.prototype;\n  // eslint-disable-next-line no-unused-vars -- required for `.length`\n  Internal = function Promise(executor) {\n    setInternalState(this, {\n      type: PROMISE,\n      done: false,\n      notified: false,\n      parent: false,\n      reactions: [],\n      rejection: false,\n      state: PENDING,\n      value: undefined\n    });\n  };\n  Internal.prototype = redefineAll(PromisePrototype, {\n    // `Promise.prototype.then` method\n    // https://tc39.es/ecma262/#sec-promise.prototype.then\n    then: function then(onFulfilled, onRejected) {\n      var state = getInternalPromiseState(this);\n      var reactions = state.reactions;\n      var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n      reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n      reaction.fail = isCallable(onRejected) && onRejected;\n      reaction.domain = IS_NODE ? process.domain : undefined;\n      state.parent = true;\n      reactions[reactions.length] = reaction;\n      if (state.state != PENDING) notify(state, false);\n      return reaction.promise;\n    },\n    // `Promise.prototype.catch` method\n    // https://tc39.es/ecma262/#sec-promise.prototype.catch\n    'catch': function (onRejected) {\n      return this.then(undefined, onRejected);\n    }\n  });\n  OwnPromiseCapability = function () {\n    var promise = new Internal();\n    var state = getInternalState(promise);\n    this.promise = promise;\n    this.resolve = bind(internalResolve, state);\n    this.reject = bind(internalReject, state);\n  };\n  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n    return C === PromiseConstructor || C === PromiseWrapper\n      ? new OwnPromiseCapability(C)\n      : newGenericPromiseCapability(C);\n  };\n\n  if (!IS_PURE && isCallable(NativePromise) && NativePromisePrototype !== Object.prototype) {\n    nativeThen = NativePromisePrototype.then;\n\n    if (!SUBCLASSING) {\n      // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n      redefine(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n        var that = this;\n        return new PromiseConstructor(function (resolve, reject) {\n          call(nativeThen, that, resolve, reject);\n        }).then(onFulfilled, onRejected);\n      // https://github.com/zloirock/core-js/issues/640\n      }, { unsafe: true });\n\n      // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\n      redefine(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });\n    }\n\n    // make `.constructor === Promise` work for native promise-based APIs\n    try {\n      delete NativePromisePrototype.constructor;\n    } catch (error) { /* empty */ }\n\n    // make `instanceof Promise` work for native promise-based APIs\n    if (setPrototypeOf) {\n      setPrototypeOf(NativePromisePrototype, PromisePrototype);\n    }\n  }\n}\n\n$({ global: true, wrap: true, forced: FORCED }, {\n  Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n\nPromiseWrapper = getBuiltIn(PROMISE);\n\n// statics\n$({ target: PROMISE, stat: true, forced: FORCED }, {\n  // `Promise.reject` method\n  // https://tc39.es/ecma262/#sec-promise.reject\n  reject: function reject(r) {\n    var capability = newPromiseCapability(this);\n    call(capability.reject, undefined, r);\n    return capability.promise;\n  }\n});\n\n$({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, {\n  // `Promise.resolve` method\n  // https://tc39.es/ecma262/#sec-promise.resolve\n  resolve: function resolve(x) {\n    return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);\n  }\n});\n\n$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {\n  // `Promise.all` method\n  // https://tc39.es/ecma262/#sec-promise.all\n  all: function all(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var $promiseResolve = aCallable(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        remaining++;\n        call($promiseResolve, C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = value;\n          --remaining || resolve(values);\n        }, reject);\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  },\n  // `Promise.race` method\n  // https://tc39.es/ecma262/#sec-promise.race\n  race: function race(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var reject = capability.reject;\n    var result = perform(function () {\n      var $promiseResolve = aCallable(C.resolve);\n      iterate(iterable, function (promise) {\n        call($promiseResolve, C, promise).then(capability.resolve, reject);\n      });\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n  setInternalState(this, {\n    type: STRING_ITERATOR,\n    string: toString(iterated),\n    index: 0\n  });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n  var state = getInternalState(this);\n  var string = state.string;\n  var index = state.index;\n  var point;\n  if (index >= string.length) return { value: undefined, done: true };\n  point = charAt(string, index);\n  state.index += point.length;\n  return { value: point, done: false };\n});\n","(function () {\n  var validator = new RegExp(\"^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$\", \"i\");\n\n  function gen(count) {\n    var out = \"\";\n    for (var i=0; i<count; i++) {\n      out += (((1+Math.random())*0x10000)|0).toString(16).substring(1);\n    }\n    return out;\n  }\n\n  function Guid(guid) {\n    if (!guid) throw new TypeError(\"Invalid argument; `value` has no value.\");\n      \n    this.value = Guid.EMPTY;\n    \n    if (guid && guid instanceof Guid) {\n      this.value = guid.toString();\n\n    } else if (guid && Object.prototype.toString.call(guid) === \"[object String]\" && Guid.isGuid(guid)) {\n      this.value = guid;\n    }\n    \n    this.equals = function(other) {\n      // Comparing string `value` against provided `guid` will auto-call\n      // toString on `guid` for comparison\n      return Guid.isGuid(other) && this.value == other;\n    };\n\n    this.isEmpty = function() {\n      return this.value === Guid.EMPTY;\n    };\n    \n    this.toString = function() {\n      return this.value;\n    };\n    \n    this.toJSON = function() {\n      return this.value;\n    };\n  };\n\n  Guid.EMPTY = \"00000000-0000-0000-0000-000000000000\";\n\n  Guid.isGuid = function(value) {\n    return value && (value instanceof Guid || validator.test(value.toString()));\n  };\n\n  Guid.create = function() {\n    return new Guid([gen(2), gen(1), gen(1), gen(1), gen(3)].join(\"-\"));\n  };\n\n  Guid.raw = function() {\n    return [gen(2), gen(1), gen(1), gen(1), gen(3)].join(\"-\");\n  };\n\n  if(typeof module != 'undefined' && module.exports) {\n    module.exports = Guid;\n  }\n  else if (typeof window != 'undefined') {\n    window.Guid = Guid;\n  }\n})();\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEvent } from './TableauEvent';\n\nexport class DashboardLayoutChangedEvent extends TableauEvent implements Contract.DashboardLayoutChangedEvent {\n  public constructor(public _dashboardLayoutChangeDetails: Contract.DashboardLayoutChangeDetails) {\n    super(Contract.TableauEventType.DashboardLayoutChanged);\n  }\n\n  public get dashboardLayoutChangeDetails(): Contract.DashboardLayoutChangeDetails {\n    return this._dashboardLayoutChangeDetails;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauError } from '@tableau/api-shared-js';\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\n\nexport class FilterChangedEvent extends TableauWorksheetEvent implements Contract.FilterChangedEvent {\n  public constructor(worksheet: Contract.ExtensionWorksheet, private _fieldName: string, private _fieldId?: string) {\n    super(TableauEventType.FilterChanged, worksheet);\n  }\n\n  public get fieldName(): string {\n    return this._fieldName;\n  }\n\n  public get fieldId(): string | undefined {\n    return this._fieldId;\n  }\n\n  public getFilterAsync(): Promise<Contract.Filter> {\n    return this._worksheet.getFiltersAsync().then<Contract.Filter>((filters) => {\n      // TODO: Filtering of the filters should eventually be done platform side.\n      const eventedFilter = this.fieldId\n        ? filters.find((filter) => filter.fieldId === this.fieldId, this)\n        : filters.find((filter) => filter.fieldName === this.fieldName, this);\n\n      if (!eventedFilter) {\n        // We shouldn't hit this unless the filter was removed from the worksheet\n        // after the event was raised.\n        throw new TableauError(ErrorCodes.MissingFilter, `cannot find filter: ${this._fieldName}`);\n      }\n\n      return eventedFilter;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\n\nexport class MarksSelectedEvent extends TableauWorksheetEvent implements Contract.MarksSelectedEvent {\n  public constructor(worksheet: Contract.ExtensionWorksheet) {\n    super(TableauEventType.MarkSelectionChanged, worksheet);\n  }\n\n  public getMarksAsync(): Promise<Contract.MarksCollection> {\n    return this.worksheet.getSelectedMarksAsync();\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, TableauEventType } from '@tableau/api-external-contract-js';\nimport { ApiServiceRegistry, ParametersService, ServiceNames, TableauError } from '@tableau/api-shared-js';\nimport { Parameter } from '../Models/Parameter';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { TableauSheetEvent } from './TableauSheetEvent';\n\nexport class ParameterChangedEvent extends TableauSheetEvent implements Contract.ParameterChangedEvent {\n  public constructor(private _globalFieldName: string, sheet: Contract.ExtensionSheet) {\n    super(TableauEventType.ParameterChanged, sheet);\n  }\n\n  public getParameterAsync(): Promise<Contract.Parameter> {\n    // Call down to our service to get the parameter back via its field name\n    const service = ApiServiceRegistry.get(ExtensionsRegistryId).getService<ParametersService>(ServiceNames.Parameters);\n    return service.findParameterByGlobalFieldNameAsync(this._globalFieldName).then((parameterImpl) => {\n      if (parameterImpl === undefined) {\n        throw new TableauError(ErrorCodes.MissingParameter, `Cannot find parameter: ${this._globalFieldName}`);\n      }\n\n      return new Parameter(parameterImpl, this.sheet);\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\n\nexport class SummaryDataChangedEvent extends TableauWorksheetEvent implements Contract.SummaryDataChangedEvent {\n  public constructor(worksheet: Contract.ExtensionWorksheet) {\n    super(TableauEventType.SummaryDataChanged, worksheet);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\n\nexport class TableauEvent implements Contract.TableauEvent {\n  private _type: TableauEventType;\n\n  public constructor(type: TableauEventType) {\n    this._type = type;\n  }\n\n  public get type(): TableauEventType {\n    return this._type;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauEvent } from './TableauEvent';\n\nexport class TableauSheetEvent extends TableauEvent implements Contract.TableauSheetEvent {\n  private _sheet: Contract.ExtensionSheet;\n\n  public get sheet(): Contract.ExtensionSheet {\n    return this._sheet;\n  }\n\n  public constructor(type: TableauEventType, sheet: Contract.ExtensionSheet) {\n    super(type);\n\n    this._sheet = sheet;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauSheetEvent } from './TableauSheetEvent';\n\nexport class TableauWorksheetEvent extends TableauSheetEvent implements Contract.TableauWorksheetEvent {\n  public get worksheet(): Contract.ExtensionWorksheet {\n    return this._worksheet;\n  }\n\n  public constructor(type: TableauEventType, protected _worksheet: Contract.ExtensionWorksheet) {\n    super(type, _worksheet);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEvent } from './TableauEvent';\n\nexport class WorkbookFormattingChangedEvent extends TableauEvent implements Contract.WorkbookFormattingChangedEvent {\n  public constructor(private _formatting: Contract.WorkbookFormatting) {\n    super(Contract.TableauEventType.WorkbookFormattingChanged);\n  }\n\n  public get formatting(): Contract.WorkbookFormatting {\n    return this._formatting;\n  }\n}\n","import { Model } from '@tableau/api-internal-contract-js';\n\nexport const BentonSansFontFamilyName = 'Benton Sans';\nexport const BentonSansLowDPIFontFamilyName = 'Benton Sans Low-DPI';\n\nexport const BentonSansBookFontFaceName = 'Benton Sans Book';\nexport const BentonSansBookItalicFontFaceName = 'Benton Sans Book Italic';\nexport const BentonSansSemiDemiFontFaceName = 'Benton Sans SemiDemi';\nexport const BentonSansSemiDemiItalicFontFaceName = 'Benton Sans SemiDemi Italic';\nexport const BentonSansLightFontFaceName = 'Benton Sans Light';\nexport const BentonSansMediumFontFaceName = 'Benton Sans Medium';\n\nexport const SupportedBentonSansFontFaces: Model[] = [\n  BentonSansBookFontFaceName,\n  BentonSansBookItalicFontFaceName,\n  BentonSansSemiDemiFontFaceName,\n  BentonSansSemiDemiItalicFontFaceName,\n  BentonSansLightFontFaceName,\n  BentonSansMediumFontFaceName,\n];\n","import * as Contract from '@tableau/api-external-contract-js';\n\nexport class ConnectedServer implements Contract.ConnectedServer {\n  public constructor(\n    protected _userId?: string,\n    protected _siteId?: string,\n    protected _siteNamespace?: string,\n    protected _workbookId?: string,\n  ) {}\n\n  public get userId(): string | undefined {\n    return this._userId;\n  }\n\n  public get siteId(): string | undefined {\n    return this._siteId;\n  }\n\n  public get siteNamespace(): string | undefined {\n    return this._siteNamespace;\n  }\n\n  public get workbookId(): string | undefined {\n    return this._workbookId;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataSchema, DataSource as DataSourceInfo } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, DataSource, DataSourceImpl, DataSourceService, ServiceNames, WorkbookImpl } from '@tableau/api-shared-js';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\n\nexport class ExtensionWorkbookImpl extends WorkbookImpl {\n  public getAllDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    const service = ApiServiceRegistry.get(ExtensionsRegistryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return service.getAllDataSourcesAsync().then<Array<Contract.DataSource>>((result) => {\n      const dataSchema: DataSchema = result;\n      const dataSources: Array<Contract.DataSource> = [];\n\n      // Loop through all data sources and add them.\n      Object.values(dataSchema.dataSources).forEach((ds) => {\n        dataSources.push(this.createDataSourceFromInfo(ds));\n      });\n\n      return dataSources;\n    });\n  }\n\n  private createDataSourceFromInfo(dataSourceInfo: DataSourceInfo): DataSource {\n    const dataSourceImpl = new DataSourceImpl(dataSourceInfo, ExtensionsRegistryId);\n    const dataSource = new DataSource(dataSourceImpl);\n    dataSourceImpl.initializeWithPublicInterfaces(dataSource);\n    return dataSource;\n  }\n}\n","import { ErrorCodes, SheetType } from '@tableau/api-external-contract-js';\nimport {\n  ContextMenuEvent,\n  DashboardExtensionLocator,\n  ExecuteParameters,\n  ExtensionDashboardInfo,\n  ExtensionLocator,\n  ExtensionSettingsInfo,\n  ExtensionWorksheetInfo,\n  FontNameAndInfo,\n  FormattingSheet,\n  INTERNAL_CONTRACT_VERSION,\n  InitializationOptions,\n  InternalApiDispatcher,\n  InternalApiDispatcherFactory,\n  Model,\n  NotificationId,\n  ParameterId,\n  SheetPath,\n  VerbId,\n  WorkbookFormatting,\n} from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  ApiVersion,\n  DashboardImpl,\n  NotificationService,\n  ServiceNames,\n  SheetInfoImpl,\n  TableauError,\n  VersionedExternalApiDispatcher,\n  VizService,\n  WorksheetImpl,\n  doCrossFrameBootstrap,\n  registerAllSharedServices,\n} from '@tableau/api-shared-js';\nimport { Dashboard } from '../Models/Dashboard';\nimport { Workbook } from '../Models/Workbook';\nimport { Worksheet } from '../Models/Worksheet';\nimport { DashboardContent } from '../Namespaces/DashboardContent';\nimport { Environment } from '../Namespaces/Environment';\nimport { Settings } from '../Namespaces/Settings';\nimport { UI } from '../Namespaces/UI';\nimport { WorksheetContent } from '../Namespaces/WorksheetContent';\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\nimport { InitializationService } from '../Services/InitializationService';\nimport { registerAllExtensionsServices, registerInitializationExtensionsServices } from '../Services/RegisterAllExtensionsServices';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { UIService } from '../Services/UIService';\nimport {\n  BentonSansBookFontFaceName,\n  BentonSansBookItalicFontFaceName,\n  BentonSansFontFamilyName,\n  BentonSansLightFontFaceName,\n  BentonSansLowDPIFontFamilyName,\n  BentonSansMediumFontFaceName,\n  BentonSansSemiDemiFontFaceName,\n  BentonSansSemiDemiItalicFontFaceName,\n  SupportedBentonSansFontFaces,\n} from './BentonSansFontNameConstants';\nimport { ExtensionWorkbookImpl } from './ExtensionWorkbookImpl';\nimport { LegacyInternalApiDispatcherHolder } from './LegacyInternalApiDispatcherHolder';\nimport { SettingsImpl } from './SettingsImpl';\nimport {\n  SupportedTableauFontFaces,\n  TableauBoldFontFaceName,\n  TableauBoldFontFamilyName,\n  TableauBookFontFaceName,\n  TableauBookFontFamilyName,\n  TableauLightFontFaceName,\n  TableauLightFontFamilyName,\n  TableauMediumFontFaceName,\n  TableauMediumFontFamilyName,\n  TableauRegularFontFaceName,\n  TableauRegularFontFamilyName,\n  TableauSemiBoldFontFaceName,\n  TableauSemiboldFontFamilyName,\n} from './TableauBookFontNameConstants';\nimport { UIImpl } from './UIImpl';\n\nexport type CallbackMap = { [key: string]: () => Record<string, unknown> };\n\nexport class ExtensionsImpl {\n  private _initializationPromise: Promise<string>;\n  private _styleElement: HTMLStyleElement;\n  public dashboardContent?: DashboardContent;\n  public worksheetContent?: WorksheetContent;\n  public environment: Environment;\n  public settings: Settings;\n  public ui: UI;\n  public workbook: Workbook;\n  public extensionZoneId: number;\n\n  public initializeAsync(isExtensionDialog: boolean, contextMenuCallbacks?: CallbackMap): Promise<string> {\n    if (!this._initializationPromise) {\n      this._initializationPromise = new Promise<string>((resolve, reject) => {\n        const initOptions: InitializationOptions = { isAlpha: ApiVersion.Instance.isAlpha };\n        // First thing we want to do is check to see if there is a desktop dispatcher already registered for us\n        if (LegacyInternalApiDispatcherHolder.hasDesktopApiDispatcherPromise(initOptions)) {\n          // Running in a pre-2019.3 desktop, use our legacy dispatcher promise\n          const desktopDispatcherPromise = LegacyInternalApiDispatcherHolder.getDesktopDispatcherPromise(initOptions);\n          desktopDispatcherPromise\n            ?.then((dispatcherFactory) => this.onDispatcherReceived(dispatcherFactory, isExtensionDialog, contextMenuCallbacks))\n            .then((openPayload) => {\n              resolve(openPayload);\n            })\n            .catch((error) => {\n              reject(error);\n            });\n        } else {\n          // We must be running in server, so we should try to kick of the server dispatcher bootstrapping\n          const onDispatcherReceivedCallback = this.onDispatcherReceived.bind(this);\n          doCrossFrameBootstrap(window, INTERNAL_CONTRACT_VERSION, initOptions)\n            .then((factory: InternalApiDispatcherFactory) => {\n              return onDispatcherReceivedCallback(factory, isExtensionDialog, contextMenuCallbacks);\n            })\n            .then((openPayload) => {\n              resolve(openPayload);\n            })\n            .catch((error) => {\n              reject(error);\n            });\n        }\n      });\n    }\n\n    return this._initializationPromise;\n  }\n\n  public createVizImageAsync(inputSpec: object): Promise<string> {\n    const vizService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<VizService>(ServiceNames.Viz);\n\n    return vizService.createVizImageAsync(inputSpec);\n  }\n\n  public setClickThroughAsync(clickThroughEnabled: boolean): Promise<void> {\n    const uiService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<UIService>(ExtensionsServiceNames.UIService);\n\n    return uiService.setClickThroughAsync(clickThroughEnabled, this.extensionZoneId);\n  }\n\n  private isDashboardExtensionLocator(locator: ExtensionLocator): locator is DashboardExtensionLocator {\n    const dashboardExtensionLocator = locator as DashboardExtensionLocator;\n    if (!dashboardExtensionLocator.dashboardPath) {\n      throw new TableauError(ErrorCodes.InternalError, 'Unexpected error during initialization.');\n    }\n    return true;\n  }\n\n  private onDispatcherReceived(\n    dispatcherFactory: InternalApiDispatcherFactory,\n    isExtensionDialog: boolean,\n    contextMenuFunctions?: CallbackMap,\n  ): Promise<string> {\n    let dispatcher: InternalApiDispatcher = dispatcherFactory(INTERNAL_CONTRACT_VERSION);\n\n    // Call to register all the services which will use the newly initialized dispatcher\n    registerInitializationExtensionsServices(dispatcher);\n\n    // Get the initialization service and initialize this extension\n    const initializationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<InitializationService>(\n      ExtensionsServiceNames.InitializationService,\n    );\n\n    const callbackMapKeys = contextMenuFunctions ? Object.keys(contextMenuFunctions) : [];\n    return initializationService.initializeDashboardExtensionsAsync(isExtensionDialog, callbackMapKeys).then<string>((result) => {\n      // If we receive an invalid plaform version, this means that platform is runnning 1.4 or 2.1 and\n      // doesn't pass the platform version to external. In this case we assume the platform version to be 1.9\n      const platformVersion = result.extensionEnvironment.platformVersion\n        ? result.extensionEnvironment.platformVersion\n        : { major: 1, minor: 9, fix: 0 };\n\n      // Wrap our existing dispatcher in a dispatcher that can downgrade/upgrade for an older platform.\n      if (VersionedExternalApiDispatcher.needsVersionConverter(platformVersion)) {\n        dispatcher = new VersionedExternalApiDispatcher(dispatcher, platformVersion);\n      }\n      // Registration of services must happen before initializing content and environment\n      // Extensions doesn't need to pass in a registryId. By default, the service registry instance is associated with registryId=0.\n      registerAllSharedServices(dispatcher, ExtensionsRegistryId, platformVersion);\n      registerAllExtensionsServices(dispatcher);\n\n      if (result.extensionDashboardInfo && this.isDashboardExtensionLocator(result.extensionInstance.locator)) {\n        this.dashboardContent = this.initializeDashboardContent(\n          result.extensionDashboardInfo,\n          result.extensionInstance.locator.dashboardPath,\n        );\n        this.extensionZoneId = result.extensionDashboardInfo.extensionZoneId;\n      }\n\n      if (result.extensionWorksheetInfo) {\n        this.worksheetContent = this.initializeWorksheetContent(result.extensionWorksheetInfo);\n      }\n\n      this.environment = new Environment(result.extensionEnvironment);\n      this.settings = this.initializeSettings(result.extensionSettingsInfo);\n      this.ui = new UI(new UIImpl());\n      this.workbook = new Workbook(new ExtensionWorkbookImpl());\n\n      if (result.extensionEnvironment.workbookFormatting) {\n        this.initializeTableauFonts(dispatcher, result.extensionEnvironment.workbookFormatting);\n        this.applyAllFormatting(result.extensionEnvironment.workbookFormatting);\n      }\n\n      // After initialization has completed, setup listeners for the callback functions that\n      // are meant to be triggered whenever a context menu item is clicked.\n      this.initializeContextMenuCallbacks(contextMenuFunctions);\n\n      // Also set up listeners for ExtensionStylesChangedEvent\n      this.initializeWorkbookFormattingChangedEventCallback(dispatcher);\n\n      // In the normal initialization case, this will be an empty string.  When returning from initializeAsync to the\n      // developer, we just ingore that string.  In the case of initializing from an extension dialog, this string\n      // is an optional payload sent from the parent extension.\n      return result.extensionDialogPayload;\n    });\n  }\n\n  public applyAllFormatting(formattingModel: WorkbookFormatting | undefined): void {\n    if (!this._styleElement) {\n      this._styleElement = document.createElement('style');\n      this._styleElement.id = 'Tableau-Extension-Formatting';\n      document.head.appendChild(this._styleElement);\n    }\n\n    if (!this._styleElement.sheet || !formattingModel) {\n      return;\n    }\n\n    const stylesheet: CSSStyleSheet = this._styleElement.sheet as CSSStyleSheet;\n    while (stylesheet.cssRules.length > 0) {\n      stylesheet.deleteRule(stylesheet.cssRules.length - 1);\n    }\n    formattingModel.formattingSheets.map((currentFormattingSheet) => {\n      this.applyFormattingSheetToStyleSheet(currentFormattingSheet, stylesheet);\n    });\n  }\n\n  private applyFormattingSheetToStyleSheet(currentFormattingSheet: FormattingSheet, stylesheet: CSSStyleSheet): void {\n    let styleInfo = '';\n\n    const cssProperties = currentFormattingSheet.cssProperties;\n    if (cssProperties.fontFamily) {\n      styleInfo += 'font-family: ' + cssProperties.fontFamily.toString() + '; ';\n    }\n\n    if (cssProperties.fontSize) {\n      styleInfo += 'font-size: ' + cssProperties.fontSize.toString() + '; ';\n    }\n\n    if (cssProperties.fontWeight) {\n      styleInfo += 'font-weight: ' + cssProperties.fontWeight.toString() + '; ';\n    }\n\n    if (cssProperties.fontStyle) {\n      styleInfo += 'font-style: ' + cssProperties.fontStyle.toString() + '; ';\n    }\n\n    if (cssProperties.textDecoration) {\n      styleInfo += 'text-decoration: ' + cssProperties.textDecoration.toString() + '; ';\n    }\n\n    if (cssProperties.color) {\n      styleInfo += 'color: ' + cssProperties.color + '; ';\n    }\n\n    const selector: string = '.' + currentFormattingSheet.classNameKey;\n    const rule: string = selector + ' { ' + styleInfo + ' }';\n    stylesheet.insertRule(rule, stylesheet.cssRules.length);\n  }\n\n  private initializeWorkbookFormattingChangedEventCallback(dispatcher: InternalApiDispatcher): void {\n    const notificationService: NotificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(\n      ServiceNames.Notification,\n    );\n    // Unregister function not used since these notifications should be\n    // observed for the full lifetime of the extension.\n    notificationService.registerHandler(\n      NotificationId.WorkbookFormattingChanged,\n      () => true,\n      (eventFormatting: WorkbookFormatting) => {\n        if (eventFormatting) {\n          this.initializeTableauFonts(dispatcher, eventFormatting);\n          this.applyAllFormatting(eventFormatting);\n        }\n      },\n    );\n  }\n\n  private initializeTableauFonts(dispatcher: InternalApiDispatcher, workbookFormatting: WorkbookFormatting): void {\n    const fontNames: Model[] = [...SupportedBentonSansFontFaces, ...SupportedTableauFontFaces];\n    workbookFormatting.formattingSheets.forEach((formattingSheet) => {\n      if (formattingSheet.cssProperties.fontFamily) {\n        fontNames.push(formattingSheet.cssProperties.fontFamily);\n      }\n    });\n\n    if (fontNames.length > 0) {\n      const parameters: ExecuteParameters = { [ParameterId.FontNameListItems]: fontNames };\n      dispatcher\n        .execute(VerbId.GetFonts, parameters)\n        .then((response) => {\n          this.loadFonts(response.result as Array<FontNameAndInfo>);\n        })\n        .catch();\n    }\n  }\n\n  private loadFonts(fonts: Array<FontNameAndInfo>): void {\n    fonts.forEach((fontNameAndInfo) => {\n      if (SupportedTableauFontFaces.includes(fontNameAndInfo.fontName)) {\n        this.loadTableauFonts(fontNameAndInfo);\n      } else if (SupportedBentonSansFontFaces.includes(fontNameAndInfo.fontName)) {\n        this.loadBentonSansFonts(fontNameAndInfo);\n      } else {\n        document.fonts.add(new FontFace(fontNameAndInfo.fontName, fontNameAndInfo.fontBinaryInfo));\n      }\n    });\n  }\n\n  private initializeDashboardContent(info: ExtensionDashboardInfo, sheetPath: SheetPath): DashboardContent {\n    // sheets are always active for Extensions\n    const sheetInfoImpl = new SheetInfoImpl(info.name, SheetType.Dashboard, { width: info.size.w, height: info.size.h }, undefined, true);\n    const dashboardImpl = new DashboardImpl(sheetInfoImpl, info.zones, sheetPath, ExtensionsRegistryId, null, info.activeDashboardObjectId);\n    const dashboard = new Dashboard(dashboardImpl);\n    return new DashboardContent(dashboard);\n  }\n\n  private initializeWorksheetContent(info: ExtensionWorksheetInfo): WorksheetContent {\n    const sheetInfoImpl = new SheetInfoImpl(\n      info.visualId.worksheet,\n      SheetType.Worksheet,\n      { width: info.size.w, height: info.size.h },\n      undefined, // index property is embedding specific\n      true, // sheets are always active for Extensions\n    );\n\n    const worksheetImpl = new WorksheetImpl(\n      sheetInfoImpl,\n      ExtensionsRegistryId,\n      info.visualId,\n      null, // parentDashboard is always null for worksheet in WorksheetContent\n      null, // parentStoryPoint is only used for embedding\n    );\n    const worksheet = new Worksheet(worksheetImpl);\n    return new WorksheetContent(worksheet);\n  }\n\n  private initializeSettings(settingsInfo: ExtensionSettingsInfo): Settings {\n    const settingsImpl = new SettingsImpl(settingsInfo);\n    return new Settings(settingsImpl);\n  }\n\n  private initializeContextMenuCallbacks(contextMenuFunctions?: CallbackMap): void {\n    const notificationService: NotificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(\n      ServiceNames.Notification,\n    );\n\n    // Unregister function not used since these notifications should be\n    // observed for the full lifetime of the extension.\n    notificationService.registerHandler(\n      NotificationId.ContextMenuClick,\n      () => {\n        // Let through any context menu event, these are already filtered on api-core\n        // based on the extension locator.\n        return true;\n      },\n      (event: ContextMenuEvent) => {\n        // Execute the function associated with this context menu ID\n        if (contextMenuFunctions) {\n          if (!contextMenuFunctions[event.id]) {\n            throw new TableauError(ErrorCodes.InternalError, `Received unexpected context menu Id from event: ${event.id}`);\n          }\n\n          contextMenuFunctions[event.id]();\n        }\n      },\n    );\n  }\n\n  private loadTableauFonts(fontNameAndInfo: FontNameAndInfo): void {\n    switch (fontNameAndInfo.fontName) {\n      case TableauBookFontFaceName:\n        document.fonts.add(new FontFace(TableauBookFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        break;\n\n      case TableauLightFontFaceName:\n        document.fonts.add(new FontFace(TableauLightFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        break;\n\n      case TableauRegularFontFaceName:\n        document.fonts.add(\n          new FontFace(TableauRegularFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        break;\n\n      case TableauSemiBoldFontFaceName:\n        document.fonts.add(\n          new FontFace(TableauSemiboldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        document.fonts.add(new FontFace(TableauRegularFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        break;\n\n      case TableauBoldFontFaceName:\n        document.fonts.add(new FontFace(TableauBoldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        document.fonts.add(new FontFace(TableauBoldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(new FontFace(TableauMediumFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(\n          new FontFace(TableauSemiboldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }),\n        );\n        break;\n\n      case TableauMediumFontFaceName:\n        document.fonts.add(\n          new FontFace(TableauMediumFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        document.fonts.add(new FontFace(TableauLightFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(new FontFace(TableauBookFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        break;\n\n      default:\n        throw new TableauError(ErrorCodes.InternalError, `'attempted to load unsupported font: ${fontNameAndInfo.fontName}.'`);\n    }\n  }\n\n  private loadBentonSansFonts(fontNameAndInfo: FontNameAndInfo): void {\n    switch (fontNameAndInfo.fontName) {\n      case BentonSansBookFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        document.fonts.add(\n          new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: '100', style: 'normal' }),\n        );\n        break;\n\n      case BentonSansLightFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: '100', style: 'normal' }));\n        break;\n\n      case BentonSansMediumFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(\n          new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }),\n        );\n        break;\n\n      case BentonSansSemiDemiFontFaceName:\n        document.fonts.add(\n          new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        break;\n\n      case BentonSansBookItalicFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { style: 'italic' }));\n        break;\n\n      case BentonSansSemiDemiItalicFontFaceName:\n        document.fonts.add(new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { style: 'italic' }));\n        break;\n\n      default:\n        throw new TableauError(ErrorCodes.InternalError, `'attempted to load unsupported font: ${fontNameAndInfo.fontName}.'`);\n    }\n  }\n}\n","import { InitializationOptions, InternalApiDispatcherFactory, INTERNAL_CONTRACT_VERSION, VerbId } from '@tableau/api-internal-contract-js';\n\n/**\n * LegacyInternalApiDispatcherHolder has been moved (and renamed) from api-internal-contract.\n * It supports running a newer external library against a pre 2019.3 desktop.\n * Starting in 2019.3, we have a merged bootstrap style for both desktop and server.\n * In addition, the alpha checking that is happening here is not necessary in external-api-js\n *  after 2019.3 because that checking happens in api-platform-js (ApiDispatcherTest.ts)\n * TFSID: 1091561 tracks an improvement to this system to make it less complex and tie it directly to\n *  tableau beta release versions.\n * @deprecated\n */\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport namespace LegacyInternalApiDispatcherHolder {\n  /**\n   * @param options\n   */\n  export function getDesktopDispatcherPromise(options?: InitializationOptions): Promise<InternalApiDispatcherFactory> | undefined {\n    if ((!options || typeof options.isAlpha === 'undefined') && !window.__warningIssued) {\n      // tslint:disable-next-line:no-console\n      console.warn('This is a beta version of the Extensions API. Please upgrade to an official release.');\n      window.__warningIssued = true;\n    } else if (options?.isAlpha && window.__platformIsOfficialRelease) {\n      window.__tableauDesktopDispatcher\n        .then((dispatcherFactory) => {\n          const dispatcher = dispatcherFactory(INTERNAL_CONTRACT_VERSION);\n          dispatcher.execute(VerbId.BlockExtension, {}).catch();\n        })\n        .catch();\n    }\n\n    // this will be undefined if promise is rejected or throws\n    return window.__tableauDesktopDispatcher;\n  }\n\n  /**\n   * @param options\n   */\n  export function hasDesktopApiDispatcherPromise(options?: InitializationOptions): boolean {\n    return !!getDesktopDispatcherPromise(options);\n  }\n}\n\ndeclare global {\n  interface Window {\n    __tableauDesktopDispatcher: Promise<InternalApiDispatcherFactory>;\n    __platformIsOfficialRelease: boolean;\n    __warningIssued: boolean;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExtensionSettingsInfo, NotificationId, SettingsEvent } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  ErrorHelpers,\n  NotificationService,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n  TableauError,\n} from '@tableau/api-shared-js';\nimport { TableauEvent } from '../Events/TableauEvent';\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { SettingsCollection, SettingsService } from '../Services/SettingsService';\n\nclass SettingsChangedEvent extends TableauEvent implements Contract.SettingsChangedEvent {\n  public constructor(private _newSettings: { [key: string]: string }) {\n    super(Contract.TableauEventType.SettingsChanged);\n  }\n\n  public get newSettings(): SettingsCollection {\n    return this._newSettings;\n  }\n}\n\nexport class SettingsImpl {\n  private static ASYNC_SAVE_IN_PROGRESS = 'Async Save is in progress, updating settings is not allowed.';\n  private _isModified: boolean;\n  private _currentSettings: SettingsCollection;\n\n  // Since promises can't be introspected for state, keep a variable that\n  // indicates a save is in progress, so that set/erase can't be called during a save.\n  private _saveInProgress = false;\n\n  public constructor(settingsInfo: ExtensionSettingsInfo) {\n    this.initializeSettings(settingsInfo);\n  }\n\n  public erase(key: string): void {\n    ErrorHelpers.verifyParameter(key, 'key');\n\n    // Only make a modification if we have the key already\n    if (this._currentSettings[key]) {\n      this.verifySettingsAreUnlocked();\n\n      delete this._currentSettings[key];\n      this._isModified = true;\n    }\n  }\n\n  public get(key: string): string | undefined {\n    ErrorHelpers.verifyParameter(key, 'key');\n\n    return this._currentSettings[key];\n  }\n\n  public getAll(): SettingsCollection {\n    // Returns a mutable copy of the settings\n    return Object.assign({}, this._currentSettings);\n  }\n\n  public get isModified(): boolean {\n    return this._isModified;\n  }\n\n  public saveAsync(): Promise<SettingsCollection> {\n    this.verifySettingsAreUnlocked();\n\n    // Just resolve immediately if settings are unchanged\n    if (!this._isModified) {\n      return Promise.resolve<SettingsCollection>(this._currentSettings);\n    }\n\n    this._saveInProgress = true;\n\n    // Use the settings service to save settings to twb\n    const settingsService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<SettingsService>(\n      ExtensionsServiceNames.SettingsService,\n    );\n\n    return settingsService.saveSettingsAsync(this._currentSettings).then<SettingsCollection>(\n      (newSettings) => {\n        this._saveInProgress = false;\n        this._isModified = false;\n        if (this._currentSettings === undefined) {\n          this._currentSettings = newSettings;\n        } else {\n          Object.assign(this._currentSettings, newSettings);\n        }\n        return newSettings;\n      },\n      (reason) => {\n        this._saveInProgress = false;\n        return Promise.reject(reason);\n      },\n    );\n  }\n\n  public set(key: string, value: string): void {\n    ErrorHelpers.verifyStringParameter(key, 'key'); // Key shouldn't be an empty string.\n    ErrorHelpers.verifyParameter(value, 'value'); // Empty string value is allowed.\n    this.verifySettingsAreUnlocked();\n\n    this._currentSettings[key] = value;\n    this._isModified = true;\n  }\n\n  /**\n   * Initializes all events relevant to settings object.  This is only a settingsUpdate event currently.\n   *\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager.\n   */\n  public initializeEvents(): Array<SingleEventManager> {\n    const results = new Array<SingleEventManager>();\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return\n      return results;\n    }\n\n    const settingsChangedEvent = new SingleEventManagerImpl<SettingsChangedEvent>(Contract.TableauEventType.SettingsChanged);\n    notificationService.registerHandler(\n      NotificationId.SettingsChanged,\n      () => true,\n      (event: SettingsEvent) => {\n        this._currentSettings = event.newSettings;\n        settingsChangedEvent.triggerEvent(() => new SettingsChangedEvent(event.newSettings));\n      },\n    );\n\n    results.push(settingsChangedEvent);\n\n    return results;\n  }\n\n  private initializeSettings(settingsInfo: ExtensionSettingsInfo): void {\n    ErrorHelpers.verifyParameter(settingsInfo, 'settingsInfo');\n    ErrorHelpers.verifyParameter(settingsInfo.settingsValues, 'settingsInfo.SettingsValues');\n\n    this._currentSettings = settingsInfo.settingsValues;\n\n    // Reset the isModified flag\n    this._isModified = false;\n  }\n\n  /**\n   * This helper should be called before any local update to this.currentSettings.\n   * Checks if a current save call is still in progress and throws an error if so.\n   */\n  private verifySettingsAreUnlocked(): void {\n    if (this._saveInProgress) {\n      throw new TableauError(Contract.ErrorCodes.SettingSaveInProgress, SettingsImpl.ASYNC_SAVE_IN_PROGRESS);\n    }\n  }\n}\n","import { Model } from '@tableau/api-internal-contract-js';\n\nexport const TableauBookFontFamilyName = 'Tableau Book';\nexport const TableauLightFontFamilyName = 'Tableau Light';\nexport const TableauRegularFontFamilyName = 'Tableau Regular';\nexport const TableauMediumFontFamilyName = 'Tableau Medium';\nexport const TableauSemiboldFontFamilyName = 'Tableau Semibold';\nexport const TableauBoldFontFamilyName = 'Tableau Bold';\n\nexport const TableauBookFontFaceName = 'Tableau Book';\nexport const TableauBoldFontFaceName = 'Tableau Bold';\nexport const TableauLightFontFaceName = 'Tableau Light';\nexport const TableauMediumFontFaceName = 'Tableau Medium';\nexport const TableauRegularFontFaceName = 'Tableau Regular';\nexport const TableauSemiBoldFontFaceName = 'Tableau Semi Bold';\n\nexport const SupportedTableauFontFaces: Model[] = [\n  TableauBookFontFaceName,\n  TableauBoldFontFaceName,\n  TableauLightFontFaceName,\n  TableauMediumFontFaceName,\n  TableauRegularFontFaceName,\n  TableauSemiBoldFontFaceName,\n];\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { DialogUpdateEvent, NotificationId } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, NotificationService, ServiceNames, TableauError } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { UIService } from '../Services/UIService';\n\nexport class UIImpl {\n  public displayDialogAsync(url: string, payload?: string, options?: Contract.DialogOptions): Promise<string> {\n    const uiService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<UIService>(ExtensionsServiceNames.UIService);\n    const notificationService: NotificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(\n      ServiceNames.Notification,\n    );\n\n    return new Promise((resolve, reject) => {\n      uiService\n        .displayDialogAsync(url, payload || '', options)\n        .then(() => {\n          const unregisterFn = notificationService.registerHandler(\n            NotificationId.ExtensionDialogUpdate,\n            () => {\n              // Let through any dialog update event\n              return true;\n            },\n            (event: DialogUpdateEvent) => {\n              if (event.isCloseEvent) {\n                if (event.closePayload === undefined) {\n                  throw new TableauError(Contract.ErrorCodes.InternalError, 'closePayload is undefined');\n                }\n                resolve(event.closePayload);\n              } else {\n                reject(new TableauError(ErrorCodes.DialogClosedByUser, 'Extension dialog closed by user.'));\n              }\n\n              unregisterFn();\n            },\n          );\n        })\n        .catch((error) => {\n          reject(error);\n        });\n    });\n  }\n\n  public closeDialog(payload?: string): void {\n    const uiService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<UIService>(ExtensionsServiceNames.UIService);\n\n    uiService.closeDialog(payload);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardLayoutChangeDetails, TableauEventType, WorkbookFormatting } from '@tableau/api-external-contract-js';\nimport { DashboardLayoutEvent, NotificationId } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  DashboardImpl,\n  DashboardObjectImpl,\n  NotificationService,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n  WorksheetImpl,\n} from '@tableau/api-shared-js';\nimport { DashboardLayoutChangedEvent } from '../Events/DashboardLayoutChangedEvent';\nimport { WorkbookFormattingChangedEvent } from '../Events/WorkbookFormattingChangedEvent';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { DashboardObject } from './DashboardObject';\nimport { Sheet } from './Sheet';\nimport { Worksheet } from './Worksheet';\n\nexport class Dashboard extends Sheet implements Contract.ExtensionDashboard {\n  public constructor(private _dashboardImpl: DashboardImpl) {\n    super(_dashboardImpl);\n    _dashboardImpl.initializeWithPublicInterfaces();\n    this.initializeEvents().forEach((e) => this.addNewEventType(e));\n  }\n\n  public get worksheets(): Array<Contract.ExtensionWorksheet> {\n    return this._dashboardImpl.worksheetsImpl.map((worksheetImpl: WorksheetImpl) => {\n      return new Worksheet(worksheetImpl);\n    });\n  }\n\n  public get objects(): Array<Contract.ExtensionDashboardObject> {\n    return this._dashboardImpl.objects.map((dashboardObjectImpl: DashboardObjectImpl) => {\n      return new DashboardObject(dashboardObjectImpl);\n    });\n  }\n\n  public get activeDashboardObjectId(): number {\n    return this._dashboardImpl.activeDashboardObjectId;\n  }\n\n  public get activeDashboardName(): string {\n    return this._dashboardImpl.activeDashboardName;\n  }\n\n  public setZoneVisibilityAsync(zoneVisibilityMap: Contract.ZoneVisibilityMap): Promise<void> {\n    return this._dashboardImpl.setDashboardObjectVisibilityAsync(zoneVisibilityMap);\n  }\n\n  public setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap: Contract.DashboardObjectVisibilityMap): Promise<void> {\n    return this._dashboardImpl.setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap);\n  }\n\n  public getDashboardObjectById(dashboardObjectId: number): DashboardObject | undefined {\n    const zone = this._dashboardImpl.getDashboardObjectById(dashboardObjectId);\n    return zone && new DashboardObject(zone);\n  }\n\n  public initializeEvents(): Array<SingleEventManager> {\n    const results = new Array<SingleEventManager>();\n\n    // Initializing events and registering notification service\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return (allows unit testing without NotificationService mock)\n      return results;\n    }\n\n    const dashboardLayoutChangedEvent = new SingleEventManagerImpl<DashboardLayoutChangedEvent>(TableauEventType.DashboardLayoutChanged);\n    notificationService.registerHandler(\n      NotificationId.DashboardLayoutChanged,\n      () => true,\n      (event: DashboardLayoutEvent) => {\n        const dashboardObjectChanges: DashboardLayoutChangeDetails = this._dashboardImpl.updateZones(\n          event.zones,\n          event.activeZoneId,\n          event.activeDashboardName,\n        );\n        dashboardLayoutChangedEvent.triggerEvent(() => new DashboardLayoutChangedEvent(dashboardObjectChanges));\n      },\n    );\n\n    results.push(dashboardLayoutChangedEvent);\n\n    const workbookFormattingChangedEvent = new SingleEventManagerImpl<WorkbookFormattingChangedEvent>(\n      TableauEventType.WorkbookFormattingChanged,\n    );\n\n    notificationService.registerHandler(\n      NotificationId.WorkbookFormattingChanged,\n      () => true,\n      (eventFormatting: WorkbookFormatting) => {\n        workbookFormattingChangedEvent.triggerEvent(() => new WorkbookFormattingChangedEvent(eventFormatting));\n      },\n    );\n\n    results.push(workbookFormattingChangedEvent);\n\n    return results;\n  }\n\n  public moveAndResizeDashboardObjectsAsync(\n    dashboardObjectPositionAndSizeUpdateArray: Contract.DashboardObjectPositionAndSizeUpdateArray,\n  ): Promise<void> {\n    return this._dashboardImpl.moveAndResizeDashboardObjectsAsync(dashboardObjectPositionAndSizeUpdateArray);\n  }\n\n  public replayAnimationAsync(replaySpeed: Contract.ReplaySpeedType): Promise<void> {\n    return this._dashboardImpl.replayAnimationAsync(replaySpeed);\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    return this._dashboardImpl.getFiltersAsync();\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    return this._dashboardImpl.applyFilterAsync(fieldName, values, updateType, options);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardObjectImpl } from '@tableau/api-shared-js';\nimport { Dashboard } from './Dashboard';\nimport { Worksheet } from './Worksheet';\n\n/**\n * Implementation of the dashboard objects - the zones in a dashboard.\n */\nexport class DashboardObject implements Contract.ExtensionDashboardObject {\n  public constructor(private _dashboardObjectImpl: DashboardObjectImpl) {}\n\n  public get dashboard(): Contract.ExtensionDashboard {\n    return new Dashboard(this._dashboardObjectImpl.dashboardImpl);\n  }\n\n  public get type(): Contract.DashboardObjectType {\n    return this._dashboardObjectImpl.type;\n  }\n\n  public get position(): Contract.Point {\n    return this._dashboardObjectImpl.position;\n  }\n\n  public get size(): Contract.Size {\n    return this._dashboardObjectImpl.size;\n  }\n\n  public get worksheet(): Contract.ExtensionWorksheet | undefined {\n    if (this._dashboardObjectImpl.worksheetImpl) {\n      return new Worksheet(this._dashboardObjectImpl.worksheetImpl);\n    }\n    return undefined;\n  }\n\n  public get name(): string {\n    return this._dashboardObjectImpl.name;\n  }\n\n  public get isFloating(): boolean {\n    return this._dashboardObjectImpl.isFloating;\n  }\n\n  public get isVisible(): boolean {\n    return this._dashboardObjectImpl.isVisible;\n  }\n\n  public get id(): number {\n    return this._dashboardObjectImpl.id;\n  }\n\n  public get fieldId(): string | undefined {\n    return this._dashboardObjectImpl.fieldId;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { NotificationId } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  ErrorHelpers,\n  EventListenerManager,\n  NotificationService,\n  ParameterImpl,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n} from '@tableau/api-shared-js';\nimport { ParameterChangedEvent } from '../Events/ParameterChangedEvent';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\n\n/**\n * Implementation of the Parameter contract. Calls down to the impl\n * class for almost all of the work it does.\n */\nexport class Parameter extends EventListenerManager implements Contract.Parameter {\n  public constructor(private parameterImpl: ParameterImpl, sheet: Contract.ExtensionSheet) {\n    super();\n\n    // Initialize our event handling for this class\n    this.initializeEvents(sheet).forEach((e) => this.addNewEventType(e));\n  }\n\n  public get name(): string {\n    return this.parameterImpl.name;\n  }\n\n  public get currentValue(): Contract.DataValue {\n    return this.parameterImpl.currentValue;\n  }\n\n  public get dataType(): Contract.DataType {\n    return this.parameterImpl.dataType;\n  }\n\n  public get allowableValues(): Contract.ParameterDomainRestriction {\n    return this.parameterImpl.allowableValues;\n  }\n\n  public get id(): string {\n    return this.parameterImpl.id;\n  }\n\n  public changeValueAsync(newValue: string | number | boolean | Date): Promise<Contract.DataValue> {\n    return this.parameterImpl.changeValueAsync(newValue);\n  }\n\n  /**\n   * Helper method which goes through and registers each event type this impl knows about\n   * with the NotificationService. It returns an array of SingleEventManager objects which\n   * can then be passed to an EventListenerManager to handle user registration / unregistration.\n   *\n   * @param sheet The sheet object which will be included with the event notifications\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager\n   */\n  public initializeEvents(sheet: Contract.ExtensionSheet): Array<SingleEventManager> {\n    ErrorHelpers.verifyInternalValue(sheet, 'sheet');\n\n    const results = new Array<SingleEventManager>();\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return\n      return results;\n    }\n\n    // Initialize all of the event managers we'll need (one for each event type)\n    const parameterEvent = new SingleEventManagerImpl<ParameterChangedEvent>(Contract.TableauEventType.ParameterChanged);\n    notificationService.registerHandler(\n      NotificationId.ParameterChanged,\n      (model) => {\n        const fieldName = model as string;\n        return fieldName === this.parameterImpl.id;\n      },\n      (fieldName: string) => {\n        parameterEvent.triggerEvent(() => new ParameterChangedEvent(fieldName, sheet));\n      },\n    );\n\n    results.push(parameterEvent);\n\n    return results;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { EventListenerManager, SheetImpl, TableauError } from '@tableau/api-shared-js';\nimport { Parameter } from './Parameter';\n\nexport class Sheet extends EventListenerManager implements Contract.ExtensionSheet {\n  public constructor(private _sheetImpl: SheetImpl) {\n    super();\n  }\n\n  public get name(): string {\n    return this._sheetImpl.name;\n  }\n\n  public get sheetType(): Contract.SheetType {\n    return this._sheetImpl.sheetType;\n  }\n\n  public get size(): Contract.Size {\n    if (this.isValidSize(this._sheetImpl.size)) {\n      return this._sheetImpl.size;\n    }\n\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, 'Size not implemented');\n  }\n\n  private isValidSize(size: any): size is Contract.Size {\n    const testSize = size as Contract.Size;\n    if (testSize.width !== undefined && testSize.height !== undefined) {\n      return true;\n    }\n\n    return false;\n  }\n\n  public findParameterAsync(parameterName: string): Promise<Contract.Parameter | undefined> {\n    return this._sheetImpl.findParameterAsync(parameterName).then((parameterImpl) => {\n      if (parameterImpl) {\n        return new Promise<Contract.Parameter>((resolve) => resolve(new Parameter(parameterImpl, this)));\n      } else {\n        return new Promise<undefined>((resolve) => resolve(undefined));\n      }\n    });\n  }\n\n  public getParametersAsync(): Promise<Array<Contract.Parameter>> {\n    return this._sheetImpl.getParametersAsync().then((parametersImpl) => {\n      return parametersImpl.map((parameterImpl) => {\n        return new Parameter(parameterImpl, this);\n      });\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExtensionWorkbookImpl } from '../Impl/ExtensionWorkbookImpl';\n\nexport class Workbook implements Contract.ExtensionWorkbook {\n  public constructor(private _workbookImpl: ExtensionWorkbookImpl) {}\n\n  public getAllDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    return this._workbookImpl.getAllDataSourcesAsync();\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { Column, FilterUpdateType, SelectionUpdateType, TableauEventType, TooltipContext } from '@tableau/api-external-contract-js';\nimport { FilterEvent, NotificationId, SummaryDataEvent, VisualId } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  NotificationService,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n  TableauError,\n  WorksheetImpl,\n} from '@tableau/api-shared-js';\nimport { FilterChangedEvent } from '../Events/FilterChangedEvent';\nimport { MarksSelectedEvent } from '../Events/MarksSelectedEvent';\nimport { SummaryDataChangedEvent } from '../Events/SummaryDataChangedEvent';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { Dashboard } from './Dashboard';\nimport { Sheet } from './Sheet';\n\nexport class Worksheet extends Sheet implements Contract.ExtensionWorksheet {\n  public constructor(protected _worksheetImpl: WorksheetImpl) {\n    super(_worksheetImpl);\n\n    // Call to initialize events and then call down to the event listener manager to handle things\n    this.initializeEvents().forEach((e) => this.addNewEventType(e));\n  }\n\n  public get parentDashboard(): Contract.ExtensionDashboard {\n    // This should never happen for Extensions if the DashboardImpls are created correctly\n    if (this._worksheetImpl.parentDashboard == null) {\n      throw new TableauError(Contract.SharedErrorCodes.ImplementationError, `Parent dashboard not implemented`);\n    }\n\n    return new Dashboard(this._worksheetImpl.parentDashboard);\n  }\n\n  /**\n   * Helper method which goes through and registers each event type this impl knows about\n   * with the NotificationService. It returns an array of SingleEventManager objects which\n   * can then be passed to an EventListenerManager to handle user registration / unregistration.\n   *\n   * @param {Worksheet} worksheet The worksheet object which will be included with the event notifications\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager\n   */\n  public initializeEvents(): Array<SingleEventManager> {\n    const results = new Array<SingleEventManager>();\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return\n      return results;\n    }\n\n    // Initialize all of the event managers we'll need (one for each event type)\n    const marksEvent = new SingleEventManagerImpl<MarksSelectedEvent>(TableauEventType.MarkSelectionChanged);\n    notificationService.registerHandler(\n      NotificationId.SelectedMarksChanged,\n      (model) => {\n        const visualId = model as VisualId;\n        return this.visualIdsAreEqual(visualId, this._worksheetImpl.visualId);\n      },\n      () => marksEvent.triggerEvent(() => new MarksSelectedEvent(this)),\n    );\n\n    const filterEvent = new SingleEventManagerImpl<FilterChangedEvent>(TableauEventType.FilterChanged);\n    notificationService.registerHandler(\n      NotificationId.FilterChanged,\n      (model) => {\n        const filterEventResponse = model as FilterEvent;\n        return this._worksheetImpl.visualId.worksheet === filterEventResponse.visualId.worksheet;\n      },\n      (event: FilterEvent) => {\n        filterEvent.triggerEvent(() => new FilterChangedEvent(this, event.fieldName, event.fieldId));\n      },\n    );\n\n    const summaryDataEvent = new SingleEventManagerImpl<SummaryDataChangedEvent>(TableauEventType.SummaryDataChanged);\n    notificationService.registerHandler(\n      NotificationId.SummaryDataChanged,\n      (model) => {\n        const summaryDataEventResponse = model as SummaryDataEvent;\n        return this._worksheetImpl.visualId.worksheet === summaryDataEventResponse.visualId.worksheet;\n      },\n      (event: SummaryDataEvent) => {\n        summaryDataEvent.triggerEvent(() => new SummaryDataChangedEvent(this));\n      },\n    );\n\n    results.push(marksEvent);\n    results.push(filterEvent);\n    results.push(summaryDataEvent);\n\n    return results;\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    return this._worksheetImpl.applyFilterAsync(fieldName, values, updateType, options);\n  }\n\n  public applyRangeFilterAsync(fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\n    return this._worksheetImpl.applyRangeFilterAsync(fieldName, filterOptions);\n  }\n\n  public applyHierarchicalFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    return this._worksheetImpl.applyHierarchicalFilterAsync(fieldName, values, updateType, options);\n  }\n\n  public applyRelativeDateFilterAsync(fieldName: string, options: Contract.RelativeDateFilterOptions): Promise<string> {\n    return this._worksheetImpl.applyRelativeDateFilterAsync(fieldName, options);\n  }\n\n  public clearFilterAsync(fieldName: string): Promise<string> {\n    return this._worksheetImpl.clearFilterAsync(fieldName);\n  }\n\n  public getDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    return this._worksheetImpl.getDataSourcesAsync();\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    return this._worksheetImpl.getFiltersAsync();\n  }\n\n  public getSelectedMarksAsync(): Promise<Contract.MarksCollection> {\n    return this._worksheetImpl.getSelectedMarksAsync();\n  }\n\n  public getHighlightedMarksAsync(): Promise<Contract.MarksCollection> {\n    return this._worksheetImpl.getHighlightedMarksAsync();\n  }\n\n  public getSummaryDataAsync(options: Contract.GetSummaryDataOptions): Promise<Contract.DataTable> {\n    return this._worksheetImpl.getSummaryDataAsync(options);\n  }\n\n  public getSummaryDataReaderAsync(pageRowCount: number, options: Contract.GetSummaryDataOptions): Promise<Contract.DataTableReader> {\n    return this._worksheetImpl.getSummaryDataReaderAsync(pageRowCount, options);\n  }\n\n  public getSummaryColumnsInfoAsync(): Promise<Array<Column>> {\n    return this._worksheetImpl.getSummaryColumnsInfoAsync();\n  }\n\n  public getUnderlyingDataAsync(options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    console.warn(\n      'Worksheet.getUnderlyingDataAsync is deprecated. Please use ' +\n        'Worksheet.getUnderlyingTablesAsync and Worksheet.getUnderlyingTableDataAsync',\n    );\n    return this._worksheetImpl.getUnderlyingDataAsync(options);\n  }\n\n  public getUnderlyingTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    return this._worksheetImpl.getUnderlyingTablesAsync();\n  }\n\n  public getUnderlyingTableDataAsync(logicalTableId: string, options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    return this._worksheetImpl.getUnderlyingTableDataAsync(logicalTableId, options);\n  }\n\n  public getUnderlyingTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount: number,\n    options: Contract.GetUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    return this._worksheetImpl.getUnderlyingTableDataReaderAsync(logicalTableId, pageRowCount, options);\n  }\n\n  public getVisualSpecificationAsync(): Promise<Contract.VisualSpecification> {\n    return this._worksheetImpl.getVisualSpecificationAsync();\n  }\n\n  public clearSelectedMarksAsync(): Promise<void> {\n    return this._worksheetImpl.clearSelectedMarksAsync();\n  }\n\n  public selectMarksByIDAsync(marksInfo: Array<Contract.MarkInfo>, updateType: SelectionUpdateType): Promise<void> {\n    return this._worksheetImpl.selectMarksByIdAsync(marksInfo, updateType);\n  }\n\n  public selectMarksByValueAsync(selections: Array<Contract.SelectionCriteria>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    return this._worksheetImpl.selectMarksByValueAsync(selections, selectionUpdateType);\n  }\n\n  public selectMarksByIdAsync(selections: Array<Contract.MarkInfo>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    return this._worksheetImpl.selectMarksByIdAsync(selections, selectionUpdateType);\n  }\n\n  public annotateMarkAsync(mark: Contract.MarkInfo, annotationText: string): Promise<void> {\n    return this._worksheetImpl.annotateMarkAsync(mark, annotationText);\n  }\n\n  public getAnnotationsAsync(): Promise<Array<Contract.Annotation>> {\n    return this._worksheetImpl.getAnnotationsAsync();\n  }\n\n  public removeAnnotationAsync(annotation: Contract.Annotation): Promise<void> {\n    return this._worksheetImpl.removeAnnotationAsync(annotation);\n  }\n\n  public hoverTupleAsync(hoveredTuple?: number, tooltip?: TooltipContext | null, allowHoverActions = true): Promise<void> {\n    return this._worksheetImpl.hoverTupleAsync(hoveredTuple, tooltip, allowHoverActions);\n  }\n\n  public selectTuplesAsync(selectedTuples: Array<number>, selectOption: Contract.SelectOptions, tooltip?: TooltipContext): Promise<void> {\n    return this._worksheetImpl.selectTuplesAsync(selectedTuples, selectOption, tooltip);\n  }\n\n  public getTooltipTextAsync(tupleId: number): Promise<String> {\n    return this._worksheetImpl.getTooltipTextAsync(tupleId);\n  }\n\n  public leaveMarkNavigationAsync(): Promise<void> {\n    return this._worksheetImpl.leaveMarkNavigationAsync();\n  }\n\n  private visualIdsAreEqual(a: VisualId, b: VisualId): boolean {\n    return (\n      a &&\n      b &&\n      a.worksheet === b.worksheet &&\n      a.dashboard === b.dashboard &&\n      a.storyboard === b.storyboard &&\n      a.storyPointID === b.storyPointID\n    );\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\n\n/**\n * Implementation of the external DashboardContent namespace.\n * This does not follow the Impl pattern as DashboardContent is\n * currently just a (single) property bag.\n */\nexport class DashboardContent implements Contract.DashboardContent {\n  public constructor(private _dashboard: Contract.ExtensionDashboard) {}\n\n  public get dashboard(): Contract.ExtensionDashboard {\n    return this._dashboard;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExtensionEnvironment } from '@tableau/api-internal-contract-js';\nimport { ApiVersion, InternalToExternalEnumMappings as EnumMappings } from '@tableau/api-shared-js';\nimport { ConnectedServer } from '../Impl/ConnectedServer';\nimport { WorkbookFormattingEnvUtil } from './WorkbookFormattingEnvUtil';\n\n/**\n * Implementation of the external environment namespace.\n * Environment does not follow the Impl pattern as it is\n * just a property bag.\n * First class extensions can get to ConnectedServer with: environment['connectedServer']\n */\nexport class Environment implements Contract.Environment {\n  /**The following is an index signature. It allows properties to be accessed by name.\n   * This allows us to add properties dynamically (see usage of this.connectedServer below) without Typescript errors.\n   * The reason we do this is so that 3rd-party extension developers do not see the connectedServer property\n   * that is only available to first class extension developers.\n   * The type of the index sigature needs to be a union of all properties in the object, since we could\n   * access any property using the property index method.\n   */\n  [x: string]: ConnectedServer | string | Contract.WorkbookFormatting | string[] | undefined;\n  private _apiVersion: string;\n  private _context: Contract.ExtensionContext;\n  private _formatting?: Contract.WorkbookFormatting;\n  private _language: string;\n  private _country?: string;\n  private _locale: string;\n  private _mode: Contract.ExtensionMode;\n  private _operatingSystem: string;\n  private _tableauVersion: string;\n  private _uniqueUserId?: string;\n\n  public constructor(extensionEnvironment: ExtensionEnvironment) {\n    this._apiVersion = ApiVersion.Instance && ApiVersion.Instance.formattedValue; // maj.min.fix (no build)\n    this._context = EnumMappings.extensionContext.convert(extensionEnvironment.extensionContext);\n    this._formatting = WorkbookFormattingEnvUtil.convertToWorkbookFormatting(extensionEnvironment.workbookFormatting);\n    this._language = extensionEnvironment.extensionLanguage;\n    this._country = extensionEnvironment.extensionCountry;\n    this._locale = extensionEnvironment.extensionLocale;\n    this._mode = EnumMappings.extensionMode.convert(extensionEnvironment.extensionMode);\n    this._operatingSystem = extensionEnvironment.operatingSystem;\n    this._tableauVersion = extensionEnvironment.tableauVersion;\n    this._uniqueUserId = extensionEnvironment.uniqueUserId;\n\n    // If we have a userId, then we are a first class extension\n    if (extensionEnvironment.userId) {\n      this.connectedServer = new ConnectedServer(\n        extensionEnvironment.userId,\n        extensionEnvironment.siteId,\n        extensionEnvironment.siteNamespace,\n        extensionEnvironment.workbookId,\n      );\n\n      this.featureFlags = extensionEnvironment.featureFlags;\n    }\n  }\n\n  public get apiVersion(): string {\n    return this._apiVersion;\n  }\n\n  public get context(): Contract.ExtensionContext {\n    return this._context;\n  }\n\n  public get workbookFormatting(): Contract.WorkbookFormatting | undefined {\n    return this._formatting;\n  }\n\n  public get language(): string {\n    return this._language;\n  }\n\n  public get country(): string | undefined {\n    return this._country;\n  }\n\n  public get locale(): string {\n    return this._locale;\n  }\n\n  public get mode(): Contract.ExtensionMode {\n    return this._mode;\n  }\n\n  public get operatingSystem(): string {\n    return this._operatingSystem;\n  }\n\n  public get tableauVersion(): string {\n    return this._tableauVersion;\n  }\n\n  public get uniqueUserId(): string | undefined {\n    return this._uniqueUserId;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { CallbackMap, ExtensionsImpl } from '../Impl/ExtensionsImpl';\n\n/**\n * Implementation of the external Extensions namespace.\n */\nexport class Extensions implements Contract.Extensions {\n  public constructor(private extensionImpl: ExtensionsImpl) {\n    this.extensionImpl = extensionImpl;\n  }\n\n  public get dashboardContent(): Contract.DashboardContent | undefined {\n    return this.extensionImpl.dashboardContent;\n  }\n\n  public get worksheetContent(): Contract.WorksheetContent | undefined {\n    return this.extensionImpl.worksheetContent;\n  }\n\n  public get environment(): Contract.Environment {\n    return this.extensionImpl.environment;\n  }\n\n  public get settings(): Contract.Settings {\n    return this.extensionImpl.settings;\n  }\n\n  public get ui(): Contract.UI {\n    return this.extensionImpl.ui;\n  }\n\n  public get workbook(): Contract.ExtensionWorkbook {\n    return this.extensionImpl.workbook;\n  }\n\n  public get dashboardObjectId(): number {\n    return this.extensionImpl.extensionZoneId;\n  }\n\n  public initializeAsync(contextMenuCallbacks?: CallbackMap): Promise<void> {\n    return this.extensionImpl.initializeAsync(false, contextMenuCallbacks).then<void>();\n  }\n\n  public initializeDialogAsync(): Promise<string> {\n    return this.extensionImpl.initializeAsync(true);\n  }\n\n  public createVizImageAsync(inputSpec: object): Promise<string> {\n    return this.extensionImpl.createVizImageAsync(inputSpec);\n  }\n\n  public setClickThroughAsync(clickThroughEnabled: boolean): Promise<void> {\n    return this.extensionImpl.setClickThroughAsync(clickThroughEnabled);\n  }\n}\n","import { Settings as SettingsContract } from '@tableau/api-external-contract-js';\nimport { EventListenerManager } from '@tableau/api-shared-js';\nimport { SettingsImpl } from '../Impl/SettingsImpl';\nimport { SettingsCollection } from '../Services/SettingsService';\n\n/**\n * Implementation of the external settings namespace.\n */\nexport class Settings extends EventListenerManager implements SettingsContract {\n  public constructor(private _settingsImpl: SettingsImpl) {\n    super();\n\n    // Initialize our event handling for this class\n    this._settingsImpl.initializeEvents().forEach((e) => this.addNewEventType(e));\n  }\n\n  public erase(key: string): void {\n    this._settingsImpl.erase(key);\n  }\n\n  public get(key: string): string | undefined {\n    return this._settingsImpl.get(key);\n  }\n\n  public getAll(): SettingsCollection {\n    return this._settingsImpl.getAll();\n  }\n\n  public get isModified(): boolean {\n    return this._settingsImpl.isModified;\n  }\n\n  public saveAsync(): Promise<SettingsCollection> {\n    return this._settingsImpl.saveAsync();\n  }\n\n  public set(key: string, value: string): void {\n    this._settingsImpl.set(key, value);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { UIImpl } from '../Impl/UIImpl';\n\n/**\n * Implementation of the external UI namespace.\n */\nexport class UI implements Contract.UI {\n  public constructor(private _impl: UIImpl) {}\n\n  public displayDialogAsync(url: string, payload?: string, options?: Contract.DialogOptions): Promise<string> {\n    return this._impl.displayDialogAsync(url, payload, options);\n  }\n\n  public closeDialog(payload?: string): void {\n    this._impl.closeDialog(payload);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { InternalToExternalEnumMappings as EnumMappings } from '@tableau/api-shared-js';\nimport { WorkbookFormatting } from '../../../../api-internal-contract-js/lib/src/JsApiInternalContract';\n\nexport class WorkbookFormattingEnvUtil {\n  public static convertToWorkbookFormatting(workbookFormattingModel?: WorkbookFormatting): Contract.WorkbookFormatting | undefined {\n    if (!workbookFormattingModel) {\n      return undefined;\n    } else {\n      const formattingMap: Array<Contract.FormattingSheet> = workbookFormattingModel.formattingSheets.map((currentFormattingSheet) => {\n        const formattingSheet: Contract.FormattingSheet = {\n          classNameKey: EnumMappings.classNameKey.convert(currentFormattingSheet.classNameKey),\n          cssProperties: {\n            fontFamily: currentFormattingSheet.cssProperties.fontFamily,\n            fontSize: currentFormattingSheet.cssProperties.fontSize,\n            fontWeight: currentFormattingSheet.cssProperties.fontWeight,\n            fontStyle: currentFormattingSheet.cssProperties.fontStyle,\n            textDecoration: currentFormattingSheet.cssProperties.textDecoration,\n            color: currentFormattingSheet.cssProperties.color,\n          },\n        };\n        return formattingSheet;\n      });\n      const result: Contract.WorkbookFormatting = {\n        formattingSheets: formattingMap,\n      };\n      return result;\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\n\n/**\n * Implementation of the external WorksheetContent namespace.\n * This does not follow the Impl pattern as WorksheetContent is\n * currently just a (single) property bag.\n */\nexport class WorksheetContent implements Contract.WorksheetContent {\n  public constructor(private _worksheet: Contract.ExtensionWorksheet) {}\n\n  public get worksheet(): Contract.ExtensionWorksheet {\n    return this._worksheet;\n  }\n}\n","import { ExecuteParameters, ExtensionBootstrapInfo, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceImplBase } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\nimport { InitializationService } from '../InitializationService';\n\nexport class InitializationServiceImpl extends ServiceImplBase implements InitializationService {\n  public get serviceName(): string {\n    return ExtensionsServiceNames.InitializationService;\n  }\n\n  public initializeDashboardExtensionsAsync(isExtensionDialog: boolean, contextMenuIds: string[]): Promise<ExtensionBootstrapInfo> {\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'initializeDashboardExtensionsAsync',\n      [ParameterId.ExtensionContextMenuIds]: contextMenuIds,\n      [ParameterId.IsExtensionDialog]: isExtensionDialog,\n    };\n\n    return this.execute(VerbId.InitializeExtension, params).then<ExtensionBootstrapInfo>((response) => {\n      // TODO - Validate return value\n\n      const result = response.result as ExtensionBootstrapInfo;\n      return result;\n    });\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ExtensionSettingsInfo, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceImplBase, TableauError } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\nimport { SettingsCollection, SettingsService } from '../SettingsService';\n\nexport class SettingsServiceImpl extends ServiceImplBase implements SettingsService {\n  public get serviceName(): string {\n    return ExtensionsServiceNames.SettingsService;\n  }\n\n  public saveSettingsAsync(settings: SettingsCollection): Promise<SettingsCollection> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'saveSettingsAsync',\n      [ParameterId.SettingsValues]: settings,\n    };\n\n    return this.execute(VerbId.SaveExtensionSettings, parameters).then<SettingsCollection>((value) => {\n      const result = value.result as ExtensionSettingsInfo;\n\n      if (!result || !result.settingsValues) {\n        throw new TableauError(ErrorCodes.InternalError, 'Unexpected error savings settings.');\n      }\n\n      return result.settingsValues;\n    });\n  }\n}\n","import { DialogOptions, DialogStyle, ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ExtensionDialogResult, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ErrorHelpers, ExternalToInternalEnumMappings, ServiceImplBase, TableauError } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\nimport { UIService } from '../UIService';\n\nconst DEFAULT_DIALOG_HEIGHT = 400; // in pixels\nconst DEFAULT_DIALOG_WIDTH = 600; // in pixels\nconst DEFAULT_DIALOG_STYLE: DialogStyle = DialogStyle.Window;\n\nexport class UIServiceImpl extends ServiceImplBase implements UIService {\n  public get serviceName(): string {\n    return ExtensionsServiceNames.UIService;\n  }\n\n  public displayDialogAsync(url: string, payload: string, options?: DialogOptions): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'displayDialogAsync',\n      [ParameterId.ExtensionDialogUrl]: url,\n      [ParameterId.ExtensionDialogPayload]: payload,\n    };\n\n    const h: number = options && options.height ? options.height : DEFAULT_DIALOG_HEIGHT;\n    const w: number = options && options.width ? options.width : DEFAULT_DIALOG_WIDTH;\n    const dialogStyle: DialogStyle = options && options.dialogStyle ? options.dialogStyle : DEFAULT_DIALOG_STYLE;\n\n    // On the platform side, we do something reasonable regardess of whether the passed\n    // height and width are too large or too small.  But this likely indicates a developer error,\n    // so we throw an error here to help with debugging.\n    if (h <= 0 || w <= 0) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'Size parameters for displayDialogAsync must be positive');\n    }\n\n    parameters[ParameterId.ExtensionDialogH] = h;\n    parameters[ParameterId.ExtensionDialogW] = w;\n    ErrorHelpers.verifyEnumValue<DialogStyle>(dialogStyle, DialogStyle, 'DialogStyle');\n    parameters[ParameterId.ExtensionDialogStyle] = ExternalToInternalEnumMappings.dialogStyles.convert(dialogStyle);\n\n    return this.execute(VerbId.DisplayDialog, parameters).then((response) => {\n      const dialogResult = response.result as ExtensionDialogResult;\n      switch (dialogResult) {\n        case ExtensionDialogResult.DialogAlreadyOpen:\n          throw new TableauError(ErrorCodes.DialogAlreadyOpen, 'There already exists an open dialog for this extension.');\n        case ExtensionDialogResult.InvalidDomain:\n          throw new TableauError(\n            ErrorCodes.InvalidDomainDialog,\n            'The url of an extension dialog must match the domain of the parent extension.',\n          );\n        default:\n          // Success case\n          return;\n      }\n    });\n  }\n\n  public closeDialog(payload?: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'closeDialog',\n    };\n\n    if (payload) {\n      parameters[ParameterId.ExtensionDialogPayload] = payload;\n    }\n\n    return this.execute(VerbId.CloseDialog, parameters).then(() => {\n      return;\n    });\n  }\n\n  public setClickThroughAsync(clickThroughEnabled: boolean, extensionZoneId: number): Promise<void> {\n    ErrorHelpers.verifyParameterType(clickThroughEnabled, 'boolean', 'clickThroughEnabled');\n\n    if (extensionZoneId === undefined || extensionZoneId <= 0) {\n      throw new TableauError(ErrorCodes.InternalError, 'Extension Id is invalid.');\n    }\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.ExtensionZoneId]: extensionZoneId,\n      [ParameterId.ClickThroughEnabled]: clickThroughEnabled,\n    };\n\n    return this.execute(VerbId.SetClickThrough, parameters).then(() => {\n      return;\n    });\n  }\n}\n","import { InternalApiDispatcher } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry } from '@tableau/api-shared-js';\nimport { InitializationServiceImpl } from './Impl/InitializationServiceImpl';\nimport { SettingsServiceImpl } from './Impl/SettingsServiceImpl';\nimport { UIServiceImpl } from './Impl/UIServiceImpl';\nimport { ExtensionsRegistryId } from './ServiceRegistryUtil';\n\nexport function registerAllExtensionsServices(dispatcher: InternalApiDispatcher): void {\n  ApiServiceRegistry.get(ExtensionsRegistryId).registerService(new SettingsServiceImpl(dispatcher, ExtensionsRegistryId));\n  ApiServiceRegistry.get(ExtensionsRegistryId).registerService(new UIServiceImpl(dispatcher, ExtensionsRegistryId));\n}\n\nexport function registerInitializationExtensionsServices(dispatcher: InternalApiDispatcher): void {\n  ApiServiceRegistry.get(ExtensionsRegistryId).registerService(new InitializationServiceImpl(dispatcher, ExtensionsRegistryId));\n}\n","export const ExtensionsRegistryId = 0;\n","// This file re-exports everything which is part of the extensions api public interface\n\nexport * from './ExternalContract/Embedding/AskDataInterfaces';\nexport {\n  ApiMenuType,\n  CrosstabFileFormat,\n  DeviceType,\n  EmbeddingErrorCodes,\n  TableauEventType as EmbeddingTableauEventType,\n  FileFormats,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  PulseLayout,\n  SheetSizeBehavior,\n  TableauDialogType,\n  Toolbar,\n} from './ExternalContract/Embedding/Enums';\nexport {\n  CustomViewEvent,\n  CustomMarkContextMenuEvent as EmbeddingCustomMarkContextMenuEvent,\n  FilterChangedEvent as EmbeddingFilterChangedEvent,\n  MarksSelectedEvent as EmbeddingMarkSelectedEvent,\n  ParameterChangedEvent as EmbeddingParameterChangedEvent,\n  SummaryDataChangedEvent as EmbeddingSummaryDataChangedEvent,\n  TableauSheetEvent as EmbeddingTableauSheetEvent,\n  TableauWorksheetEvent as EmbeddingTableauWorksheetEvent,\n  ToolbarStateChangedEvent as EmbeddingToolbarStateChangedEvent,\n  FirstVizSizeKnownEvent,\n  StoryPointSwitchedEvent,\n  TabSwitchedEvent,\n  UrlActionEvent,\n  VizLoadErrorEvent,\n  WorkbookPublishedAsEvent,\n} from './ExternalContract/Embedding/EventInterfaces';\nexport { Parameter as EmbeddingParameter } from './ExternalContract/Embedding/ParameterInterfaces';\nexport * from './ExternalContract/Embedding/PulseInterfaces';\nexport {\n  ContextMenuOptions,\n  EmbeddingAbstractQuery,\n  AuthoringWorksheet as EmbeddingAuthoringWorksheet,\n  Dashboard as EmbeddingDashboard,\n  DashboardObject as EmbeddingDashboardObject,\n  Sheet as EmbeddingSheet,\n  EmbeddingVizStateWithDataModel,\n  Worksheet as EmbeddingWorksheet,\n  HierarchicalLevels,\n  SheetInfo,\n  SheetSize,\n} from './ExternalContract/Embedding/SheetInterfaces';\nexport { Story, StoryPoint, StoryPointInfo } from './ExternalContract/Embedding/StoryInterfaces';\nexport * from './ExternalContract/Embedding/TableauError';\nexport * from './ExternalContract/Embedding/VizInterfaces';\nexport * from './ExternalContract/Embedding/WebComponentInterfaces';\nexport {\n  CustomView,\n  AuthoringWorkbook as EmbeddingAuthoringWorkbook,\n  Workbook as EmbeddingWorkbook,\n} from './ExternalContract/Embedding/WorkbookInterface';\nexport * from './SharedApiExternalContract';\n","// This file re-exports everything which is part of the extensions api public interface\n\nexport * from './ExternalContract/Extensions/EventInterface';\nexport { DashboardContent } from './ExternalContract/Extensions/Namespaces/DashboardContent';\nexport { Environment } from './ExternalContract/Extensions/Namespaces/Environment';\nexport { Extensions } from './ExternalContract/Extensions/Namespaces/Extensions';\nexport { Settings } from './ExternalContract/Extensions/Namespaces/Settings';\nexport {\n  ErrorCodes,\n  ExtensionContext,\n  ExtensionMode,\n  TableauEventType,\n  VizImageEncodingType,\n  VizImagePaletteType,\n  VizImageSizeSettingAlignmentType,\n  VizImageSizeSettingType,\n  VizImageSortDirectionType,\n} from './ExternalContract/Extensions/Namespaces/Tableau';\nexport * from './ExternalContract/Extensions/Namespaces/UI';\nexport { WorksheetContent } from './ExternalContract/Extensions/Namespaces/WorksheetContent';\nexport * from './ExternalContract/Extensions/ParameterInterfaces';\nexport {\n  DashboardObjectPositionAndSizeUpdate,\n  DashboardObjectPositionAndSizeUpdateArray,\n  DashboardObjectVisibilityMap,\n  Dashboard as ExtensionDashboard,\n  DashboardObject as ExtensionDashboardObject,\n  Sheet as ExtensionSheet,\n  Worksheet as ExtensionWorksheet,\n  Point,\n  ZoneVisibilityMap,\n} from './ExternalContract/Extensions/SheetInterfaces';\nexport * from './ExternalContract/Extensions/TableauError';\nexport { Workbook as ExtensionWorkbook } from './ExternalContract/Extensions/WorkbookInterfaces';\nexport * from './SharedApiExternalContract';\n","/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\n\nexport * from './EmbeddingApiExternalContract';\nexport * from './ExtensionsApiExternalContract';\n","import { WebComponentLocalSettings, WebComponentSettingsShared } from './WebComponentInterfaces';\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-ask-data> web component.\n * @ignore\n * @deprecated\n */\nexport enum AskDataAttributes {\n  Origin = 'origin',\n  ShowEmbed = 'show-embed',\n  ShowPin = 'show-pin',\n  ShowSave = 'show-save',\n  ShowShare = 'show-share',\n}\n\n/**\n * @deprecated\n */\nexport interface AskDataSettings extends WebComponentSettingsShared, WebComponentLocalSettings {\n  /**\n   * Indicates whether the embed button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-embed>\n   * ```\n   */\n  showEmbed?: boolean;\n\n  /**\n   * Indicates whether the pin button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-pin>\n   * ```\n   */\n  showPin?: boolean;\n\n  /**\n   * Indicates whether the save button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-save>\n   * ```\n   */\n  showSave?: boolean;\n\n  /**\n   * Indicates whether the share button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-share>\n   * ```\n   */\n  showShare?: boolean;\n\n  /**\n   *  Used for telemetry\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" origin=\"embeddingSite\">\n   * ```\n   */\n  origin?: string;\n}\n\n/**\n * The interface for the top level AskData object.\n * @deprecated\n **/\nexport interface AskData extends AskDataSettings {}\n","// All enum values made available to Embedding developers.\n// Enums should be kept in alphabetical order.\n// Most of them should match an enum on the server defined at\n// workgroup/vqlweb/scriptsharp/src/ApiShared/PublicEnums.cs#L398:17\n\n/**\n * Crosstab file formats available to use with {@link Viz.exportCrosstabAsync}\n */\nexport enum CrosstabFileFormat {\n  CSV = 'csv',\n  Excel = 'xlsx',\n}\n\n/**\n * Device types available to use with {@link Viz.device}\n */\nexport enum DeviceType {\n  Default = 'default',\n  Desktop = 'desktop',\n  Tablet = 'tablet',\n  Phone = 'phone',\n}\n\n/**\n * All error codes used by the Embedding API.\n */\nexport enum EmbeddingErrorCodes {\n  /**\n   * Raised when a request to the auth endpoint fails.\n   */\n  AuthFailed = 'auth-failed',\n  /**\n   * The browser is not capable of supporting the Tableau Embedding API\n   */\n  BrowserNotCapable = 'browser-not-capable',\n  /**\n   * The permissions on a workbook or a view do not allow downloading the workbook.\n   */\n  DownloadWorkbookNotAllowed = 'download-workbook-not-allowed',\n  /**\n   * Thrown when an error occurs while attempting to perform a filter operation.\n   */\n  FilterCannotBePerformed = 'filter-cannot-be-performed',\n  /**\n   * Thrown when attempting to switch to a sheet by index that does not exist in the workbook.\n   */\n  IndexOutOfRange = 'index-out-of-range',\n  /**\n   * Thrown when an error occurs within the Tableau Embedding API. Contact Tableau Support.\n   */\n  InternalError = 'internal-error',\n  /**\n   * An operation was attempted on a custom view that does not exist.\n   */\n  InvalidCustomViewName = 'invalid-custom-view-name',\n  /**\n   * An invalid date was specified in a method that required a date parameter.\n   */\n  InvalidDateParameter = 'invalid-date-parameter',\n  /**\n   * Either a filter operation was attempted on a field that does not exist in the data source, or the value supplied\n   * in the filter operation is the wrong data type or format.\n   */\n  invalidFilterFieldNameOrValue = 'invalid-filter-field-name',\n  /**\n   * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message\n   * field.\n   */\n  InvalidParameter = 'invalid-parameter',\n  /**\n   * A negative size was specified or the maxSize value is less than minSize in Sheet.changeSizeAsync().\n   */\n  InvalidSize = 'invalid-size',\n  /**\n   * Attempted to get an authoring worksheet when the current sheet is not a worksheet.\n   * @ignore\n   */\n  InvalidSheetType = 'invalid-sheet-type',\n  /**\n   * A behavior value was found that is not included in the SheetSizeBehavior enum.\n   */\n  InvalidSizeBehavior = 'invalid-size-behavior',\n  /**\n   * A behavior other than SheetSizeBehavior.Automatic was specified in Sheet.changeSizeAsync() when the sheet is a\n   * Worksheet instance.\n   */\n  InvalidSizeBehaviorOnWorksheet = 'invalid-size-behavior-on-worksheet',\n  /**\n   * The URL specified in the Viz class constructor is not valid.\n   */\n  InvalidUrl = 'invalid-url',\n  /**\n   * The maxSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.AtMost.\n   */\n  MissingMaxSize = 'missing-max-size',\n  /**\n   * The minSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.AtLeast.\n   */\n  MissingMinSize = 'missing-min-size',\n  /**\n   * The minSize or maxSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.Range.\n   */\n  MissingMinMaxSize = 'missing-min-max-size',\n  /**\n   * Can occur if the embedding app interacts with a parameter that has been removed from the worksheet.\n   */\n  MissingParameter = 'missing-parameter',\n  /**\n   * The rangeN field is missing for a relative date filter of type LASTN or NEXTN.\n   */\n  MissingRangeNForRelativeDateFilters = 'missing-range-n-for-relative-date-filters',\n  /**\n   * An attempt was made to access Sheet.getUrl() on a hidden sheet. Hidden sheets do not have URLs.\n   */\n  NoUrlForHiddenWorksheet = 'no-url-for-hidden-worksheet',\n  /**\n   * One or both of the parentElement or the URL parameters is not specified in the Viz constructor.\n   */\n  NoUrlOrParentElementNotFound = 'no-url-or-parent-element-not-found',\n  /**\n   * An operation was attempted on a sheet that is not active or embedded within the active dashboard.\n   */\n  NotActiveSheet = 'not-active-sheet',\n  /**\n   * A required parameter was not specified, null, or an empty string/array.\n   */\n  NullOrEmptyParameter = 'null-or-empty-parameter',\n  /**\n   * An operation was attempted on a sheet that does not exist in the workbook.\n   */\n  SheetNotInWorkbook = 'sheet-not-in-workbook',\n  /**\n   * An operation is performed on a CustomView object that is no longer valid (it has been removed).\n   */\n  StaleDataReference = 'stale-data-reference',\n  /**\n   * Unknown error triggered during the auth flow.\n   */\n  UnknownAuthError = 'unknown-auth-error',\n  /**\n   * An unknown event name was specified in the call to Viz.addEventListener or Viz.removeEventListener.\n   */\n  UnsupportedEventName = 'unsupported-event-name',\n  /**\n   * A Viz object has already been created as a child of the parentElement specified in the Viz constructor.\n   */\n  VizAlreadyInManager = 'viz-already-in-manager',\n  /**\n   * Function is not supported in the embedding api.\n   */\n  ImplementationError = 'wrong-implementation',\n  /**\n   * @NotImplemented\n   */\n  NotImplemented = 'not-implemented',\n  /**\n   * Unknown error during event initialization\n   */\n  EventInitializationError = 'event-initialization-error',\n  /**\n   * Version of the embedding api not supported by the version of tableau\n   */\n  IncompatibleVersionError = 'incompatible-version-error',\n\n  /**\n   * Unknown {@link TableauDialogType} passed in to Viz.displayDialogAsync.\n   */\n  UnknownDialogType = 'unknown-dialog-type',\n\n  /**\n   * Can occur if the API interacts with a filter that has been removed from the worksheet.\n   * Can also occurs if a {@link FilterType} has not been implemented.\n   */\n  FilterMissingOrNotImplemented = 'filter-missing-not-implemented',\n\n  /**\n   * Can occur if story point ids no longer match.\n   */\n  StoryPointIdMismatch = 'storypoint-id-mismatch',\n}\n\n/**\n * Formats available to use with displayStaticImage in @VizInterfaces\n */\nexport enum FileFormats {\n  PDF = 'pdf',\n  PNG = 'png',\n}\n\nexport enum PrintOrientation {\n  Portrait = 'portrait',\n  Landscape = 'landscape',\n}\n\nexport enum PrintPageSize {\n  Letter = 'letter',\n  Legal = 'legal',\n  Note = 'note',\n  Folio = 'folio',\n  Tabloid = 'tabloid',\n  Ledger = 'ledger',\n  Statement = 'statement',\n  Executive = 'executive',\n  A3 = 'A3',\n  A4 = 'A4',\n  A5 = 'A5',\n  B4 = 'B4',\n  B5 = 'B5',\n  Quarto = 'quarto',\n  Unspecified = 'unspecified',\n}\n\nexport enum PrintScaling {\n  Automatic = 'automatic',\n  Perc25 = '25%',\n  Perc50 = '50%',\n  Perc60 = '60%',\n  Perc75 = '75%',\n  Perc80 = '80%',\n  Perc90 = '90%',\n  Perc100 = '100%',\n  Perc200 = '200%',\n  Perc400 = '400%',\n  AtMost1PageHigh = 'at-most-1-page-high',\n  AtMost2PagesHigh = 'at-most-2-pages-high',\n  AtMost1PageWide = 'at-most-1-page-wide',\n  AtMost2PagesWide = 'at-most-2-pages-wide',\n}\n\nexport enum RevertVizSelection {\n  All = 'all',\n  Axes = 'axes',\n  Filters = 'filters',\n  Sorts = 'sorts',\n  Shelves = 'shelves',\n}\n\nexport enum ToolbarButtons {\n  Alerts = 'alerts',\n  AskData = 'askData',\n  CustomViews = 'customViews',\n  DataDetails = 'dataDetails',\n  Share = 'share',\n  Subscribe = 'subscribe',\n}\n\nexport enum Toolbar {\n  Top = 'top',\n  Bottom = 'bottom',\n  Hidden = 'hidden',\n}\n\nexport enum SheetSizeBehavior {\n  Automatic = 'automatic',\n  Exactly = 'exactly',\n  Range = 'range',\n  AtLeast = 'atleast',\n  AtMost = 'atmost',\n}\n\nexport enum PulseLayout {\n  Default = 'default',\n  Card = 'card',\n  Ban = 'ban',\n}\n\n/**\n * Be careful when adding new event types. Extensions and embedding follow two different patterns on how events are named.\n * Events should be all lower case and without hyphens or underscores.\n */\n\n/**\n * Represents the type of tableau embedding event that can be listened for.\n */\nexport enum TableauEventType {\n  /**\n   * Raised when a custom view has finished loading. This event is raised after the callback function for {@link FirstInteractive} (if any) has been called.\n   *\n   * @category Viewing\n   */\n  CustomViewLoaded = 'customviewloaded',\n\n  /**\n   * Raised when a custom view has been removed.\n   *\n   * @category Viewing\n   */\n  CustomViewRemoved = 'customviewremoved',\n\n  /**\n   * Raised when a custom view has been saved (newly created or updated).\n   *\n   * @category Viewing\n   */\n  CustomViewSaved = 'customviewsaved',\n\n  /**\n   * Raised when a custom view has been set as the default view for a workbook.\n   *\n   * @category Viewing\n   */\n  CustomViewSetDefault = 'customviewsetdefault',\n\n  /** Raised when the user clicks on the Edit Button.\n   *\n   * @category Viewing\n   */\n  EditButtonClicked = 'editbuttonclicked',\n\n  /** Raised when the user clicks on the Edit In Desktop Button.\n   *\n   * @category Authoring, Viewing\n   */\n  EditInDesktopButtonClicked = 'editindesktopbuttonclicked',\n\n  /** Raised when any filter has changed state. You can use this event type with TableauViz objects.\n   *\n   * @category Viewing\n   */\n  FilterChanged = 'filterchanged',\n\n  /** Fired when viz size is known\n   *\n   * @category Authoring, Viewing\n   */\n  FirstVizSizeKnown = 'firstvizsizeknown',\n\n  /** Fired when a viz first becomes interactive\n   *\n   * @category Authoring, Viewing\n   */\n  FirstInteractive = 'firstinteractive',\n\n  /** Raised when a custom mark context menu is clicked.\n   *\n   * @category Viewing\n   */\n  CustomMarkContextMenuEvent = 'custommarkcontextmenu',\n\n  /** The selected marks on a visualization have changed. You can use this event type with TableauViz objects.\n   *\n   * @category Viewing\n   */\n  MarkSelectionChanged = 'markselectionchanged',\n\n  /** A parameter has had its value modified. You can use this event type with [[Parameter]] objects.\n   *\n   * @category Viewing\n   */\n  ParameterChanged = 'parameterchanged',\n\n  /** Raised when a toolbar button or control becomes available or becomes unavailable.\n   *\n   * @category Viewing\n   */\n  ToolbarStateChanged = 'toolbarstatechanged',\n\n  /** Raised when the workbook is ready to close. This notification is sent when using embedded web authoring functionality.\n   *\n   * @category Authoring\n   */\n  WorkbookReadyToClose = 'workbookreadytoclose',\n\n  /** Raised when the workbook has been published. This notification is sent when using embedded web authoring functionality.\n   *\n   * @category Authoring\n   */\n  WorkbookPublished = 'workbookpublished',\n\n  /** Raised when \"publish as\" is successful. This notification is sent when using embedded web authoring functionality.\n   *\n   * @category Authoring\n   */\n  WorkbookPublishedAs = 'workbookpublishedas',\n\n  /**\n   * Raised when a URL action occurs. See the {@link UrlActionEvent} class.\n   *\n   * @category Viewing\n   */\n  UrlAction = 'urlaction',\n\n  /**\n   * Raised after a tab switch occurs (the active sheet has changed). Guarantees the viz object will be interactive after this.\n   *\n   * @category Viewing\n   */\n  TabSwitched = 'tabswitched',\n  /**\n   *\n   * Raised after a new story point becomes active.\n   *\n   * @category Viewing\n   */\n  StoryPointSwitched = 'storypointswitched',\n  /**\n   *\n   * Raised when an error occurs while loading the contents of the webcomponent.\n   *\n   * @category Authoring, Viewing, AskData\n   */\n  VizLoadError = 'vizloaderror',\n  /**\n   * Raised after the iframe src attribute has been updated\n   *\n   * @category Authoring, Viewing, AskData\n   */\n  IframeSrcUpdated = 'iframesrcupdated',\n\n  /**\n   * Raised when changes are made to summary data.\n   *\n   * @category Viewing\n   */\n  SummaryDataChanged = 'summarydatachanged',\n\n  /**\n   * Raised when tableau (viz-client) is ready to receive an auth token.\n   * Used for authentication in salesforce native mode.\n   *\n   * @hidden\n   * @category Authoring, Viewing,\n   */\n  ReadyToReceiveAuthToken = 'readytoreceiveauthtoken',\n}\n\n/**\n * Represents the location of a context menu where users can add external menu items.\n */\nexport enum ApiMenuType {\n  /** External menu item will be injected in ubertip dialog */\n  Ubertip = 'ubertip',\n}\n\n/** You can use this type with a {@link Viz} object. */\nexport enum TableauDialogType {\n  /**\n   * Used to display the download PDF dialog.\n   */\n  ExportPDF = 'export-pdf',\n  /**\n   * Used to display the download PowerPoint dialog.\n   */\n  ExportPowerPoint = 'export-powerpoint',\n  /**\n   * Used to display the download Data dialog.\n   */\n  ExportData = 'export-data',\n  /**\n   * Used to display the download CrossTab dialog.\n   */\n  ExportCrossTab = 'export-cross-tab',\n  /**\n   * Used to display the download Workbook dialog.\n   */\n  ExportWorkbook = 'export-workbook',\n  /**\n   * Used to display the Share dialog.\n   */\n  Share = 'share',\n}\n","import { PulseLayout } from './Enums';\nimport { WebComponentLocalSettings } from './WebComponentInterfaces';\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-pulse> web component.\n * @ignore\n */\nexport enum PulseAttributes {\n  DisableExploreFilter = 'disable-explore-filter',\n  Layout = 'layout',\n}\n\nexport interface PulseSettings extends WebComponentLocalSettings {\n  /**\n   * Indicates whether the explore filter is hidden or visible.\n   * ```\n   * <tableau-pulse id=\"tableauPulse\" disable-explore-filter>\n   * ```\n   */\n  disableExploreFilter?: boolean;\n\n  /**\n   * Specifies the desired custom layout of the Pulse metric.\n   * ```\n   * <tableau-pulse id=\"tableauPulse\" layout=\"card\">\n   * ```\n   */\n  layout?: PulseLayout;\n\n  /**\n   * The token used for authorization\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-authoring-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-pulse id=\"tableauPulse\" token=\"some-token-containing-clientId\" />\n   * ```\n   */\n  token?: string;\n}\n\n/**\n * The interface for the top-level Pulse object.\n **/\nexport interface Pulse extends PulseSettings {}\n","import {\n  CrosstabFileFormat,\n  DeviceType,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  TableauDialogType,\n  TableauEventType,\n  Toolbar,\n} from './Enums';\nimport { SheetSize } from './SheetInterfaces';\nimport { WebComponentLocalSettings, WebComponentSettingsShared } from './WebComponentInterfaces';\nimport { Workbook } from './WorkbookInterface';\n\n/**\n * The shared string constants you can use as HTML attributes for the <tableau-viz> and <tableau-authoring-viz> web component.\n * @ignore\n */\nexport enum VizSharedAttributes {\n  TouchOptimize = 'touch-optimize',\n  HideEditInDesktopButton = 'hide-edit-in-desktop-button',\n  SuppressDefaultEditBehavior = 'suppress-default-edit-behavior',\n  DisableVersionCheck = 'disable-version-check',\n  OnEditInDesktopButtonClicked = 'onEditInDesktopButtonClicked',\n  OnFirstVizSizeKnown = 'onFirstVizSizeKnown',\n  OnFirstInteractive = 'onFirstInteractive',\n}\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-viz> web component.\n * @ignore\n */\nexport enum VizAttributes {\n  DisableUrlActionsPopups = 'disable-url-actions',\n  HideTabs = 'hide-tabs',\n  Toolbar = 'toolbar',\n  InstanceIdToClone = 'instance-id-to-clone',\n  Device = 'device',\n  HideEditButton = 'hide-edit-button',\n  OnEditButtonClicked = 'onEditButtonClicked',\n  OnFilterChanged = 'onFilterChanged',\n  OnCustomMarkContextMenuEvent = 'onCustomMarkContextMenuEvent',\n  OnMarkSelectionChanged = 'onMarkSelectionChanged',\n  OnParameterChanged = 'onParameterChanged',\n  OnToolbarStateChanged = 'onToolbarStateChanged',\n  OnUrlAction = 'onUrlAction',\n  OnTabSwitched = 'onTabSwitched',\n  OnCustomViewLoaded = 'onCustomViewLoaded',\n  OnCustomViewRemoved = 'onCustomViewRemoved',\n  OnCustomViewSaved = 'onCustomViewSaved',\n  OnCustomViewSetDefault = 'onCustomViewSetDefault',\n  OnStoryPointSwitched = 'onStoryPointSwitched',\n  OnSummaryDataChanged = 'onSummaryDataChanged',\n  OnReadyToReceiveAuthToken = 'onReadyToReceiveAuthToken',\n}\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-authoring-viz> web component.\n * @ignore\n */\nexport enum VizAuthoringAttributes {\n  OnWorkbookPublished = 'onWorkbookPublished',\n  OnWorkbookPublishedAs = 'onWorkbookPublishedAs',\n  OnWorkbookReadyToClose = 'onWorkbookReadyToClose',\n  HideCloseButton = 'hide-close-button',\n}\n\n/**\n * The names of the string constants you can use as child tags for TableauViz and TableauAuthoringViz custom elements.\n */\nexport enum VizChildElements {\n  /**\n   * Contains a list of filter parameters. Available only in viewing mode.\n   */\n  VizFilter = 'viz-filter',\n\n  /**\n   * Contains a name and value for a parameter. Available only in viewing mode.\n   */\n  VizParameter = 'viz-parameter',\n\n  /**\n   * Contains a list of custom parameters.  Available in both viewing and authoring modes.\n   */\n  CustomParameter = 'custom-parameter',\n}\n\nexport enum VizChildElementAttributes {\n  Field = 'field',\n  Value = 'value',\n  Name = 'name',\n}\n\n/**\n * The interface for the top level Viz object.\n **/\nexport interface Viz extends VizSettings, WebComponentLocalSettings, VizActions {\n  /**\n   * One Workbook is supported per visualization.\n   */\n  readonly workbook?: Workbook;\n\n  /**\n   * Provide an auth token for salesforce native mode\n   * @param token\n   */\n  setAuthToken(token: string): void;\n}\n\n/**\n * The interface for the top level Authoring Viz object.\n */\nexport interface AuthoringViz extends VizAuthoringSettings, WebComponentLocalSettings {\n  /**\n   * Gets the visualization's current URL.\n   */\n  getCurrentSrcAsync(): Promise<string>;\n\n  /**\n   * Provide an auth token for salesforce native mode\n   * @param token\n   */\n  setAuthToken(token: string): void;\n}\n\n/**\n * Partially implemented - Actions related to events and state of the viz\n */\nexport interface VizActions {\n  /**\n   * Indicates whether automatic updates are currently paused.\n   */\n  readonly automaticUpdatesArePaused: boolean;\n\n  /**\n   * Pause layout updates. This is useful if you are resizing the visualization or performing multiple calls that could affect the layout.\n   */\n  pauseAutomaticUpdatesAsync(): Promise<void>;\n\n  /**\n   * Resume layout updates.\n   */\n  resumeAutomaticUpdatesAsync(): Promise<void>;\n\n  /**\n   * Toggle layout updates.\n   */\n  toggleAutomaticUpdatesAsync(): Promise<void>;\n\n  /**\n   * Equivalent to clicking on the Revert All toolbar button, which restores the workbook to its starting state.\n   */\n  revertAllAsync(): Promise<void>;\n\n  /**\n   * Equivalent to clicking on the Refresh Data toolbar button.\n   */\n  refreshDataAsync(): Promise<void>;\n\n  /**\n   * Equivalent to clicking on Download > Image from the toolbar, which creates a PNG file of the current visualization.\n   */\n  exportImageAsync(): Promise<void>;\n\n  /**\n   * Exports the crosstab of any given worksheet within the current view to a\n   * specified format (CrosstabFileFormat.Excel, CrosstabFileFormat.CSV).\n   * Throws an error if the sheet name does not match any worksheets within the active sheet.\n   * Throws an error if the crosstab file failed to be created.\n   * Note: exportCrosstabAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * viz.exportCrosstabAsync('Sales by Segment', CrosstabFileFormat.CSV);\n   * ```\n   */\n  exportCrosstabAsync(sheetName: string, format: CrosstabFileFormat): Promise<void>;\n\n  /**\n   * Exports the summary data shown in the View Data window\n   * (shown when you click Download > Data from the toolbar for any given worksheet within the current view).\n   * The current file format is CSV. There is no limitation on the amount of summary data you can export.\n   * Throws an error if the sheet name does not match any worksheets within the active sheet.\n   * Throws an error if the CSV file failed to be created.\n   * Note: exportDataAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * const activeSheet = viz.workbook.activeSheet;\n   * if (activeSheet.sheetType === SheetType.Worksheet) {\n   *   const columns = await activeSheet.getSummaryColumnsInfoAsync();\n   *   // Getting fieldId's for Latitude and Longitude columns\n   *   const columnsToIncludeById = columns.map((column) => {\n   *     if (column.fieldName === 'Latitude' || column.fieldName === 'Longitude') {\n   *       return column.fieldId;\n   *     }\n   *   });\n   *   await viz.exportDataAsync(activeSheet.name, { columnsToIncludeById });\n   * }\n   * else if (activeSheet.sheetType === SheetType.Dashboard) {\n   *   // Exporting the summary data for each worksheet in the dashboard while also ignoring aliases\n   *   for (const worksheet of activeSheet.worksheets) {\n   *     await viz.exportDataAsync(worksheet.name, { ignoreAliases: true });\n   *   }\n   * }\n   * else\n   * {\n   *   // activeSheet is a Story and we want to export worksheets within the current view\n   *   const containedSheet = activeSheet.activeStoryPoint.containedSheet;\n   *   if (containedSheet !== undefined && containedSheet.sheetType === SheetType.Worksheet) {\n   *     // Exporting summary data of a worksheet within the active story point\n   *     await viz.exportDataAsync(containedSheet.name);\n   *   } else if (containedSheet !== undefined && containedSheet.sheetType === SheetType.Dashboard) {\n   *     // Exporting the summary data for each worksheet within the active story point\n   *     for (const worksheet of containedSheet.worksheets) {\n   *       await viz.exportDataAsync(worksheet.name);\n   *     }\n   *   }\n   * }\n   * ```\n   */\n  exportDataAsync(sheetName: string, options?: ExportDataOptions): Promise<void>;\n\n  /**\n   * Exports the list of sheets to a PowerPoint file. If no sheets are specified, the current sheet is exported.\n   * The order the sheets appear in the list is the order the sheets appear in the PowerPoint file.\n   * The list of sheets can either exclusively include the worksheets within a dashboard or exclusively include the published sheets from the workbook.\n   *\n   * Throws an error if the list of sheets contains both worksheets within a dashboard and published sheets from the workbook.\n   * Throws an error if the PowerPoint file fails to be created.\n   *\n   * Note: exportPowerPointAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * const workbook = viz.workbook;\n   * const activeSheet = workbook.activeSheet;\n   * if (activeSheet.sheetType === SheetType.Worksheet || activeSheet.sheetType === SheetType.Story) {\n   *   await viz.exportPowerPointAsync();\n   * } else if (activeSheet.sheetType ===  SheetType.Dashboard) {\n   *   const worksheetNames = activeSheet.worksheets.map((worksheet) => worksheet.name);\n   *   await viz.exportPowerPointAsync(worksheetNames);\n   * }\n   * // exporting all sheets within the workbook to PowerPoint\n   * const publishedSheetNames = workbook.publishedSheetsInfo.map((publishedSheetInfo) => publishedSheetInfo.name);\n   * await viz.exportPowerPointAsync(publishedSheetNames);\n   * ```\n   */\n  exportPowerPointAsync(sheetNames?: Array<string>): Promise<void>;\n\n  /**\n   * Exports the list of sheets with the given {@link ExportPDFOptions} options. If no sheets are specified, the current sheet is exported.\n   * The list of sheets can either exclusively include the worksheets within a dashboard or exclusively include the published sheets from the workbook.\n   * If no ExportPDFOptions are specified, the default settings are: Scaling = Automatic, PageSize = Letter, and Orientation = Portrait.\n   *\n   * Throws an error if the list of sheets contains both worksheets within a dashboard and published sheets from the workbook.\n   * Throws an error if the PDF file fails to be created.\n   *\n   * Note: exportPDFAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * const workbook = viz.workbook;\n   * const activeSheet = workbook.activeSheet;\n   * if (activeSheet.sheetType === SheetType.Worksheet || activeSheet.sheetType === SheetType.Story) {\n   *   await viz.exportPDFAsync();\n   * } else if (activeSheet.sheetType ===  SheetType.Dashboard) {\n   *   const worksheetNames = activeSheet.worksheets.map((worksheet) => worksheet.name);\n   *   await viz.exportPDFAsync(worksheetNames);\n   * }\n   * // exporting all sheets within the workbook to PDF\n   * const publishedSheetNames = workbook.publishedSheetsInfo.map((publishedSheetInfo) => publishedSheetInfo.name);\n   * await viz.exportPDFAsync(publishedSheetNames);\n   * ```\n   */\n  exportPDFAsync(sheetNames?: Array<string>, options?: ExportPDFOptions): Promise<void>;\n\n  /**\n   * Display one of the export dialogs based on the dialogType parameter\n   *\n   * Throws an error if dialogType is invalid\n   */\n  displayDialogAsync(dialogType: TableauDialogType): Promise<void>;\n\n  /**\n   * Gets the visualization's current URL.\n   */\n  getCurrentSrcAsync(): Promise<string>;\n\n  /**\n   * Redoes the last action performed on a sheet.\n   */\n  redoAsync(): Promise<void>;\n\n  /**\n   * Undoes the last action performed on a sheet.\n   */\n  undoAsync(): Promise<void>;\n\n  /**\n   * Adds an event listener to the specified event.\n   *\n   * ```\n   * async function getSelectedMarks(event) {\n   *     const marksSelected = await event.detail.getMarksAsync();\n   *     const numMarks = marksSelected.data[0].data.length;\n   *     console.log(`${numMarks} marks Selected`);\n   * }\n   *\n   * let viz = document.getElementById('tableauViz');\n   * viz.addEventListener(\"markselectionchanged\", getSelectedMarks);\n   * ```\n   */\n  addEventListener(type: TableauEventType, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;\n\n  /**\n   * Removes an event listener from the specified event.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * viz.removeEventListener(\"markselectionchanged\", getSelectedMarks);\n   * ```\n   */\n  removeEventListener(type: TableauEventType, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;\n\n  /**\n   * Use this method to filter the viz before initialization. If used after initialization, it will re-render the viz.\n   * For filtering after initialization, use the other filtering methods, such as `applyFilterAsync`.\n   *\n   * If you add the same filter fields using the `addFilter()` method and by using the `<viz-filter>` element in the `<tableau-viz>` web component,\n   * you might experience unexpected behavior.\n   *\n   * @param fieldName The name of the field to filter on.\n   * @param value Single value or a list of comma separated values to filter on.\n   *\n   * ```\n   * viz.addFilter('Region', 'Central,West');\n   * ```\n   */\n  addFilter(fieldName: string, value: string): void;\n}\n\nexport interface VizSize {\n  /**\n   * Gets the sheetSize record for the current sheet\n   */\n  readonly sheetSize: SheetSize;\n\n  /**\n   * Gets the height of the Tableau UI elements (the chrome) surrounding the view.\n   */\n  readonly chromeHeight: number;\n}\n\n/**\n * This interface represents all of the options for configuring a viz that are common between\n * viewing and authoring mode.\n */\ninterface VizSettingsShared extends WebComponentSettingsShared {\n  /**\n   * Indicates whether to touch optimize viz controls.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" touch-optimize />\n   * <tableau-authoring-viz id=\"tableauViz\" touch-optimize />\n   * ```\n   */\n  touchOptimize?: boolean;\n\n  /**\n   * Indicates whether the Edit in Desktop button is hidden or visible.\n   * If not specified, defaults to false, meaning that the Edit in Desktop button is visible.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" hide-edit-in-desktop-button>\n   * <tableau-authoring-viz id=\"tableauViz\" hide-edit-in-desktop-button>\n   * ```\n   */\n  hideEditInDesktopButton?: boolean;\n\n  /**\n   * Indicates whether the default edit behavior is suppressed.\n   * If not specified, defaults to false, meaning that the default edit behavior is not suppressed.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" suppress-default-edit-behavior>\n   * <tableau-authoring-viz id=\"tableauViz\" suppress-default-edit-behavior>\n   * ```\n   */\n  suppressDefaultEditBehavior?: boolean;\n\n  /**\n   * An event raised when the user clicks on the Edit In Desktop Button. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onEditInDesktopButtonClicked=\"onEditInDesktopButtonClickedHandler\" />\n   * <tableau-authoring-viz id=\"tableauViz\" onEditInDesktopButtonClicked=\"onEditInDesktopButtonClickedHandler\" />\n   * ```\n   */\n  onEditInDesktopButtonClicked?: string;\n\n  /**\n   * An event raised when the size of the viz is known. You can use this event to perform tasks such as resizing\n   * the elements surrounding the Viz object once the object's size has been established.\n   * ```\n   * <tableau-viz id=\"tableauViz\" \"onFirstVizSizeKnown\"=\"onFirstVizSizeKnownHandler\" />\n   * <tableau-authoring-viz id=\"tableauViz\" onFirstVizSizeKnown=\"onFirstVizSizeKnownHandler\" />\n   * ```\n   */\n  onFirstVizSizeKnown?: string;\n\n  /**\n   * An event raised when the Viz object first becomes interactive. This is only raised once.\n   * ```\n   * <tableau-viz id=\"tableauViz\" \"onFirstInteractive\"=\"onFirstInteractiveHandler\" />\n   * <tableau-authoring-viz id=\"tableauViz\" onFirstInteractive=\"onFirstInteractiveHandler\" />\n   * ```\n   */\n  onFirstInteractive?: string;\n}\n\n/**\n * The options for configuring a viz in view mode.\n */\nexport interface VizSettings extends VizSettingsShared {\n  /**\n   * Indicates whether to suppress the execution of URL actions. This option does not prevent the URL action\n   * event from being raised. You can use this option to change what happens when a URL action occurs. If set\n   * to true and you create an event listener for the URL_ACTION event, you can use an event listener\n   * handler to customize the actions.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" disable-url-actions />\n   * ```\n   */\n  disableUrlActionsPopups?: boolean;\n\n  /**\n   * Indicates whether tabs are hidden or shown.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  hide-tabs />\n   * ```\n   */\n  hideTabs?: boolean;\n\n  /**\n   * Specifies the position of the toolbar, if it is shown. The values can be Toolbar.Top,\n   * Toolbar.Bottom or Toolbar.Hidden.\n   * If not specified, defaults to Toolbar.Bottom.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  toolbar=\"hidden\" />\n   * ```\n   */\n  toolbar?: Toolbar;\n\n  /**\n   * Specifies a device layout for a dashboard, if it exists.\n   * Values can be default, desktop, tablet, or phone.\n   * If not specified, defaults to loading a layout based on the\n   * smallest dimension of the hosting iframe element.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  device=\"desktop\" />\n   * ```\n   */\n  device?: DeviceType;\n\n  /**\n   * Specifies the ID of an existing instance to make a copy (clone) of.\n   * This is useful if the user wants to continue analysis of an existing visualization\n   * without losing the state of the original. If the ID does not refer to an existing visualization,\n   * the cloned version is derived from the original visualization.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  instance-id-to-clone=\"id1\" />\n   * ```\n   */\n  instanceIdToClone?: string;\n\n  /**\n   * Indicates whether the Edit button is hidden or visible.\n   * If not set, defaults to false, meaning that the Edit button is visible.\n   * ```\n   * <tableau-viz id=\"tableauViz\" hide-edit-button>\n   * ```\n   */\n  hideEditButton?: boolean;\n\n  /**\n   * An event raised when the user clicks on the Edit Button.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onEditButtonClicked=\"onEditButtonClickedHandler\" />\n   * ```\n   */\n  onEditButtonClicked?: string;\n\n  /**\n   * An event raised when any filter has changed state. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onFilterChanged=\"onFilterChangedHandler\" />\n   * ```\n   */\n  onFilterChanged?: string;\n\n  /**\n   * An event raised when a custom mark context menu is clicked.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomMarkContextMenuEvent=\"onCustomMarkContextMenuEventHandler\" />\n   * ```\n   */\n  onCustomMarkContextMenuEvent?: string;\n\n  /**\n   * An event raised when the selected marks on a visualization have changed. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onMarkSelectionChanged=\"onMarkSelectionChangedHandler\" />\n   * ```\n   */\n  onMarkSelectionChanged?: string;\n\n  /**\n   * An event raised when a parameter has had its value modified. You can use this event type with [[Parameter]] objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onParameterChanged=\"onParameterChangedHandler\" />\n   * ```\n   */\n  onParameterChanged?: string;\n\n  /**\n   * An event raised when a toolbar button or control becomes available or becomes unavailable.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onToolbarStateChanged=\"onToolbarStateChangedHandler\" />\n   * ```\n   */\n  onToolbarStateChanged?: string;\n\n  /**\n   * An event raised when a URL action occurs. See the {@link UrlActionEvent} class.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onUrlAction=\"onUrlActionHandler\" />\n   * ```\n   */\n  onUrlAction?: string;\n\n  /**\n   * An event raised after a tab switch occurs (the active sheet has changed). Guarantees the viz object will be interactive after this.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onTabSwitched=\"onTabSwitchedHandler\" />\n   * ```\n   */\n  onTabSwitched?: string;\n\n  /**\n   * An event raised when a custom view has finished loading. This event is raised after the callback\n   * function for {@link FirstInteractive} (if any) has been called.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewLoaded=\"onCustomViewLoadedHandler\" />\n   * ```\n   */\n  onCustomViewLoaded?: string;\n\n  /**\n   * An event raised when a custom view has been removed.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewRemoved=\"onCustomViewRemovedHandler\" />\n   * ```\n   */\n  onCustomViewRemoved?: string;\n\n  /**\n   * An event raised when a custom view has been saved (newly created or updated).\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewSaved=\"onCustomViewSavedHandler\" />\n   * ```\n   */\n  onCustomViewSaved?: string;\n\n  /**\n   * An event raised when a custom view has been set as the default view for a workbook.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewSetDefault=\"onCustomViewSetDefaultHandler\" />\n   * ```\n   */\n  onCustomViewSetDefault?: string;\n\n  /**\n   * An event raised after a new story point becomes active.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onStoryPointSwitched=\"onStoryPointSwitchedHandler\" />\n   * ```\n   */\n  onStoryPointSwitched?: string;\n\n  /**\n   * An event raised when the summary data on a visualization have changed. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onSummaryDataChanged=\"onSummaryDataChangedHandler\" />\n   * ```\n   */\n  onSummaryDataChanged?: string;\n}\n\n/**\n * (Beta) Represents the options for configuring a viz in authoring mode.\n */\nexport interface VizAuthoringSettings extends VizSettingsShared {\n  /**\n   * Indicates whether the Close button is hidden or visible.\n   * If not set, defaults to false, meaning that the Close button is visible.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" hide-close-button />\n   * ```\n   */\n  hideCloseButton?: boolean;\n\n  /**\n   * An event raised when the workbook has been published. This notification is sent when using embedded web authoring functionality.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" onWorkbookPublished=\"onWorkbookPublishedHandler\" />\n   * ```\n   */\n  onWorkbookPublished?: string;\n\n  /**\n   * An event raised when \"publish as\" is successful. This notification is sent when using embedded web authoring functionality.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" onWorkbookPublishedAs=\"onWorkbookPublishedAsHandler\" />\n   * ```\n   */\n  onWorkbookPublishedAs?: string;\n\n  /**\n   * An event raised when the workbook is ready to close. This notification is sent when using embedded web authoring functionality.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" onWorkbookReadyToClose=\"onWorkbookReadyToCloseHandler\" />\n   * ```\n   */\n  onWorkbookReadyToClose?: string;\n}\n\nexport interface FilterParameters {\n  field: string;\n  value: string;\n}\n\n/**\n * VizParameters are used to set Parameter values on the viz.\n *\n * * ```\n * <tableau-viz id=\"tableauViz\">\n *  <viz-parameter name=\"parameter-name\" value=\"parameter-value\"></viz-parameter>\n * </tableau-viz>\n * ```\n *\n */\nexport interface VizParameter {\n  /**\n   * Name of the parameter to be set.\n   */\n  name: string;\n\n  /**\n   * Valid value for the parameter being set.\n   */\n  value: string;\n}\n\n/**\n * CustomParameters are used to pass along settings, information, etc., that aren't exposed on the\n * tableau-viz element. CustomParameters will override attributes, or filters, set on the tableau-viz element.\n *\n * * ```\n * <tableau-viz id=\"tableauViz\">\n *  <custom-parameter name=\"parameter-name\" value=\"parameter-value\"></custom-parameter>\n * </tableau-viz>\n * ```\n *\n */\nexport interface CustomParameter {\n  /**\n   * Name of the parameter to be set.\n   */\n  name: string;\n\n  /**\n   * Valid value for the parameter being set.\n   */\n  value: string;\n}\n\n/**\n * Configuration object for exporting data.\n */\nexport interface ExportDataOptions {\n  /**\n   * Do not use aliases specified in the data source in Tableau. Default is false.\n   */\n  ignoreAliases?: boolean;\n  /**\n   * The columns to include specified by field id, includes all by default.\n   * The order of the column ids in the array determines the column order shown in the summary data table.\n   */\n  columnsToIncludeById?: Array<string>;\n}\n\nexport interface ExportPDFOptions {\n  scaling: PrintScaling;\n  pageSize: PrintPageSize;\n  orientation: PrintOrientation;\n}\n\nexport interface ExportScenariosForPDFAndPowerPoint {\n  currentSheetName: string;\n  exportableSheetNamesFromDashboard: Array<string>;\n  exportableSheetNamesFromWorkbook: Array<string>;\n}\n","/**\n * User supplied options that do not get passed as request parameters to load a Tableau viz, Tableau askdata\n */\nexport interface WebComponentLocalSettings {\n  /**\n   * The viz src\n   */\n  src?: string | null;\n\n  /**\n   * Represents width in pixels\n   * Can be any valid CSS size specifier. If not specified, defaults to the published width of the view.\n   */\n  width?: string | number;\n\n  /**\n   * Represents height in pixels\n   * Can be any valid CSS size specifier. If not specified, defaults to the published height of the view.\n   */\n  height?: string | number;\n}\n\n/**\n * This interface represents all of the options for configuring a webcomponent that are common between\n * viz and askdata.\n */\nexport interface WebComponentSettingsShared {\n  /**\n   * The token used for authorization\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-authoring-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-ask-data id=\"tableauAskData\" token=\"some-token-containing-clientId\" />\n   * ```\n   */\n  token?: string;\n\n  /**\n   * Indicates whether the non-minified version of JavaScript is loaded. If specified (or set to true), the\n   * non-minified version is used for both the local component and the Tableau Server visualization (if enabled).\n   * If not specified (or set to false), the minified version of the JavaScript files are loaded.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" debug />\n   * <tableau-authoring-viz id=\"tableauViz\" debug />\n   * <tableau-ask-data id=\"tableauAskData\" debug />\n   * ```\n   */\n  debug?: boolean;\n\n  /**\n   * Indicates whether to use the old auth mechanism for authentication which happens inside the iframe. If specified, VizLoadErrorEvents\n   * triggered due to auth failures will not be thrown.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" iframe-auth />\n   * <tableau-authoring-viz id=\"tableauViz\" iframe-auth />\n   * <tableau-ask-data id=\"tableauAskData\" iframe-auth />\n   * ```\n   */\n  iframeAuth?: boolean;\n}\n\n/**\n * The names of the common string constants you can use as HTML attributes for the tableau web component.\n * @ignore\n */\nexport enum WebComponentAttributes {\n  Src = 'src',\n  Width = 'width',\n  Height = 'height',\n  Token = 'token',\n  Debug = 'debug',\n  IframeAuth = 'iframe-auth',\n  OnVizLoadError = 'onvizloaderror',\n  ForceTokenSync = 'force-token-sync',\n}\n\n/**\n * The names of the string constants you can use as child tags for TableauViz, TableauAuthoringViz and TableauAskData custom elements.\n * @ignore\n */\nexport enum WebComponentChildElements {\n  /**\n   * Contains a list of custom parameters.  Available in viz viewing, viz authoring and askdata.\n   */\n  CustomParameter = 'custom-parameter',\n}\n\nexport enum WebComponentChildElementAttributes {\n  Field = 'field',\n  Value = 'value',\n  Name = 'name',\n}\n","// All enum values made available to Extensions developers.\n// Enums should be kept in alphabetical order.\n\nimport { Extensions } from './Extensions';\n\nnamespace Tableau {\n  export let extensions: Extensions;\n  /**\n   * All error codes used by the Extensions API.\n   */\n  export enum ErrorCodes {\n    /**\n     * Thrown when caller attempts to execute command before initialization has completed.\n     */\n    APINotInitialized = 'api-not-initialized',\n    /**\n     * Thrown when caller attempts to execute command while extension is not visible.\n     */\n    VisibilityError = 'visibility-error',\n    /**\n     * Only one dialog can be opened at time with the UI namespace functionality.\n     */\n    DialogAlreadyOpen = 'dialog-already-open',\n    /**\n     * The open dialog was closed by the user.\n     */\n    DialogClosedByUser = 'dialog-closed-by-user',\n    /**\n     * An error occurred within the Tableau Extensions API. Contact Tableau Support.\n     */\n    InternalError = 'internal-error',\n    /**\n     * A dialog must start on the same domain as the parent extenion.\n     */\n    InvalidDomainDialog = 'invalid-dialog-domain',\n    /**\n     * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.\n     */\n    InvalidParameter = 'invalid-parameter',\n    /**\n     * Can occur if the extension interacts with a filter that has been removed from the worksheet.\n     */\n    MissingFilter = 'missing-filter',\n    /**\n     * Can occur if the extension interacts with a parameter that has been removed from the worksheet.\n     */\n    MissingParameter = 'missing-parameter',\n    /**\n     * Internal Server Error\n     */\n    ServerError = 'server-error',\n    /**\n     * Developer cannot save settings while another save is still in progress.\n     */\n    SettingSaveInProgress = 'setting-save-in-progress',\n    /**\n     * An unknown event name was specified in the call to `addEventListener` or `removeEventListener`.\n     */\n    UnsupportedEventName = 'unsupported-event-name',\n    /**\n     * A method was used for a type of data source that doesn't support that method (see getActiveTablesAsync for an example)\n     */\n    UnsupportedMethodForDataSourceType = 'unsupported-method-for-data-source-type',\n  }\n\n  /**\n   * The context in which the Extensions is currently running.\n   */\n  export enum ExtensionContext {\n    Desktop = 'desktop',\n    Server = 'server',\n  }\n\n  /**\n   * The mode in which the Extensions is currently running.\n   */\n  export enum ExtensionMode {\n    Authoring = 'authoring',\n    Viewing = 'viewing',\n  }\n\n  /**\n   * Represents the type of event that can be listened for.\n   */\n  export enum TableauEventType {\n    /** Raised when any filter has changed state. You can use this event type with [Worksheet](../interfaces/worksheet.html) objects.*/\n    FilterChanged = 'filter-changed',\n\n    /** The selected marks on a visualization has changed.\n     * You can use this event type with [Worksheet](../interfaces/worksheet.html) objects. */\n    MarkSelectionChanged = 'mark-selection-changed',\n\n    /** The summary data backing a worksheet has changed\n     * You can use this event type with [Worksheet](../interfaces/worksheet.html) objects.*/\n    SummaryDataChanged = 'summary-data-changed',\n\n    /** A parameter has had its value modified. You can use this event type with [[Parameter]] objects. */\n    ParameterChanged = 'parameter-changed',\n\n    /** Settings have been changed for this extension. You can use this event type with [[Settings]] objects. */\n    SettingsChanged = 'settings-changed',\n\n    /** The dashboard layout has changed\n     * @category Dashboard Extensions\n     */\n    DashboardLayoutChanged = 'dashboard-layout-changed',\n\n    /** The workbook formatting has changed\n     * @category Dashboard Extensions\n     */\n    WorkbookFormattingChanged = 'workbook-formatting-changed',\n  }\n\n  /**\n   * Enum that represents the data type of encodings for createVizImageAsync.\n   * @since 1.6.0\n   */\n  export enum VizImageEncodingType {\n    Discrete = 'discrete',\n    Continuous = 'continuous',\n  }\n\n  /**\n   * Enum that represents the sort direction for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImageSortDirectionType {\n    Ascending = 'ascending',\n    Descending = 'descending',\n  }\n\n  /**\n   * Enum that represents the palette type for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImagePaletteType {\n    CustomDiverging = 'custom-diverging',\n    CustomSequential = 'custom-sequential',\n  }\n\n  /**\n   * Enum that represents the Size Setting type for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImageSizeSettingType {\n    Fixed = 'fixed',\n    Manual = 'manual',\n  }\n\n  /**\n   * Enum that represents the Size Setting alignment type for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImageSizeSettingAlignmentType {\n    Right = 'right',\n    Left = 'left',\n    Center = 'center',\n  }\n}\nexport = Tableau;\n","export enum SharedErrorCodes {\n  /**\n   * A CSV or Excel file failed to be created in Viz.exportCrosstabAsync().\n   */\n  CrosstabCreationError = 'crosstab-creation-error',\n  /**\n   * A CSV file failed to be created in Viz.exportDataAsync().\n   */\n  DataCreationError = 'data-creation-error',\n  /**\n   * An invalid aggregation was specified for the filter, such as setting a range filter to \"SUM(Sales)\" instead of\n   * \"Sales\".\n   */\n  InvalidAggregationFieldName = 'invalid-aggregation-field-name',\n  /**\n   * A filter operation was attempted on a field that does not exist in the data source.\n   */\n  InvalidFilterFieldName = 'invalid-filter-name',\n  /**\n   * A filter operation was attempted using a value that is the wrong data type or format.\n   */\n  InvalidFilterFieldValue = 'invalid-filter-fieldValue',\n  /**\n   * An invalid date value was specified in a Sheet.selectMarksAsync() call for a date field.\n   */\n  InvalidSelectionDate = 'invalid-selection-date',\n  /**\n   * A field was specified in a Sheet.selectMarksAsync() call that does not exist in the data source.\n   */\n  InvalidSelectionFieldName = 'invalid-selection-fieldName',\n  /**\n   * An invalid value was specified in a Sheet.selectMarksAsync() call.\n   */\n  InvalidSelectionValue = 'invalid-selection-value',\n  /**\n   * A parameter did not include a valid sheet selection for exporting.\n   */\n  InvalidSelectionSheet = 'invalid-selection-sheet',\n  /**\n   * An error occurred within the Tableau API. Contact Tableau Support.\n   */\n  InternalError = 'internal-error',\n  /**\n   * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.\n   */\n  InvalidParameter = 'invalid-parameter',\n  /**\n   * A PDF file failed to be created in Viz.exportPDFAsync().\n   */\n  PDFCreationError = 'pdf-creation-error',\n  /**\n   * A PowerPoint file failed to be created in Viz.exportPowerPointAsync().\n   */\n  PowerPointCreationError = 'powerpoint-creation-error',\n  /**\n   * An operation was attempted on a sheet that is not active or embedded within the active dashboard.\n   */\n  NotActiveSheet = 'not-active-sheet',\n  /**\n   * Property or Function is not supported within the Tableau API.\n   */\n  ImplementationError = 'wrong-implementation',\n  /**\n   * Can occur when two incompatible calls are triggered together.\n   */\n  ApiExecutionError = 'api-execution-error',\n  /**\n   * A general-purpose server error occurred. Details are contained in the Error object.\n   */\n  ServerError = 'server-error',\n  /**\n   * Can occur when an api call times out.\n   */\n  Timeout = 'timeout',\n}\n","/**\n * The tableau namespace exists for organization and to avoid polluting\n * the global namespace. It contains no constructs other than sub-namespaces and the Tableau enumerations.\n */\nnamespace Tableau {\n  export enum AnalyticsObjectType {\n    Cluster = 'cluster',\n    Forecast = 'forecast',\n    TrendLine = 'trend-line',\n  }\n\n  export enum AnnotationType {\n    Mark = 'mark',\n    Point = 'point',\n    Area = 'area',\n  }\n\n  export enum ColumnType {\n    Discrete = 'discrete',\n    Continuous = 'continuous',\n    Unknown = 'unknown',\n  }\n\n  export enum ClassNameKey {\n    WorksheetTitle = 'tableau-worksheet-title',\n    Worksheet = 'tableau-worksheet',\n    Tooltip = 'tableau-tooltip',\n    StoryTitle = 'tableau-story-title',\n    DashboardTitle = 'tableau-dashboard-title',\n  }\n\n  /**\n   * What the object represents in a dashboard.\n   */\n  export enum DashboardObjectType {\n    Blank = 'blank',\n    Worksheet = 'worksheet',\n    QuickFilter = 'quick-filter',\n    ParameterControl = 'parameter-control',\n    PageFilter = 'page-filter',\n    Legend = 'legend',\n    Title = 'title',\n    Text = 'text',\n    Image = 'image',\n    WebPage = 'web-page',\n    Extension = 'extension',\n  }\n\n  /**\n   * Enum that represents the visibility state of a dashboard object.\n   * @since 1.7.0\n   */\n  export enum DashboardObjectVisibilityType {\n    /** Used for turning on the visibility of a dashboard object.*/\n    Show = 'show',\n\n    /** Used for turning off the visibility of a dashboard object.*/\n    Hide = 'hide',\n  }\n\n  /**\n   * The different types of data a value can have\n   */\n  export enum DataType {\n    String = 'string',\n    Int = 'int',\n    Float = 'float',\n    Bool = 'bool',\n    Date = 'date',\n    DateTime = 'date-time',\n    Spatial = 'spatial',\n    Unknown = 'unknown',\n  }\n\n  /**\n   * Enum that represents the changes that occur to a dashboard object.\n   */\n  export enum DashboardLayoutChange {\n    /** A dashboard object was added */\n    Added = 'added',\n\n    /** A dashboard object was removed */\n    Removed = 'removed',\n\n    /** A dashboard object's floating state changed */\n    IsFloatingChanged = 'is-floating-changed',\n\n    /** A dashboard object's visibility changed */\n    IsVisibleChanged = 'is-visible-changed',\n\n    /** A dashboard object's position changed */\n    PositionChanged = 'position-changed',\n\n    /** A dashboard object's size changed */\n    SizeChanged = 'size-changed',\n\n    /** A dashboard object was renamed */\n    NameChanged = 'name-changed',\n\n    /** A dashboard object is selected */\n    Selected = 'selected',\n\n    /** A dashboard object is deselected */\n    Deselected = 'deselected',\n\n    /** Navigate to another dashboard */\n    DashboardChanged = 'dashboard-changed',\n  }\n\n  /**\n   * Valid date ranges for a relative date filter.\n   */\n  export enum DateRangeType {\n    Last = 'last',\n    LastN = 'last-n',\n    Next = 'next',\n    NextN = 'next-n',\n    Current = 'current',\n    ToDate = 'to-date',\n  }\n\n  /**\n   * Enum that represents the types of dialog popup styles.\n   */\n  export enum DialogStyle {\n    Window = 'window',\n    Modal = 'modal',\n    Modeless = 'modeless',\n  }\n\n  export enum EncodingType {\n    Column = 'column',\n    Row = 'row',\n    Page = 'page',\n    Filter = 'filter',\n    MarksType = 'marks-type',\n    MeasureValues = 'measure-values',\n    Color = 'color',\n    Size = 'size',\n    Label = 'label',\n    Detail = 'detail',\n    Tooltip = 'tooltip',\n    Shape = 'shape',\n    Path = 'path',\n    Angle = 'angle',\n    Geometry = 'geometry',\n    Custom = 'custom',\n  }\n\n  /**\n   *  Type of aggregation on a field.\n   */\n  export enum FieldAggregationType {\n    Sum = 'sum',\n    Avg = 'avg',\n    Min = 'min',\n    Max = 'max',\n    Stdev = 'stdev',\n    Stdevp = 'stdevp',\n    Var = 'var',\n    Varp = 'varp',\n    Collect = 'collect',\n    Count = 'count',\n    Countd = 'countd',\n    Median = 'median',\n    Attr = 'attr',\n    None = 'none',\n    Year = 'year',\n    Qtr = 'qtr',\n    Month = 'month',\n    Day = 'day',\n    Hour = 'hour',\n    Minute = 'minute',\n    Second = 'second',\n    Week = 'week',\n    Weekday = 'weekday',\n    MonthYear = 'month-year',\n    Mdy = 'mdy',\n    End = 'end',\n    TruncYear = 'trunc-year',\n    TruncQtr = 'trunc-qtr',\n    TruncMonth = 'trunc-month',\n    TruncWeek = 'trunc-week',\n    TruncDay = 'trunc-day',\n    TruncHour = 'trunc-hour',\n    TruncMinute = 'trunc-minute',\n    TruncSecond = 'trunc-second',\n    Quart1 = 'quart1',\n    Quart3 = 'quart3',\n    Skewness = 'skewness',\n    Kurtosis = 'kurtosis',\n    InOut = 'in-out',\n    User = 'user',\n  }\n\n  /**\n   * Role of a field.\n   */\n  export enum FieldRoleType {\n    Dimension = 'dimension',\n    Measure = 'measure',\n    Unknown = 'unknown',\n  }\n\n  /**\n   * An enumeration of the valid types of filters that can be applied.\n   */\n  export enum FilterType {\n    Categorical = 'categorical',\n    Range = 'range',\n    Hierarchical = 'hierarchical',\n    RelativeDate = 'relative-date',\n  }\n\n  /**\n   * The different update types for applying filter\n   */\n  export enum FilterUpdateType {\n    Add = 'add',\n    All = 'all',\n    Replace = 'replace',\n    Remove = 'remove',\n  }\n\n  /**\n   * The domain type for a filter\n   */\n  export enum FilterDomainType {\n    /**\n     * The domain values that are relevant to the specified filter\n     * i.e. the domain is restricted by a previous filter\n     */\n    Relevant = 'relevant',\n    /**\n     * list of all possible domain values from database\n     */\n    Database = 'database',\n  }\n\n  /**\n   * The option for specifying which values to include for filtering\n   * Indicates what to do with null values for a given filter or mark selection call.\n   */\n  export enum FilterNullOption {\n    NullValues = 'null-values',\n    NonNullValues = 'non-null-values',\n    AllValues = 'all-values',\n  }\n\n  /**\n   * Enum that serves as a filter on the DataValues returned from `getSummaryDataReaderAsync`,\n   * `getUnderlyingTableDataReaderAsync` and `getLogicalTableDataReaderAsync`.\n   * This is an optimization of returned data values only. Tableau versions prior to 2021.2\n   * will pass the data across and populate the DataValue properties.\n   * Please note that all properties not requested will be `undefined` in the DataValue results.\n   * @since 1.5.0\n   */\n  export enum IncludeDataValuesOption {\n    /** DataValues will include all properties.*/\n    AllValues = 'all-values',\n\n    /** DataValues will only include value and nativeValue properties.*/\n    OnlyNativeValues = 'only-native-values',\n\n    /** DataValues will only include formattedValue properties. */\n    OnlyFormattedValues = 'only-formatted-values',\n  }\n\n  /**\n   * Type of mark for a given marks card in a viz.\n   */\n  export enum MarkType {\n    Bar = 'bar',\n    Line = 'line',\n    Area = 'area',\n    Square = 'square',\n    Circle = 'circle',\n    Shape = 'shape',\n    Text = 'text',\n    Map = 'map',\n    Pie = 'pie',\n    GanttBar = 'gantt-bar',\n    Polygon = 'polygon',\n    Heatmap = 'heatmap',\n    VizExtension = 'viz-extension',\n  }\n\n  /**\n   * An enumeration describing the different types of allowable values.\n   * This is used for restricting the domain of a parameter\n   */\n  export enum ParameterValueType {\n    All = 'all',\n    List = 'list',\n    Range = 'range',\n  }\n\n  /**\n   * Date period used in filters and in parameters.\n   */\n  export enum PeriodType {\n    Years = 'years',\n    Quarters = 'quarters',\n    Months = 'months',\n    Weeks = 'weeks',\n    Days = 'days',\n    Hours = 'hours',\n    Minutes = 'minutes',\n    Seconds = 'seconds',\n  }\n\n  export enum QuickTableCalcType {\n    RunningTotal = 'running-total',\n    Difference = 'difference',\n    PercentDifference = 'percent-difference',\n    PercentOfTotal = 'percent-of-total',\n    Rank = 'rank',\n    Percentile = 'percentile',\n    MovingAverage = 'moving-average',\n    YTDTotal = 'ytd-total',\n    CompoundGrowthRate = 'compound-growth-rate',\n    YearOverYearGrowth = 'year-over-year-growth',\n    YTDGrowth = 'ytd-growth',\n    Undefined = 'undefined',\n  }\n\n  /**\n   * Enum for specifying the selection type for select marks api.\n   */\n  export enum SelectionUpdateType {\n    Replace = 'select-replace',\n    Add = 'select-add',\n    Remove = 'select-remove',\n  }\n\n  /**\n   * Enum for specifying the select option for the `extensions.Worksheet.selectTuplesAsync` method.\n   */\n  export enum SelectOptions {\n    /**\n     * Clears existing selection before selecting the tuples specified\n     */\n    Simple = 'select-options-simple',\n    /**\n     * Adds specified tuples to the existing selection\n     */\n    Toggle = 'select-options-toggle',\n  }\n\n  /**\n   * The type of sheet a [[Sheet]] object represents\n   */\n  export enum SheetType {\n    Dashboard = 'dashboard',\n    Story = 'story',\n    Worksheet = 'worksheet',\n  }\n\n  export enum SortDirection {\n    Increasing = 'increasing',\n    Decreasing = 'decreasing',\n  }\n\n  export enum TrendLineModelType {\n    Linear = 'linear',\n    Logarithmic = 'logarithmic',\n    Exponential = 'exponential',\n    Polynomial = 'polynomial',\n  }\n\n  /**\n   * Enum that represents the replay speed of an animation.\n   * @since 1.7.0\n   */\n  export enum ReplaySpeedType {\n    /** Used for setting the replay speed of an animation to 0.5x.*/\n    Slow = 'slow',\n\n    /** Used for setting the replay speed of an animation to 1.0x.*/\n    Normal = 'normal',\n\n    /** Used for setting the replay speed of an animation to 2.0x.*/\n    Fast = 'fast',\n  }\n\n  /**\n   * Enum that represents the selection state of a level in a hierarchical filter\n   * @since Extensions 1.10.0\n   */\n  export enum HierarchicalLevelSelectionState {\n    AllSelected = 'all-selected',\n    NoneSelected = 'none-selected',\n    SomeSelected = 'some-selected',\n    UnknownSelected = 'unknown-selected',\n  }\n\n  /**\n   * ZoneVisibilityType\n   * @deprecated use DashboardObjectVisibilityType\n   */\n  export declare type ZoneVisibilityType = DashboardObjectVisibilityType;\n  export const ZoneVisibilityType = { ...DashboardObjectVisibilityType };\n}\nexport = Tableau;\n","// This file re-exports everything which is part of the shared api public interface\n\nexport * from './ExternalContract/Shared/AnnotationInterfaces';\nexport * from './ExternalContract/Shared/DataSourceInterfaces';\nexport * from './ExternalContract/Shared/DataTableInterfaces';\nexport * from './ExternalContract/Shared/Enums';\nexport * from './ExternalContract/Shared/EnvironmentInterfaces';\nexport * from './ExternalContract/Shared/FilterInterfaces';\nexport {\n  AnalyticsObjectType,\n  AnnotationType,\n  ClassNameKey,\n  ColumnType,\n  DashboardLayoutChange,\n  DashboardObjectType,\n  DashboardObjectVisibilityType,\n  DataType,\n  DateRangeType,\n  DialogStyle,\n  EncodingType,\n  FieldAggregationType,\n  FieldRoleType,\n  FilterDomainType,\n  FilterNullOption,\n  FilterType,\n  FilterUpdateType,\n  HierarchicalLevelSelectionState,\n  IncludeDataValuesOption,\n  MarkType,\n  ParameterValueType,\n  PeriodType,\n  QuickTableCalcType,\n  ReplaySpeedType,\n  SelectOptions,\n  SelectionUpdateType,\n  SheetType,\n  SortDirection,\n  TrendLineModelType,\n  ZoneVisibilityType,\n} from './ExternalContract/Shared/Namespaces/Tableau';\nexport * from './ExternalContract/Shared/SelectionInterfaces';\nexport * from './ExternalContract/Shared/SheetInterfaces';\nexport * from './ExternalContract/Shared/VisualModelInterface';\nexport * from './ExternalContract/Shared/WorkbookFormattingInterfaces';\n","/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\n\n// The following polyfills are needed for IE11\nimport 'core-js/es/number/is-integer';\nimport 'core-js/es/number/is-nan';\nimport 'core-js/es/object/assign';\n// Export the version of the internal contract to be available at runtime\n//  This file is generated by yarn publish:bump via scripts/publish-check.ts\n//  updateInternalContractRuntimeVersion in the monorepo root.\nimport * as internalContractVersion from '../internal-contract-version.json';\nexport const INTERNAL_CONTRACT_VERSION = internalContractVersion;\n\nexport * from './contract/DataTypeConverter';\nexport * from './contract/Enums';\nexport * from './contract/Models';\nexport * from './contract/Notifications';\nexport * from './contract/Parameters';\nexport * from './contract/Verbs';\nexport * from './interface/AskDataInterface';\nexport * from './interface/InitializationOptions';\nexport * from './interface/InternalApiDispatcher';\nexport * from './interface/PulseInterface';\nexport * from './interface/VersionNumber';\nexport * from './interface/VqlInterface';\nexport * from './messaging/CrossFrameMessenger';\nexport * from './messaging/interface/MessageDispatcher';\nexport * from './messaging/interface/MessageListener';\nexport * from './messaging/interface/MessageTypes';\nexport * from './messaging/interface/Messenger';\nexport * from './messaging/interface/PreparedMessage';\nexport * from './versioning/InternalContractVersionConverter';\nexport * from './versioning/VersionConverterFactory';\nexport * from './versioning/external/ExternalContractVersionConverter';\nexport * from './versioning/external/ExternalIdentityVersionConverter';\nexport * from './versioning/external/ExternalVersionConverterFactory';\n\n// Export the version number of messaging for consumers to use.\n// Be very careful making any updates to this contract which break version compatibility.\nexport const MESSAGING_VERSION = {\n  major: 1,\n  minor: 0,\n  fix: 0,\n};\n","import { DataType } from './Enums';\n\nexport class DataTypeConverter {\n  private static isSpecial(valueAsString: string): boolean {\n    // Prior to ShowDataTablePresModel, special values come to us as\n    // '%null%', '%all%', '%wildcard%', '%missing%'...\n    // While this function will never return true for ShowDataTablePresModel conversion,\n    // it is as cheap as passing around a version and checking that.\n    // (See DataValueFormatter.cpp)\n\n    if (valueAsString.length > 2 && valueAsString[0] === '%' && valueAsString[valueAsString.length - 1] === '%') {\n      return true;\n    }\n    return false;\n  }\n\n  private static specialValueIndicator = '%null%';\n\n  // tslint:disable-next-line:no-any\n  private static parseBoolean(booleanString: string): boolean | string {\n    // boolean values come to us as 'true'|'false'\n    const normalizedBoolean: string = booleanString.toLowerCase();\n    return normalizedBoolean !== 'true' && normalizedBoolean !== 'false' ? this.specialValueIndicator : normalizedBoolean === 'true';\n  }\n\n  // tslint:disable-next-line:no-any\n  private static parseNumber(valueAsString: string): number | string {\n    const value = Number(valueAsString);\n    return isNaN(value) ? this.specialValueIndicator : value;\n  }\n\n  private static parseDate(dateAsString: string): Date | null {\n    // Note that without a time, the date is assumed to be UTC\n    // Input of 2020-03-25 is printed as: Mar 24 2020 17:00:00 GMT-0700\n    // This matches style used in existing convertFilterValuePresModel\n    const value = new Date(dateAsString);\n    return Number.isNaN(value.getTime()) ? null : value;\n  }\n\n  private static parseDateTime(dateAsString: string): Date | null {\n    // With a time, the date is assumed to be UTC.\n    // Our date format is always: yyyy-mm-dd hh:mm:ss\n    // Unfortunately, IE11 can't parse that format so we add a T between the day and time.\n    // We also add a Z so that it is UTC. (Without the Z, some browsers assume local, and others UTC)\n    const formattedDateString: string = dateAsString.replace(' ', 'T').concat('Z');\n    const value = new Date(formattedDateString);\n    return Number.isNaN(value.getTime()) ? null : value;\n  }\n\n  // It would be nice to merge this and the method FilterConverter::convertFilterValuePresModel in api-platform-js\n  public static convertValueAsStringToValue(valueAsString: string, type: DataType): boolean | number | string | undefined {\n    // This is both DataDictionary and ShowDataTablePresModel compatible.\n    // In the DataDictionary, valueAsString can be '%null%' or '%missing%', while in\n    // ShowDataTablePresModel, we can get 'null' or 'missing', or '%null%' for string special values.\n    // For either of these cases, we return specialValueIndicator (or the original special string).\n    // To maintain backwards compatibilty, this converter:\n    // 1. returns a string for any special values\n    // 2. returns a string for any date\n\n    // Parameter min/max values can be undefined, so result is also undefined\n    if (valueAsString === undefined || valueAsString === null) {\n      return undefined;\n    }\n\n    if (this.isSpecial(valueAsString)) {\n      return valueAsString;\n    }\n\n    switch (type) {\n      case DataType.Bool:\n        return this.parseBoolean(valueAsString);\n\n      case DataType.Int:\n      case DataType.Float:\n        // Return special value '%null%' for any failure in parsing.\n        // We need to do that because ShowDataTablePresModel will give us strings like 'null'\n        // for special values.\n        return this.parseNumber(valueAsString);\n\n      case DataType.Date:\n        // For ShowDataTablePresModel, special values will be \"null\" which will fail to parse.\n        // In that case, we return '%null%'.\n        return this.parseDate(valueAsString) === null ? this.specialValueIndicator : valueAsString;\n\n      case DataType.DateTime:\n        // For ShowDataTablePresModel, special values will be \"null\" which will fail to parse.\n        // In that case, we return '%null%'\n        return this.parseDateTime(valueAsString) === null ? this.specialValueIndicator : valueAsString;\n\n      case DataType.Spatial:\n      case DataType.String:\n      default:\n        return valueAsString;\n    }\n  }\n\n  // tslint:disable-next-line:no-any\n  public static convertValueToNativeValue(value: any, type: DataType): boolean | number | Date | string | null {\n    // This converts from our 1.2 API that returns strings for specials, and dates as strings.\n    // It takes the special case of '%null%' and returns a null.\n    // For dates, it returns a Date object rather than a string.\n    // convertValueToNativeValue should be used to build a DataValue.nativeValue field.\n\n    // Parameter min/max can be undefined. If that is the case, nativeValue is treated like a special\n    if (value === undefined || value === null) {\n      return null;\n    }\n\n    switch (type) {\n      case DataType.Bool:\n        return typeof value === 'string' ? null : value;\n\n      case DataType.Int:\n      case DataType.Float:\n        return typeof value === 'string' ? null : value;\n\n      case DataType.Date:\n        // Convert the string to Date object (or null if parsing fails ... we assume special)\n        return this.parseDate(value);\n\n      case DataType.DateTime:\n        // Convert the string to Date object (or null if parsing fails ... we assume special)\n        return this.parseDateTime(value);\n\n      case DataType.String:\n        return this.isSpecial(value) ? null : value;\n\n      case DataType.Spatial:\n      default:\n        return value;\n    }\n  }\n\n  // tslint:disable-next-line:no-any\n  public static convertStringValueToNativeValue(value: string, type: DataType): boolean | number | Date | string | null {\n    // This handles the conversion from string directly to native value for all types\n    return this.convertValueToNativeValue(this.convertValueAsStringToValue(value, type), type);\n  }\n}\n","export enum ExtensionContext {\n  Desktop = 'desktop',\n  Server = 'server',\n  Unknown = 'unknown',\n}\n\nexport enum ExtensionMode {\n  Authoring = 'authoring',\n  Viewing = 'viewing',\n  Unknown = 'unknown',\n}\n\nexport enum AnnotateEnum {\n  Mark = 'mark',\n  Point = 'point',\n  Area = 'area',\n}\n\nexport enum ColumnType {\n  Discrete = 'discrete',\n  Continuous = 'continuous',\n  Unknown = 'unknown',\n}\n\nexport enum DashboardObjectType {\n  Blank = 'blank',\n  Worksheet = 'worksheet',\n  QuickFilter = 'quick-filter',\n  ParameterControl = 'parameter-control',\n  PageFilter = 'page-filter',\n  Legend = 'legend',\n  Title = 'title',\n  Text = 'text',\n  Image = 'image',\n  WebPage = 'web-page',\n  Extension = 'extension',\n}\n\nexport enum DataType {\n  String = 'string',\n  Int = 'int',\n  Float = 'float',\n  Bool = 'bool',\n  Date = 'date',\n  DateTime = 'date-time',\n  Spatial = 'spatial',\n  Unknown = 'unknown',\n}\n\nexport enum DialogStyle {\n  Window = 'window',\n  Modal = 'modal',\n  Modeless = 'modeless',\n}\n\nexport enum EncodedDataType {\n  Number = 'number',\n  String = 'string',\n  Date = 'date',\n  Boolean = 'boolean',\n}\n\nexport enum ErrorCodes {\n  INITIALIZATION_ERROR = 'initialization-error',\n  INTERNAL_ERROR = 'internal-error',\n  MISSING_ENUM_MAPPING = 'missing-enum-mapping',\n  MISSING_PARAMETER = 'missing-parameter',\n  PERMISSION_DENIED = 'permission-denied',\n  PRES_MODEL_PARSING_ERROR = 'pres-model-parsing-error',\n  VERSION_NOT_CONFIGURED = 'version-not-configured',\n  VISIBILITY_ERROR = 'visibility-error',\n  UNKNOWN_VERB_ID = 'unknown-verb-id',\n}\n\nexport enum FieldAggregationType {\n  Sum = 'sum',\n  Avg = 'avg',\n  Min = 'min',\n  Max = 'max',\n  Stdev = 'stdev',\n  Stdevp = 'stdevp',\n  Var = 'var',\n  Varp = 'varp',\n  Collect = 'collect',\n  Count = 'count',\n  Countd = 'countd',\n  Median = 'median',\n  Attr = 'attr',\n  None = 'none',\n  Year = 'year',\n  Qtr = 'qtr',\n  Month = 'month',\n  Day = 'day',\n  Hour = 'hour',\n  Minute = 'minute',\n  Second = 'second',\n  Week = 'week',\n  Weekday = 'weekday',\n  MonthYear = 'month-year',\n  Mdy = 'mdy',\n  End = 'end',\n  TruncYear = 'trunc-year',\n  TruncQtr = 'trunc-qtr',\n  TruncMonth = 'trunc-month',\n  TruncWeek = 'trunc-week',\n  TruncDay = 'trunc-day',\n  TruncHour = 'trunc-hour',\n  TruncMinute = 'trunc-minute',\n  TruncSecond = 'trunc-second',\n  Quart1 = 'quart1',\n  Quart3 = 'quart3',\n  Skewness = 'skewness',\n  Kurtosis = 'kurtosis',\n  InOut = 'in-out',\n  User = 'user',\n}\n\nexport enum FieldRoleType {\n  Dimension = 'dimension',\n  Measure = 'measure',\n  Unknown = 'unknown',\n}\n\n/**\n *  The different update types for applying filter.\n */\nexport enum FilterUpdateType {\n  Add = 'add',\n  All = 'all',\n  Replace = 'replace',\n  Remove = 'remove',\n}\n\nexport enum SheetType {\n  Dashboard = 'dashboard',\n  Story = 'story',\n  Worksheet = 'worksheet',\n}\n\nexport enum DomainRestrictionType {\n  All = 'all',\n  List = 'list',\n  Range = 'range',\n}\n\nexport enum DateStepPeriod {\n  Years = 'years',\n  Quarters = 'quarters',\n  Months = 'months',\n  Weeks = 'weeks',\n  Days = 'days',\n  Hours = 'hours',\n  Minutes = 'minutes',\n  Seconds = 'seconds',\n}\n\n/**\n * The option for specifying which values to include for filtering.\n */\nexport enum FilterNullOption {\n  NullValues = 'nullvalues',\n  NonNullValues = 'nonnullvalues',\n  AllValues = 'allvalues',\n}\n\n/**\n * The type of filter domain\n */\nexport enum FilterDomainType {\n  Relevant = 'relevant',\n  Database = 'database',\n}\n\n/**\n * Internal enum for specifying the selection type for select marks api.\n */\nexport enum SelectionUpdateType {\n  Replace = 'select-replace',\n  Add = 'select-add',\n  Remove = 'select-remove',\n}\n\n/**\n * Internal enum for specifying the select option for the select tuples api.\n */\nexport enum SelectOptions {\n  Simple = 'select-options-simple',\n  Toggle = 'select-options-toggle',\n  Menu = 'select-options-menu', // not implemented in the external contract\n  Range = 'select-options-range', // not implemented in the external contract\n  Search = 'select-options-search', // not implemented in the external contract\n}\n\n/**\n * Internal enum for specifying the included values type for range selection.\n */\nexport enum QuantitativeIncludedValues {\n  IncludeNull = 'include-null',\n  IncludeNonNull = 'include-non-null',\n  IncludeAll = 'include-all',\n}\n\n/**\n * Internal enum for specifying a hierarchical level selection state.\n */\nexport enum HierarchicalLevelSelectionState {\n  AllSelected = 'all-selected',\n  NoneSelected = 'none-selected',\n  SomeSelected = 'some-selected',\n  UnknownSelected = 'unknown-selected',\n}\n\n/**\n * Type of mark for a given marks card in a viz.\n */\nexport enum MarkType {\n  Bar = 'bar',\n  Line = 'line',\n  Area = 'area',\n  Square = 'square',\n  Circle = 'circle',\n  Shape = 'shape',\n  Text = 'text',\n  Map = 'map',\n  Pie = 'pie',\n  GanttBar = 'gantt-bar',\n  Polygon = 'polygon',\n  Heatmap = 'heatmap',\n  VizExtension = 'viz-extension',\n}\n\n/**\n * Internal enum for specifying the type of filter\n */\nexport enum FilterType {\n  Categorical = 'categorical',\n  Range = 'range',\n  RelativeDate = 'relativeDate',\n  Hierarchical = 'hierarchical',\n}\n\n/**\n * Internal enum for specifying the DateRangeType of a relative date filter\n */\nexport enum DateRangeType {\n  /**\n   * Refers to the last day, week, month, etc. of the date period.\n   */\n  Last = 'last',\n  /**\n   * Refers to the last N days, weeks, months, etc. of the date period.\n   */\n  LastN = 'lastN',\n  /**\n   * Refers to the next day, week, month, etc. of the date period.\n   */\n  Next = 'next',\n  /**\n   * Refers to the next N days, weeks, months, etc. of the date period.\n   */\n  NextN = 'nextN',\n  /**\n   * Refers to the current day, week, month, etc. of the date period.\n   */\n  Current = 'current',\n  /**\n   * Refers to everything up to and including the current day, week, month, etc. of the date period.\n   */\n  ToDate = 'toDate',\n}\n\n/**\n * Used to determine if the launching of an extension dialog succeeded or failed.\n */\nexport enum ExtensionDialogResult {\n  DialogAlreadyOpen = 'dialog-already-open',\n  InvalidDomain = 'invalid-domain',\n  Success = 'success',\n}\n\n// Enumeration for ApiShowData table id sentinels.\nexport enum ApiShowDataTableSentinel {\n  // find the one logical table - used in version compatibility check for getUnderlyingDataTable and getLogicalDataTable commands\n  SingleTableId = 'single-table-id-sentinel',\n  SingleTableCaption = 'Single table id sentinel',\n}\n\n/**\n * Used to optimize the getSummaryData/getUnderlyingTableData results\n * Mapped from external IncludeDataValuesOption\n */\nexport enum ApiShowDataTableFormat {\n  NativeValuesOnly = 'native-values-only',\n  FormattedValuesOnly = 'formatted-values-only',\n  NativeAndFormattedValues = 'native-and-formatted-values',\n}\n\n/**\n * Used to denote the sections of formatting within tableau\n */\nexport const enum ClassNameKey {\n  WorksheetTitle = 'tableau-worksheet-title',\n  Worksheet = 'tableau-worksheet',\n  Tooltip = 'tableau-tooltip',\n  StoryTitle = 'tableau-story-title',\n  DashboardTitle = 'tableau-dashboard-title',\n}\n\n/**\n * Used to set page size for export layout options.\n */\nexport enum PageSizeOption {\n  Letter = 'letter',\n  Legal = 'legal',\n  Note = 'note',\n  Folio = 'folio',\n  Tabloid = 'tabloid',\n  Ledger = 'ledger',\n  Statement = 'statement',\n  Executive = 'executive',\n  A3 = 'a3',\n  A4 = 'a4',\n  A5 = 'a5',\n  B4 = 'b4',\n  B5 = 'b5',\n  Quarto = 'quarto',\n  Unspecified = 'unspecified',\n}\n\n/**\n * Used to set the page orientation mode for export layout options.\n */\nexport enum PageOrientation {\n  Printer = 'printer',\n  Portrait = 'portrait',\n  Landscape = 'landscape',\n}\n\n/**\n * Used to set scale mode for export layout options.\n */\nexport enum ScaleMode {\n  ScaleAuto = 'auto',\n  ScalePercentage = 'percent',\n  ScaleFitPages = 'fit-pages',\n}\n\n/**\n * Used by setFitAndScaleValues to scale percent values\n */\nexport enum PageScalingOption {\n  ScalePctAuto = 'auto',\n  ScalePct400 = 'pct400',\n  ScalePct200 = 'pct200',\n  ScalePct100 = 'pct100',\n  ScalePct90 = 'pct90',\n  ScalePct80 = 'pct80',\n  ScalePct75 = 'pct75',\n  ScalePct60 = 'pct60',\n  ScalePct50 = 'pct50',\n  ScalePct25 = 'pct25',\n}\n\n/**\n * Used by setFitAndScaleValues to scale fit page values\n */\nexport enum FitPages {\n  FitOneHigh = 'fit0x1',\n  FitTwoHigh = 'fit0x2',\n  FitOneWide = 'fit1x0',\n  FitTwoWide = 'fit2x0',\n}\n\n/**\n * Used by getVisualSpecificationAsync\n */\nexport enum EncodingType {\n  Color = 'color',\n  Size = 'size',\n  Label = 'label',\n  Detail = 'detail',\n  Tooltip = 'tooltip',\n  Shape = 'shape',\n  Path = 'path',\n  Angle = 'angle',\n  Geometry = 'geometry',\n  Custom = 'custom',\n}\n","export enum NotificationId {\n  CustomMarkContextMenuClicked = 'custom-mark-context-menu-clicked',\n  ContextMenuClick = 'context-menu-click',\n  CustomViewRemoved = 'custom-view-removed',\n  CustomViewSaved = 'custom-view-saved',\n  CustomViewSetDefault = 'custom-view-set-default',\n  CustomViewsLoaded = 'custom-views-loaded',\n  DashboardLayoutChanged = 'dashboard-layout-changed',\n  EditButtonClicked = 'edit-button-clicked',\n  EditInDesktopButtonClicked = 'edit-in-desktop-button-clicked',\n  ExtensionDialogUpdate = 'extension-dialog-update',\n  FilterChanged = 'filter-changed',\n  FirstVizSizeKnown = 'first-viz-size-known',\n  ParameterChanged = 'parameter-changed',\n  SelectedMarksChanged = 'selected-marks-changed',\n  SettingsChanged = 'settings-changed',\n  SummaryDataChanged = 'summary-data-changed',\n  TestConversionNotification = 'test-conversion-notification',\n  ToolbarStateChanged = 'toolbar-state-changed',\n  VizInteractive = 'viz-interactive',\n  AskDataInteractive = 'ask-data-interactive',\n  WorkbookReadyToClose = 'workbook-ready-to-close',\n  WorkbookFormattingChanged = 'workbook-formatting-changed',\n  WorkbookPublished = 'workbook-published',\n  WorkbookPublishedAs = 'workbook-published-as',\n  UrlAction = 'url-action',\n  TabSwitched = 'tab-switched',\n  StoryPointSwitched = 'story-point-switched',\n  ReadyToReceiveAuthToken = 'ready-to-receive-auth-token',\n}\n","// PLEASE KEEP IN ALPHABETICAL ORDER. This helps with visually finding entries, knowing where to put\n// new ones, and merge conflicts.\nexport enum ParameterId {\n  ActiveTablesInfo = 'active-tables-info',\n  AnchorDate = 'anchor-date',\n  AnnotateEnum = 'annotate-enum',\n  AnnotationList = 'annotation-list',\n\n  CategoricalDomain = 'categorical-domain',\n  ClickThroughEnabled = 'click-through-enabled',\n  ColumnsToInclude = 'columns-to-include',\n  ColumnsToIncludeById = 'columns-to-include-by-id',\n  ConnectionDescriptionSummaries = 'connection-description-summaries',\n  CurrentSheetType = 'current-sheet-type',\n  CustomView = 'custom-view',\n  CustomViewIsDefault = 'custom-view-is-default',\n  CustomViewIsPublic = 'custom-view-is-public',\n  CustomViewLuid = 'custom-view-luid',\n  CustomViewName = 'custom-view-name',\n  CustomViews = 'custom-views',\n\n  Dashboard = 'dashboard',\n  DashboardFilters = 'dashboard-filters',\n  DashboardName = 'dashboard',\n  DashboardObjectPositionAndSizeUpdate = 'dashboard-object-position-and-size-update',\n  DashboardObjectPositionAndSizeUpdateList = 'dashboard-object-position-and-size-update-list',\n  DataRowIndex = 'data-row-index',\n  DataSchema = 'data-schema',\n  DataSource = 'data-source',\n  DataSourceDataTable = 'data-source-data-table',\n  DataSourceId = 'data-source-id',\n  DataSourceName = 'data-source-name',\n  DataTable = 'data-table',\n  DataTableReader = 'data-table-reader',\n  DateRangeType = 'date-range-type',\n  DeltaTimeMs = 'delta-time-ms',\n  DimValSelectionModels = 'dimensionValueSelectionModels',\n  DomainType = 'domain-type',\n\n  EmbeddingAbstractQuery = 'embedding-abstract-query',\n  EmbeddingBootstrapInfo = 'embedding-bootstrap-info',\n  ExportCrosstabSheetMap = 'export-crosstab-sheet-map',\n  ExportFile = 'export-file',\n  ExportOriginUrl = 'export-origin-url',\n  ExportPdfOptions = 'export-pdf-options',\n  ExtensionBootstrapInfo = 'extension-bootstrap-info',\n  ExtensionContextMenuIds = 'extension-context-menu-ids',\n  ExtensionDialogH = 'extension-dialog-height',\n  ExtensionDialogPayload = 'extension-dialog-payload',\n  ExtensionDialogResult = 'extension-dialog-result',\n  ExtensionDialogStyle = 'extension-dialog-style',\n  ExtensionDialogUrl = 'extension-dialog-url',\n  ExtensionDialogW = 'extension-dialog-width',\n  ExtensionLocator = 'extension-locator',\n  ExtensionSettingsInfo = 'extension-settings-info',\n  ExtensionZoneId = 'extension-zone-id',\n  ExternalMenuDescription = 'external-menu-description',\n  ExternalMenuHeader = 'external-menu-header',\n  ExternalMenuItemDisplayName = 'external-menu-item-display-name',\n  ExternalMenuItemId = 'external-menu-item-id',\n\n  Field = 'field',\n  FieldId = 'field-id',\n  FieldName = 'field-name',\n  FilterLevels = 'filter-levels',\n  FilterRangeMax = 'filter-range-max',\n  FilterRangeMin = 'filter-range-min',\n  FilterRangeNullOption = 'filter-range-null-option',\n  FilterUpdateType = 'filter-update-type',\n  FilterValues = 'filter-values',\n  FontNameListItems = 'font-name-list-items',\n  FormattedText = 'formatted-text',\n  FunctionName = 'function-name',\n\n  HierValSelectionModels = 'hierarchicalValueSelectionModels',\n  HighlightedData = 'highlighted-data',\n  HoverTupleInteraction = 'hover-tuple-interaction',\n\n  IgnoreAliases = 'ignore-aliases',\n  IgnoreSelection = 'ignore-selection',\n  IncludeAllColumns = 'include-all-columns',\n  InvalidAggFieldName = 'invalid-agg-field-name',\n  InvalidDates = 'invalid-dates',\n  InvalidFieldCaption = 'invalid-field-caption',\n  InvalidFields = 'invalid-fields',\n  InvalidValues = 'invalid-values',\n  IsExcludeMode = 'is-exclude',\n  IsExtensionDialog = 'is-extension-dialog',\n\n  JoinDescription = 'join-description',\n\n  LogicalTableId = 'logical-table-id',\n  LogicalTableInfoList = 'logical-table-info-list',\n\n  MaxHeight = 'max-height',\n  MaxRows = 'max-rows',\n  MaxWidth = 'max-width',\n  MinHeight = 'min-height',\n  MinWidth = 'min-width',\n\n  PageRowCount = 'page-row-count',\n  ParameterCaption = 'paremeter-caption',\n  ParameterError = 'parameter-error',\n  ParameterFieldName = 'parameter-field-name',\n  ParameterInfo = 'parameter-info',\n  ParameterInfos = 'parameter-infos',\n  ParameterValue = 'parameter-value',\n  PeriodType = 'period-type',\n\n  QuantitativeDomain = 'quantitative-dmain',\n  QuantRangeSelectionModels = 'quantativeRangeSelectionModels',\n\n  RangeN = 'range-n',\n  ReplaySpeed = 'replay-speed',\n\n  SelectedData = 'selected-data',\n  SelectedSheetNames = 'selected-sheet-names',\n  Selection = 'selection',\n  SelectionList = 'selection-list',\n  SelectionUpdateType = 'selectionUpdateType',\n  SelectTuplesInteraction = 'select-tuples-interaction',\n  SendNotifications = 'send-notifications',\n  SettingsValues = 'settings-values',\n  SharedFilterSheets = 'shared-filter-sheets',\n  SharedFiltersInfo = 'shared-filters-info',\n  SheetIdentifier = 'sheet-identifier',\n  SheetName = 'sheet-name',\n  SheetPath = 'sheet-path',\n  ShouldRefreshDS = 'should-refresh-ds',\n  ShowDataTableFormat = 'show-data-table-format',\n  State = 'state',\n  StoryPointIndex = 'story-point-index',\n  StoryPointInfo = 'story-point-info',\n  SwitchToSheetName = 'switch-to-sheet-name',\n\n  TargetPoint = 'target-point',\n  TestConversionParameter = 'test-conversion-parameter',\n  Text = 'formatted-text',\n  TooltipContext = 'tooltip-context',\n  TooltipTextRequest = 'tooltip-text-request',\n  TooltipText = 'tooltip-text',\n\n  UnderlyingDataTable = 'underlying-data-table',\n  UnderlyingSummaryDataTable = 'underlying-summary-data-table',\n  Url = 'url',\n  UseTabDelimiters = 'use-tab-delimiters',\n\n  ViewDataTableCacheId = 'view-data-table-cache-id',\n  ViewDataTableId = 'view-data-table-id',\n  VisualId = 'visual-id',\n  VisualSpecification = 'visual-specification',\n  VizAPIInputJson = 'vizapi-input-json',\n  VizAPIStateWithDataModel = 'vizapi-state-with-data-model',\n  VizAPIStateWarningMsg = 'vizapi-state-warning-msg',\n  VizAPISVG = 'vizapi-svg',\n\n  WorksheetName = 'worksheet-name',\n  WorksheetFilters = 'worksheet-filters',\n\n  ZoneIdsVisibilityMap = 'zone-ids-visibility-map',\n}\n","// Declare this key type and export the NotificationId to make this behave like a string enum.\n//\n// PLEASE KEEP IN ALPHABETICAL ORDER. This helps with visually finding entries, knowing where to put\n// new ones, and merge conflicts.\nexport enum VerbId {\n  ActivateNextStoryPoint = 'activate-next-story-point',\n  ActivatePreviousStoryPoint = 'activate-previous-story-point',\n  ActivateSheet = 'activateSheet',\n  ActivateStoryPoint = 'activate-story-point',\n  AppendExternalMenuItem = 'append-external-menu-item',\n  ApplyCategoricalFilter = 'categorical-filter',\n  ApplyRangeFilter = 'range-filter',\n  ApplyRelativeDateFilter = 'apply-relative-date-Filter',\n  Authenticate = 'authenticate',\n\n  BlockExtension = 'block-extension',\n\n  ChangeParameterValue = 'change-parameter-value',\n  ChangeSharedFilter = 'change-shared-filter',\n  ClearFilter = 'clear-filter',\n  ClearSelectedMarks = 'clear-selected-marks',\n  CloseDialog = 'close-dialog',\n  CreateAnnotation = 'create-annotation',\n\n  DashboardCategoricalFilter = 'dashboard-categorical-filter',\n  DisplayDialog = 'display-dialog',\n  DownloadWorkbook = 'download-workbook',\n\n  ExecuteExternalMenuItem = 'execute-external-menu-item',\n  ExportCrosstab = 'export-crosstab',\n  ExportCrosstabCsvDownload = 'export-crosstab-csv-download',\n  ExportCrosstabExcelDownload = 'export-crosstab-excel-download',\n  ExportData = 'export-data',\n  ExportDataDownload = 'export-data-download',\n  ExportImage = 'export-image',\n  ExportPdf = 'export-pdf',\n  ExportPdfDownload = 'export-pdf-download',\n  ExportPowerpoint = 'export-powerpoint',\n  ExportPowerpointDownload = 'export-powerpoint-download',\n\n  FindParameter = 'find-parameter',\n\n  GetActiveTables = 'get-active-tables',\n  GetAllDataSources = 'get-all-data-sources',\n  GetAnnotations = 'get-annotations',\n  GetCategoricalDomain = 'get-categorical-domain',\n  GetConnectionDescriptionSummaries = 'get-connection-description-summaries',\n  GetCurrentSrc = 'get-current-src',\n  GetCustomViews = 'get-custom-views',\n  GetDashboardFilters = 'get-dashboard-filters',\n  GetDataSource = 'get-datasource',\n  GetDataSourceData = 'get-datasource-data',\n  GetDataSources = 'get-data-sources',\n  GetDataSummaryData = 'get-summary-data',\n  GetDataSummaryDataReader = 'get-summary-data-reader',\n  GetDataTableReaderPage = 'get-data-table-reader-page',\n  GetEmbeddingAbstractQueryWithDataModel = 'get-embedding-abstract-query-with-data-model',\n  GetEmbeddingClientInfo = 'get-embedding-client-info',\n  GetVizStateWithDataModel = 'get-viz-state-with-data-model',\n  GetExportCrosstabSheetMap = 'get-export-crosstab-sheet-map',\n  GetExportPdfOptions = 'get-export-pdf-options',\n  GetField = 'get-field',\n  GetFieldAndDataSource = 'get-field-and-datasource',\n  GetVisualSpecification = 'get-visual-specification',\n  GetFilters = 'get-filters',\n  GetFonts = 'get-fonts',\n  GetHighlightedMarks = 'get-highlighted-marks',\n  GetJoinDescription = 'get-join-description',\n  GetLogicalTableData = 'get-logical-table-data',\n  GetLogicalTableDataReader = 'get-logical-table-data-reader',\n  GetLogicalTables = 'get-logical-tables',\n  GetParametersForSheet = 'get-parameters-for-sheet',\n  GetRangeDomain = 'get-range-domain',\n  GetSelectedMarks = 'get-selected-marks',\n  GetSharedFilter = 'get-shared-filter',\n  GetTooltipText = 'get-tooltip-text',\n  GetUnderlyingData = 'get-underlying-data',\n  GetUnderlyingTableData = 'get-underlying-table-data',\n  GetUnderlyingTableDataReader = 'get-underlying-table-data-reader',\n  GetUnderlyingTables = 'get-underlying-tables',\n\n  HierarchicalFilter = 'hierachical-filter',\n\n  InitializeExtension = 'initialize-extension',\n\n  MoveAndResizeZones = 'move-and-resize-zones',\n\n  RaiseLeaveMarkNavNotification = 'raise-leave-mark-nav-notification',\n  RaiseHoverTupleNotification = 'raise-hover-tuple-notification',\n  RaiseSelectTuplesNotification = 'raise-select-tuples-notification',\n  Redo = 'redo',\n  RefreshDataSource = 'refresh-data-source',\n  ReleaseDataTableReader = 'release-data-table-reader',\n  RemoveAnnotation = 'remove-annotation',\n  RemoveCustomView = 'remove-custom-view',\n  RemoveExternalMenuItem = 'remove-external-menu-item',\n  RenameExternalMenu = 'rename-external-menu',\n  ReplayAnimation = 'replay-animation',\n  RevertStoryPoint = 'revert-story-point',\n  RevertWorkbook = 'revert-workbook',\n\n  SaveExtensionSettings = 'save-extension-settings',\n  SaveWorkbookAsCustomView = 'save-workbook-as-custom-view',\n  SelectByValue = 'select-by-value',\n  SetActiveCustomViewAsDefault = 'set-active-custom-view-as-default',\n  SetAutoUpdate = 'set-auto-update',\n  SetClickThrough = 'set-click-through',\n  SetVizStateWithDataModel = 'set-viz-state-with-data-model',\n  SetSheetSize = 'set-sheet-size',\n  SetZoneVisibility = 'set-zone-visibility',\n  Share = 'share',\n  ShowCustomView = 'show-custom-view',\n\n  TestConversionVerb = 'test-conversion-verb',\n\n  Undo = 'undo',\n  UpdateCustomView = 'update-custom-view',\n\n  VizAPI = 'viz-api',\n}\n","export enum AskDataOptionNames {\n  token = 'token',\n  origin = 'origin',\n  showEmbed = 'showEmbed',\n  showPin = 'showPin',\n  showSave = 'showSave',\n  showShare = 'showShare',\n  debug = ':jsdebug',\n  ApiID = ':apiID',\n  ApiExternalVersion = ':apiExternalVersion',\n  ApiInternalVersion = ':apiInternalVersion',\n  AskDataWebComponent = ':askDataWebComponent',\n}\n","export enum PulseOptionNames {\n  embed = 'embed',\n  token = 'token',\n  disableExploreFilter = 'disableExploreFilter',\n  layout = 'embed_layout',\n  ApiExternalVersion = ':apiExternalVersion',\n  ApiInternalVersion = ':apiInternalVersion',\n  PulseWebComponent = ':pulseWebComponent',\n}\n","/**\n * These strings were *manually copied* from the server,\n * workgroup/src/silos/tableau-server/libraries/tab-controller-vizql/src/com/tableausoftware/\n * controller/vizql/constants/ParameterKeys.java#L9\n * should be exported instead\n * parameters that vizql will accept in an embedding URL\n **/\nenum VqlParameterNames {\n  ONE = '1',\n  ALERTS = ':alerts',\n  ALIAS = 'alias',\n  ALLOW_DEFERRED_BOOTSTRAP = ':allowDeferredBootstrap',\n  ALLOW_AUTOGEN_WORKSHEET_PHONE_LAYOUTS = 'allowAutogenWorksheetPhoneLayouts',\n  API_ID = ':apiID',\n  APP = ':app',\n  ATTACHMENT = 'attachment',\n  IS_IPAD_APP = 'app',\n  ANIMATE_TRANSITION = ':animate_transition',\n  ASCENDING = 'ascending',\n  AUTHENTICATION = 'authentication',\n  ATTRIBUTES = 'attributes',\n  AUTHORING_SHEET = ':authSheet',\n  AXIS = 'axis',\n  BOOTSTRAP_WHEN_NOTIFIED = ':bootstrapWhenNotified',\n  BROWSER_BACK_BUTTON_UNDO = ':browserBackButtonUndo',\n  BROWSER_RENDERING_ON = 'isBrowserRendering',\n  BROWSER_RENDERING_THRESHOLD = 'browserRenderingThreshold',\n  CHARSET = 'charset',\n  CLIENT_DIMENSION = 'clientDimension',\n  CLIENT_IP = 'client_ip',\n  CLIENT_NUM = 'clientNum',\n  COLON_EMBEDDED = ':embedded',\n  COLON_MOBILE = ':mobile',\n  COLON_DEEP_LINKING_DISABLED = ':deepLinkingDisabled',\n  COLON_WATERMARK = ':watermark',\n  COMMENTS = ':comments',\n  COMMENTING_ENABLED = ':commentingEnabled',\n  COMMENTING_MENTIONS_ENABLED = ':commentingMentions',\n  CONNECTION = 'connection',\n  CREATED_BY_FEATURE = 'createdByFeature',\n  CRYPTED_PASSWORD = 'crypted',\n  CSSDEBUG = ':cssdebug',\n  CSV = 'csv',\n  CUSTOM_VIEWS = ':customViews',\n  CV = ':cv',\n  CV_ID = 'cvId',\n  DASHBOARD_PORT_SIZE = 'dashboardPortSize',\n  DATA_DETAILS = ':dataDetails',\n  DATASOURCE = 'datasource',\n  DEBUG = ':debug',\n  DELAY = ':delay',\n  DEPTH = 'depth',\n  DEVICE_TYPE = ':device',\n  DEVICE_PIXEL_RATIO = 'devicePixelRatio',\n  DEVICE_PREVIEW_MODE = ':devicepreviewmode',\n  DIMENSIONS = ':dimensions',\n  DISABLE_SHARED_SESSIONS = ':disable_shared_sessions',\n  DISABLE_URL_ACTIONS_POPUPS = ':disableUrlActionsPopups',\n  DIRECTION = 'direction',\n  DISPLAY_OVERLAY = ':display_overlay',\n  DISPLAY_SHARE = ':display_share',\n  DISPLAY_SPINNER = ':display_spinner',\n  DISPLAY_STATIC_IMAGE = ':display_static_image',\n  DISPLAY_TABS = 'display_tabs',\n  DISPLAY_VIEW_COUNT = ':display_count',\n  IGNORE_STICKY_SESSION = ':ignore_sticky_session',\n  INCREMENT_VIEW_COUNT = ':increment_view_count',\n  DOCMODE = 'docmode',\n  DOMAIN = 'domain',\n  DO_WORK = 'do_work',\n  DX = 'dx',\n  DY = 'dy',\n  EDIT_DATA_ALERT = ':editDataAlert',\n  EMBED = ':embed',\n  EMBEDDED = 'embedded',\n  ENCRYPTED = 'encrypted',\n  API_EXTERNAL_VERSION = ':apiExternalVersion',\n  API_INTERNAL_VERSION = ':apiInternalVersion',\n  EXCLUDE = 'exclude',\n  EXPORT_FORMAT = ':export_format',\n  FIELDNAME = 'fieldname',\n  FIELD_NAME = 'field_name',\n  FIELD_SEP = 'field_sep',\n  FILE = 'file',\n  FILTER_TILE_SIZE = 'filterTileSize',\n  FN = 'fn',\n  FOCUS = 'focus',\n  FORCE_CACHE = 'force_cache',\n  FORMAT = 'format',\n  FORMAT_DATA_VALUE_LOCALLY = 'formatDataValueLocally',\n  FROM_WG = ':from_wg',\n  GRAPHQL_DATABASE_ID = ':graphQLDatabaseId',\n  GRAPHQL_TABLE_ID = ':graphQLTableId',\n  GUID = ':guid',\n  H = 'h',\n  HIDDEN = 'hidden',\n  HIDE_CLOSE_BUTTON = ':hideCloseButton',\n  HIDE_EDIT_BUTTON = ':hideEditButton',\n  HIDE_EDIT_IN_DESKTOP_BUTTON = ':hideEditInDesktopButton',\n  HIGH_DPI = ':highdpi',\n  IMAGE_SIZE_LIMIT = 'imageSizeLimit',\n  TRANSPARENT_LINE_MARKS_LIMIT = 'transparentLineMarkLimit',\n  CLIENT_RENDER_PIXEL_LIMIT = 'clientRenderPixelLimit',\n  IN = 'in',\n  INSTANCE_ID = ':iid',\n  IS_GUEST_REDIRECT_FROM_VIZPORTAL = ':isGuestRedirectFromVizportal',\n  IS_MARK_ANIMATION_ENABLED = 'isMarkAnimationEnabled',\n  IS_VIZPORTAL = ':isVizPortal',\n  INPUT_ = 'input_string',\n  JSDEBUG = ':jsdebug',\n  JSON = 'json',\n  JSON_ONLY = ':jsonOnly',\n  KEEPFILE = 'keepfile',\n  KEY = 'key',\n  LANGUAGE = 'language',\n  LANGUAGE_REQUESTED = ':language',\n  LINKTARGET = ':linktarget',\n  LOAD_ORDER_ID = ':loadOrderID', // used for Public\n  LOAD_NEWEST_REVISION = ':loadNewestRevision',\n  LOCAL_PATHS = ':localPaths',\n  LOCALE = 'locale',\n  LOCATION_ID = 'locationid',\n  LOCATION_TYPE = 'locationtype',\n  WORKBOOK_LOCALE = 'workbookLocale',\n  MAXROWS = 'maxrows',\n  MAX_AGE = 'maxAge',\n  MAX_ROWS = 'maxRows',\n  METHOD = 'method',\n  MOBILE = 'mobile',\n  MODIFIER = 'modifier',\n  NAME = 'name',\n  NAV_TYPE = 'navType',\n  NAV_SRC = 'navSrc',\n  NOATTACHMENT = 'no-attachment',\n  NO_OVERWRITE = 'no_overwrite',\n  OPEN_AUTHORING_IN_TOP_WINDOW = ':openAuthoringInTopWindow',\n  OPENID_HD = ':openid_hd',\n  OPENID_LOGIN_HINT = ':openid_login_hint',\n  OAUTHREQUEST = 'oauthrequest',\n  OAUTH_CREDENTIAL_IDS = 'oauth_credential_ids',\n  OFFLINE_MODE = ':offlinemode',\n  ORIGIN = ':origin',\n  OVERLAY = ':overlay',\n  P = 'p',\n  PATH = 'path',\n  PANE_RESOLVER_X = 'paneResolverX',\n  PANE_RESOLVER_Y = 'paneResolverY',\n  PARAM = 'param',\n  PARENT_ID = 'parent_id',\n  PASSWORD = 'password',\n  PATTERN = 'pattern',\n  PIXEL_RATIO = ':pixelratio',\n  PREFIX = ':prefix',\n  PREVIEW = ':preview',\n  PRIMARY_CONTENT_URL = 'primary_content_url',\n  PROJECT = 'project',\n  PROTOCOL = 'protocol',\n  PSEUDO = ':pseudo',\n  QUERY = 'query',\n  R = 'r',\n  RANGE_TYPE = 'range_type',\n  RECORD_SEP = 'record_sep',\n  RECORD_CLIENT_PERFORMANCE = ':record_client_performance',\n  RECORD_PERFORMANCE = ':record_performance',\n  RECOVER_OLD_SESSION_ID = ':recover_old_session_id',\n  RECOVER_SESSION_STATE_TICKETS = ':recover_session_state_tickets',\n  REFRESH = ':refresh',\n  REFRESHUNMODIFIED = ':refreshunmodified',\n  REGION = 'region',\n  RELOAD_ON_CUSTOM_VIEW_SAVE = ':reloadOnCustomViewSave',\n  RENDER = ':render',\n  RENDER_MAPS_CLIENT_SIDE = 'renderMapsClientSide',\n  RETRY = ':retry',\n  REUSE = 'reuse',\n  REUSE_FOREVER = 'reuse_forever',\n  REVERT = ':revert',\n  SAVE_DB_PASSWORDS = 'save_db_passwords',\n  SELECT_X = 'select_x',\n  SELECT_Y = 'select_y',\n  SESSION_FEATURE_PREFIX = ':ff_',\n  SESSION_FLAGS = ':session_feature_flags',\n  SHARE_BUTTON = 'share_button',\n  SHEET_ID = 'sheet_id',\n  SHARED = 'shared',\n  SHOWALL = 'showall',\n  SHOW_APP_BANNER = ':showAppBanner',\n  SHOW_ASK_DATA = ':showAskData',\n  SHOW_PARAMS = 'showParams',\n  SHOW_SHARE_OPTIONS = ':showShareOptions',\n  SIZE = ':size',\n  SOURCE = 'source',\n  STATE = 'state',\n  STICKY_SESSION_KEY = 'stickySessionKey',\n  SUBSCRIPTIONS = ':subscriptions',\n  SUMMARY = 'summary',\n  SUPPRESS_DEFAULT_EDIT_BEHAVIOR = ':suppressDefaultEditBehavior',\n  SYNC_SESSION = ':sync_session',\n  SYNC_SESSION_STATE = 'sync_session_state',\n  TABS = ':tabs',\n  TARGET = 'target',\n  TARGET_SITE = 'target_site',\n  TOOLBAR = ':toolbar',\n  TOOLTIP = ':tooltip',\n  TS = 'ts',\n  UNDERLYING_TABLE_ID = 'underlying_table_id',\n  UNDERLYING_TABLE_CAPTION = 'underlying_table_caption',\n  UPDATE_TYPE = 'update_type',\n  USE_GUEST = ':useGuest',\n  USE_INLINE_IMAGES = 'use_inline_images',\n  USERAGENT = 'useragent',\n  USERNAME = 'username',\n  VALUE = 'value',\n  VERBOSE_MODE = 'verboseMode',\n  VIEW_ID = 'views_id',\n  VIZ_SNAPSHOT_ID = 'viz_snapshot_id',\n  VW = ':vw',\n  W = 'w',\n  WORKSHEET_PORT_SIZE = 'worksheetPortSize',\n  WATERMARK = 'watermark',\n  WATERMARK_MARGIN = ':watermark_margin',\n  WB = ':wb',\n  WHICH = 'which',\n  X = 'x',\n  Y = 'y',\n  ZID = 'zid',\n  ZONE_ID = 'zone_id',\n  KEYCHAIN_VERSION = 'keychain_version',\n  DATASOURCE_ID = 'datasource_id',\n  DATASOURCE_NAME = 'datasource_name',\n  LENS_ID = 'lens_id',\n  WIDTH = 'width',\n  HEIGHT = 'height',\n\n  // Default Layout params\n  LAYOUT_VIEWS = 'views',\n  LAYOUT_MENUS = 'menus',\n  LAYOUT_GEOMETRY = 'geometry',\n  LAYOUT_PAGES = 'pages',\n  LAYOUT_CACHEURL = 'cacheurl',\n  LAYOUT_SHEET = 'sheet',\n  LAYOUT_DEPTH = 'depth',\n}\n\n/**\n * parameters that are only relevant when working with Tableau Public\n * maybe not really necessry to split them out\n */\nenum PublicParameterNames {\n  SHOW_VIZ_HOME = ':showVizHome',\n  // display view count\n}\n\n/**\n * Map the parameter names as used in the url to what we call them publicly in the embedding library.\n * The only parameters listed here should be the ones that get sent to vizql\n *  - this should match the interface at external-contract:VizInterfaces:VizSettings\n */\nexport enum VizOptionNames {\n  // publicName = internalStringValue\n  Size = VqlParameterNames.SIZE,\n  Embed = VqlParameterNames.EMBED,\n  ApiInternalVersion = VqlParameterNames.API_INTERNAL_VERSION,\n  ApiExternalVersion = VqlParameterNames.API_EXTERNAL_VERSION,\n  ShowVizHome = PublicParameterNames.SHOW_VIZ_HOME,\n  Jsdebug = VqlParameterNames.JSDEBUG,\n  BootstrapWhenNotified = VqlParameterNames.BOOTSTRAP_WHEN_NOTIFIED,\n  NavType = VqlParameterNames.NAV_TYPE,\n  NavSrc = VqlParameterNames.NAV_SRC,\n  debug = VqlParameterNames.JSDEBUG,\n  ApiID = VqlParameterNames.API_ID,\n\n  disableUrlActionsPopups = VqlParameterNames.DISABLE_URL_ACTIONS_POPUPS,\n  hideTabs = VqlParameterNames.TABS,\n  toolbar = VqlParameterNames.TOOLBAR,\n  device = VqlParameterNames.DEVICE_TYPE,\n  instanceIdToClone = VqlParameterNames.INSTANCE_ID,\n  touchOptimize = VqlParameterNames.MOBILE,\n  hideEditButton = VqlParameterNames.HIDE_EDIT_BUTTON,\n  hideEditInDesktopButton = VqlParameterNames.HIDE_EDIT_IN_DESKTOP_BUTTON,\n  suppressDefaultEditBehavior = VqlParameterNames.SUPPRESS_DEFAULT_EDIT_BEHAVIOR,\n  hideCloseButton = VqlParameterNames.HIDE_CLOSE_BUTTON,\n}\n","import * as guid from 'guid';\nimport { ExecuteParameters, INTERNAL_CONTRACT_VERSION, Model, NotificationId, VerbId, VersionNumber } from '../JsApiInternalContract';\nimport { InitializationOptions } from '../interface/InitializationOptions';\nimport { CrossFramePreparedMessage } from './CrossFramePreparedMessage';\nimport {\n  isCommandMessage,\n  isCommandResponseMessage,\n  isHandshakeMessage,\n  isInitMessage,\n  isMessage,\n  isNotificationMessage,\n} from './MessageTypeChecks';\nimport {\n  CommandMessageHandler,\n  CommandResponseMessageHandler,\n  HandshakeMessageHandler,\n  InitializeMessageHandler,\n  NotificationMessageHandler,\n} from './interface/MessageListener';\nimport {\n  CommandMessage,\n  CommandResponseMessage,\n  HandshakeMessage,\n  InitializeMessage,\n  Message,\n  MessageType,\n  NotificationMessage,\n} from './interface/MessageTypes';\nimport { Messenger } from './interface/Messenger';\nimport { PreparedMessage } from './interface/PreparedMessage';\n\n/**\n * The CrossFrameMessenger is the primary export from the api-messaging module. An instance of\n * this class can be instantiated on both sides of a frame boundary to facilitate communication\n * in both directions between the frames. This class implements both the dispatcher and the listener\n * portions, but doesn't require callers to care about both.\n */\nexport class CrossFrameMessenger implements Messenger {\n  private unregisterFunction?: () => void;\n  private initializeMessageHandler?: InitializeMessageHandler;\n  private commandResponseMessageHandler?: CommandResponseMessageHandler;\n  private commandMessageHandler?: CommandMessageHandler;\n  private notificationMessageHandler?: NotificationMessageHandler;\n  private handshakeMessageHandler?: HandshakeMessageHandler;\n\n  /**\n   * Creates an instance of CrossFrameMessenger. If you would like to use the CrossFrameMessenger as a MessageListener,\n   * be sure to call StartListening and register message handlers.\n   * @param thisWindow The window object which the CrossFrameMessenger lives. An onMessage listener will be added here.\n   * @param [otherWindow] Optional otherWindow which messages will be posted to.\n   *                      If defined, incoming messages must originate from otherWindow to be passed on\n   * @param [otherWindowOrigin] The target origin which otherWindow must have in order to receive dispatched messages.\n   *                            This value will be sent as the targetOrigin of a postMessage\n   *                            (https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage)\n   */\n  public constructor(private thisWindow: Window, private otherWindow?: Window, private otherWindowOrigin?: string) {\n    // Make sure to call StartListening\n  }\n\n  ///// MessageListener Implementation\n\n  public startListening(): void {\n    // Check if we already are listening, if not, hook up a message listener\n    if (!this.unregisterFunction) {\n      const boundHandler = this.onMessageReceived.bind(this);\n      this.thisWindow.addEventListener('message', boundHandler, true);\n      this.unregisterFunction = () => this.thisWindow.removeEventListener('message', boundHandler, true);\n    }\n  }\n\n  public stopListening(): void {\n    // Stop listening if we have started listening\n    if (this.unregisterFunction) {\n      this.unregisterFunction();\n      this.unregisterFunction = undefined;\n    }\n  }\n\n  public setInitializeMessageHandler(handler?: InitializeMessageHandler): void {\n    this.initializeMessageHandler = handler;\n  }\n\n  public setCommandResponseMessageHandler(handler?: CommandResponseMessageHandler): void {\n    this.commandResponseMessageHandler = handler;\n  }\n\n  public setCommandMessageHandler(handler?: CommandMessageHandler): void {\n    this.commandMessageHandler = handler;\n  }\n\n  public setNotificationMessageHandler(handler?: NotificationMessageHandler): void {\n    this.notificationMessageHandler = handler;\n  }\n\n  public setHandshakeMessageHandler(handler?: HandshakeMessageHandler): void {\n    this.handshakeMessageHandler = handler;\n  }\n\n  ///// MessageDispatcher Implementation\n\n  /**\n   * @param apiVersion api-internal-contract-js version (exported in JsApiInternalConntract)\n   * @param crossFrameVersion crossframe messaging version (exported in JsApiInternalConntract)\n   * @param options additional options that can be passed at initialization (information about the version of\n   *                external being used for example)\n   */\n  public prepareInitializationMessage(\n    apiVersion: VersionNumber,\n    crossFrameVersion: VersionNumber,\n    options?: InitializationOptions,\n  ): PreparedMessage {\n    const message: InitializeMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Initialize,\n      crossFrameVersion: crossFrameVersion,\n      apiVersion: apiVersion,\n      options: options,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareCommandMessage(verbId: VerbId, parameters: ExecuteParameters): PreparedMessage {\n    const message: CommandMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Command,\n      verbId: verbId,\n      parameters: parameters,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareCommandResponseMessage(commandGuid: string, data: Model | undefined, error: Model | undefined): PreparedMessage {\n    const message: CommandResponseMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.CommandResponse,\n      commandGuid: commandGuid,\n      data: data,\n      error: error,\n    };\n\n    if (error) {\n      // stringify error object to remove unserializable fields like functions and prevent serialization errors\n      message.error = JSON.parse(JSON.stringify(error));\n    }\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareNotificationMessage(notificationId: NotificationId, data: Model): PreparedMessage {\n    const message: NotificationMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Notification,\n      notificationId: notificationId,\n      data: data,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareAckMessage(): PreparedMessage {\n    const message: HandshakeMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Ack,\n      platformVersion: INTERNAL_CONTRACT_VERSION,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  /**\n   * Prepares a pending message for sending and returns the prepared message\n   *\n   * @param msg The message to be sent to this.otherWindow\n   * @returns The prepared message\n   */\n  private prepareMessage(msg: Message): PreparedMessage {\n    if (!this.otherWindow || !this.otherWindowOrigin) {\n      throw 'Other window not initialized, cannot dispatch messages';\n    }\n\n    const preparedMessage = new CrossFramePreparedMessage(msg, this.otherWindow, this.otherWindowOrigin);\n    return preparedMessage;\n  }\n\n  /**\n   * Called when a message is received. Does some validation of the message, and then\n   * calls an appropriate message handler if one is defined\n   *\n   * @param event The incoming MessageEvent\n   */\n  private onMessageReceived(event: MessageEvent): void {\n    // If we have an otherWindow defined, make sure the message is coming from there\n    if (this.otherWindow && event.source !== this.otherWindow) {\n      return;\n    }\n\n    // Do some validation on event.data to make sure that we have received a real message\n    if (!event.data) {\n      return;\n    }\n\n    const message = event.data;\n    if (!isMessage(message)) {\n      return;\n    }\n\n    // Check the declared message type, validate the message, and call an appropriate hander if one exists\n    switch (message.msgType) {\n      case MessageType.Initialize: {\n        if (!isInitMessage(message) || !this.initializeMessageHandler) {\n          return;\n        }\n\n        this.initializeMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.CommandResponse: {\n        if (!isCommandResponseMessage(message) || !this.commandResponseMessageHandler) {\n          return;\n        }\n\n        this.commandResponseMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.Command: {\n        if (!isCommandMessage(message) || !this.commandMessageHandler) {\n          return;\n        }\n\n        this.commandMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.Notification: {\n        if (!isNotificationMessage(message) || !this.notificationMessageHandler) {\n          return;\n        }\n\n        this.notificationMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.Handshake: {\n        if (!isHandshakeMessage(message) || !this.handshakeMessageHandler) {\n          return;\n        }\n\n        this.handshakeMessageHandler(message, event.source);\n        break;\n      }\n      default:\n      // Just ignore this since we don't know how to handle the message type\n    }\n  }\n\n  public setOtherWindow(otherWindow: Window): void {\n    this.otherWindow = otherWindow;\n  }\n\n  public setOtherWindowOrigin(origin: string): void {\n    this.otherWindowOrigin = origin;\n  }\n}\n","import { Message } from './interface/MessageTypes';\nimport { PreparedMessage } from './interface/PreparedMessage';\n\n/**\n * Implementation of the PreparedMessage interface used to post messages between\n * two frames using window.postMessage\n */\nexport class CrossFramePreparedMessage implements PreparedMessage {\n  /**\n   * Creates an instance of CrossFramePreparedMessage.\n   * @param _message The message to be sent\n   * @param _target The target window where the message will be sent\n   * @param _origin The targetOrigin where this message can be received\n   */\n  public constructor(private _message: Message, private _target: Window, private _origin: string) {}\n\n  public get messageGuid(): string {\n    return this._message.msgGuid;\n  }\n\n  public send(): PreparedMessage {\n    this._target.postMessage(this._message, this._origin);\n    return this;\n  }\n}\n","import * as guid from 'guid';\nimport { NotificationId } from '../contract/Notifications';\nimport { VersionNumber } from '../interface/VersionNumber';\nimport {\n  CommandMessage,\n  CommandResponseMessage,\n  HandshakeMessage,\n  InitializeMessage,\n  Message,\n  MessageType,\n  NotificationMessage,\n} from './interface/MessageTypes';\n\nconst expectedEmptyNotifications = new Set([\n  NotificationId.EditButtonClicked,\n  NotificationId.EditInDesktopButtonClicked,\n  NotificationId.WorkbookPublished,\n  NotificationId.WorkbookReadyToClose,\n  NotificationId.ReadyToReceiveAuthToken,\n]);\n\n/* tslint:disable no-any */\nexport function isMessage(data: Message | any): data is Message {\n  if (!data) {\n    return false;\n  }\n\n  const message = data as Message;\n  if (!message || !message.msgGuid || !message.msgType) {\n    return false;\n  }\n\n  if (!guid.isGuid(message.msgGuid)) {\n    return false;\n  }\n\n  if (typeof message.msgType !== 'string') {\n    return false;\n  }\n\n  const messageTypes: Array<string> = [\n    MessageType.Command,\n    MessageType.CommandResponse,\n    MessageType.Initialize,\n    MessageType.Notification,\n    MessageType.Handshake,\n  ];\n\n  if (messageTypes.indexOf(message.msgType) < 0) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isVersion(versionNumber: VersionNumber | any): versionNumber is VersionNumber {\n  if (!versionNumber) {\n    return false;\n  }\n\n  const v = versionNumber as VersionNumber;\n\n  if (typeof v !== 'object') {\n    return false;\n  }\n\n  if (typeof v.fix !== 'number' || typeof v.minor !== 'number' || typeof v.major !== 'number') {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isInitMessage(message: InitializeMessage | any): message is InitializeMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const initMessage = message as InitializeMessage;\n  if (initMessage.msgType !== MessageType.Initialize) {\n    return false;\n  }\n\n  if (!initMessage.apiVersion || !isVersion(initMessage.apiVersion)) {\n    return false;\n  }\n\n  if (!initMessage.crossFrameVersion || !isVersion(initMessage.crossFrameVersion)) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isCommandResponseMessage(message: CommandResponseMessage | any): message is CommandResponseMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const crMessage = message as CommandResponseMessage;\n  if (crMessage.msgType !== MessageType.CommandResponse) {\n    return false;\n  }\n\n  if (!guid.isGuid(crMessage.commandGuid)) {\n    return false;\n  }\n\n  if (!crMessage.data && !crMessage.error) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isCommandMessage(message: CommandMessage | any): message is CommandMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const commandMessage = message as CommandMessage;\n  if (commandMessage.msgType !== MessageType.Command) {\n    return false;\n  }\n\n  if (!commandMessage.parameters || typeof commandMessage.parameters !== 'object') {\n    return false;\n  }\n\n  if (!commandMessage.verbId || typeof commandMessage.verbId !== 'string') {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isNotificationMessage(message: NotificationMessage | any): message is NotificationMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const notificationMessage = message as NotificationMessage;\n  if (notificationMessage.msgType !== MessageType.Notification) {\n    return false;\n  }\n\n  if (!notificationMessage.data && !expectedEmptyNotifications.has(notificationMessage.notificationId)) {\n    return false;\n  }\n\n  if (!notificationMessage.notificationId || typeof notificationMessage.notificationId !== 'string') {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isHandshakeMessage(message: HandshakeMessage | any): message is HandshakeMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const handshakeMessage = message as HandshakeMessage;\n  if (handshakeMessage.msgType !== MessageType.Handshake) {\n    return false;\n  }\n\n  return true;\n}\n","import { ExecuteParameters, Model, NotificationId, VerbId, VersionNumber } from '../../JsApiInternalContract';\nimport { InitializationOptions } from '../../interface/InitializationOptions';\n\n/**\n * Enum defining the 4 different types of messages we have defined\n */\nexport enum MessageType {\n  Initialize = 'initialize',\n  Notification = 'notification',\n  Command = 'command',\n  CommandResponse = 'command-response',\n  Handshake = 'v-handshake',\n  Ack = 'v-ack',\n}\n\n/**\n * The Message interface is the base interface for all the other\n * message type interfaces.\n */\nexport interface Message {\n  /**\n   * A unique id for this message\n   */\n  msgGuid: string;\n\n  /**\n   * The type of this message\n   */\n  msgType: MessageType;\n}\n\n/**\n * The initialize message is the first message which will be sent\n * from the javascript to set up communications\n */\nexport interface InitializeMessage extends Message {\n  /**\n   * The version of the api which the sender wants to use\n   */\n  apiVersion: VersionNumber;\n\n  /**\n   * The version of this messaging contract to be used. For now, there\n   * should only be a single version but sending this along should help\n   * if we need to add a new version in a future release\n   */\n  crossFrameVersion: VersionNumber;\n\n  /**\n   * Additional options that can be passed at the time of initialization\n   */\n  options?: InitializationOptions;\n}\n\n/**\n * This message is sent when a notification occurs from the preslayer\n */\nexport interface NotificationMessage extends Message {\n  /**\n   * The id for this type of notification\n   */\n  notificationId: NotificationId;\n\n  /**\n   * The data which came along with the notification\n   */\n  data: Model;\n}\n\n/**\n * Represents calling an internal contract command\n */\nexport interface CommandMessage extends Message {\n  /**\n   * The id of the command which should be executed\n   */\n  verbId: VerbId;\n\n  /**\n   * An object containing the parameters for the command\n   */\n  parameters: ExecuteParameters;\n}\n\n/**\n * This message is sent in response to a CommandMessage with the\n * result of that commands invocation\n */\nexport interface CommandResponseMessage extends Message {\n  /**\n   * Guid of the CommandMessage which this is in response to\n   */\n  commandGuid: string;\n\n  /**\n   * If there was an error returned from the command, this will be defined\n   * and contain the error\n   */\n  error?: Model;\n\n  /**\n   * If the command executed successfully, this will contain the command result\n   */\n  data?: Model;\n}\n\nexport interface HandshakeMessage extends Message {\n  /**\n   * Internal API contract version\n   */\n  platformVersion: VersionNumber;\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId } from '../JsApiInternalContract';\nimport { InternalContractVersionConverter } from './InternalContractVersionConverter';\n\n// tslint:disable:no-any\n\n/**\n * This version converter doesn't actually do anything but is useful for testing or when we have\n * a matching platform and internal version number\n */\nexport class IdentityVersionConverter implements InternalContractVersionConverter {\n  public upgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    return {\n      verb: verb as VerbId,\n      parameters: parameters as ExecuteParameters,\n    };\n  }\n\n  public downgradeExecuteReturn(executeResponse: ExecuteResponse): ExecuteResponse {\n    return executeResponse;\n  }\n\n  public downgradeNotification(notification: Notification): Notification {\n    return notification;\n  }\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId, VersionNumber } from '../JsApiInternalContract';\nimport { InternalContractVersionConverter } from './InternalContractVersionConverter';\nimport * as Translations from './VersionTranslations';\n\n// tslint:disable:no-any\n\n/**\n * The version converter is designed to allow the platform and external modules\n * to seemlessly communicate over two different versions of the internal API. The only\n * mode it supports is external's version <= platform's version. When executing\n * commands, it is used to upgrade the external representation to what platform knows on the way in\n * and downgrade the representations on the way out. Similarly for notifications, it can\n * downgrade those on the way from platform to external.\n */\nexport class StackingVersionConverter implements InternalContractVersionConverter {\n  /**\n   * Creates a new instance of the StackingVersionConverter\n   *\n   * @param _externalVersion The version of the internal contract api-external-js is using\n   * @param _platformVersion The version of the internal contract the api-platform-js is using\n   * @param _upgradeExecuteTranslations Ordered list of the translations to perform when upgrading cmd parameters\n   * @param _downgradeExecuteTranslations Ordered list of downgrade translations to perform after a cmd\n   * @param _downgradeNotificationTranslations Ordered list of downgrade translations to perform on a notification\n   */\n  public static fromData(\n    externalVersion: VersionNumber,\n    platformVersion: VersionNumber,\n    upgradeExecuteTranslations: Array<Translations.UpgradeExecuteCall>,\n    downgradeExecuteTranslations: Array<Translations.DowngradeExecuteReturn>,\n    downgradeNotificationTranslations: Array<Translations.DowngradeNotification>,\n  ): StackingVersionConverter {\n    return new this(\n      externalVersion.major,\n      platformVersion.major,\n      upgradeExecuteTranslations,\n      downgradeExecuteTranslations,\n      downgradeNotificationTranslations,\n    );\n  }\n\n  /**\n   * Creates a new instance of the StackingVersionConverter\n   *\n   * @param _externalMajorVersion The major version of the internal contract api-external-js is using\n   * @param _platformMajorVersion The major version of the internal contract the api-platform-js is using\n   * @param _upgradeExecuteTranslations Ordered list of the translations to perform when upgrading cmd parameters\n   * @param _downgradeExecuteTranslations Ordered list of downgrade translations to perform after a cmd\n   * @param _downgradeNotificationTranslations Ordered list of downgrade translations to perform on a notification\n   */\n  public constructor(\n    private _externalMajorVersion: number,\n    private _platformMajorVersion: number,\n    private _upgradeExecuteTranslations: Array<Translations.UpgradeExecuteCall>,\n    private _downgradeExecuteTranslations: Array<Translations.DowngradeExecuteReturn>,\n    private _downgradeNotificationTranslations: Array<Translations.DowngradeNotification>,\n  ) {\n    if (this._externalMajorVersion > this._platformMajorVersion) {\n      throw new Error(`Cannot convert between external version ${this._externalMajorVersion} and ${this._platformMajorVersion}`);\n    }\n  }\n\n  public upgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    // Perform the upgrade of the verb and parameters to the level that platform is using\n    let upgraded = { verb: verb, parameters: parameters };\n    for (const upgradeTranslation of this._upgradeExecuteTranslations) {\n      upgraded = upgradeTranslation(upgraded.verb, upgraded.parameters);\n    }\n\n    return upgraded;\n  }\n\n  public downgradeExecuteReturn(executeResponse: ExecuteResponse): ExecuteResponse {\n    // Downgrade the response to what the external module is expecting\n    let downgraded = executeResponse;\n    for (const downgradeTranslation of this._downgradeExecuteTranslations) {\n      downgraded = downgradeTranslation(downgraded);\n    }\n\n    return downgraded;\n  }\n\n  public downgradeNotification(notification: Notification): Notification {\n    // Downgrade the notification to what the external module is expecting\n    let downgraded = notification;\n    for (const downgradeTranslation of this._downgradeNotificationTranslations) {\n      downgraded = downgradeTranslation(downgraded);\n    }\n\n    return downgraded;\n  }\n}\n","import { VersionNumber } from '../JsApiInternalContract';\nimport { IdentityVersionConverter } from './IdentityVersionConverter';\nimport { InternalContractVersionConverter } from './InternalContractVersionConverter';\nimport { StackingVersionConverter } from './StackingVersionConverter';\nimport * as Translations from './VersionTranslations';\nimport { DowngradeFlipboardZoneID, DowngradeWorksheetNames } from './VersionTranslations';\n\n/**\n * @returns true if lhs < rhs (ignoring fix number)\n * @param lhs\n * @param rhs\n */\nexport function VersionLessThan(lhs: VersionNumber, rhs: VersionNumber): boolean {\n  if (lhs.major > rhs.major) {\n    return false;\n  }\n  if (lhs.major < rhs.major) {\n    return true;\n  }\n  return lhs.minor < rhs.minor;\n}\n\n/**\n * @returns true if lhs == rhs (ignoring fix number)\n * @param lhs\n * @param rhs\n */\nexport function VersionEqualTo(lhs: VersionNumber, rhs: VersionNumber): boolean {\n  return lhs.major === rhs.major && lhs.minor === rhs.minor;\n}\n\nexport interface MajorMinorTranslators<T> {\n  [major: number]: { [minor: number]: Array<T> };\n}\n\n// A mapping from an older client version of internal-contract to the current platform version of this contract.\n// Each version bump can have an array of translations to perform in order. Notice that this is\n// different than the major upgrades/downgrades above because it handles both major and minor version changes.\n// Also please note: downgradeExecuteCall is handled on the client/external side rather than platform side.\n// When updating the major or minor version of our internal-contract, you will need to update these data structures.\n// * If there are translations to add, add them to the version to \"upgrade from\" or \"downgrade to\".\nexport const ExecuteMinorUpgrades: MajorMinorTranslators<Translations.UpgradeExecuteCall> = {\n  1: {\n    9: [], // Note that we put upgrades from 1.9 to 1.10 in the [1][9] bucket\n  },\n};\n\nexport const ExecuteMinorDowngrades: MajorMinorTranslators<Translations.DowngradeExecuteReturn> = {\n  1: {\n    5: [DowngradeWorksheetNames],\n    9: [],\n  },\n};\n\nexport const NotificationMinorDowngrades: MajorMinorTranslators<Translations.DowngradeNotification> = {\n  1: {\n    9: [],\n    10: [DowngradeFlipboardZoneID],\n  },\n};\n\n/**\n * Creates a new InternalContractVersionConverter which has the ability to upgrade and downgrade the contract\n * between the two versions, which are specified. If externalMajorVersion is greater than platformMajorVersion,\n * an error will be thrown because we won't know how to do those conversions.\n * This converter can handle both major and minor updates when the platform version is greater than external version.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n */\nexport function CreateVersionConverter(externalVersion: VersionNumber, platformVersion: VersionNumber): InternalContractVersionConverter {\n  return CreateVersionConverterWithTranslators(\n    externalVersion,\n    platformVersion,\n    ExecuteMinorUpgrades,\n    ExecuteMinorDowngrades,\n    NotificationMinorDowngrades,\n  );\n}\n\n/**\n * Implementation of CreateVersionConverter. This function takes the upgrade, downgrade, and\n * notification arrays so that all the logic can be tested.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n * @param upgrades MajorMinorTranslators for upgrades\n * @param downgrades MajorMinorTranslators for downgrades\n * @param notificationDowngrades MajorMinorTranslators for notification downgrades\n */\nexport function CreateVersionConverterWithTranslators(\n  externalVersion: VersionNumber,\n  platformVersion: VersionNumber,\n  upgrades: MajorMinorTranslators<Translations.UpgradeExecuteCall>,\n  downgrades: MajorMinorTranslators<Translations.DowngradeExecuteReturn>,\n  notificationDowngrades: MajorMinorTranslators<Translations.DowngradeNotification>,\n): InternalContractVersionConverter {\n  const externalMajorVersion: number = externalVersion.major;\n  const externalMinorVersion: number = externalVersion.minor;\n  const platformMajorVersion: number = platformVersion.major;\n\n  if (externalMajorVersion > platformMajorVersion) {\n    throw new Error(`External version must be less than or equal to platform version.\n    externalMajorVersion=${externalMajorVersion} platformMajorVersion=${platformMajorVersion}`);\n  }\n\n  // If we are using the exact same versions (major.minor), just use the identity converter\n  if (VersionEqualTo(externalVersion, platformVersion)) {\n    return new IdentityVersionConverter();\n  }\n\n  // Walk the span between the versions we have here and collect the upgrade and downgrades necessary\n  const neededExecuteUpgrades: Array<Translations.UpgradeExecuteCall> = GetNeededTranslations(\n    externalMajorVersion,\n    platformMajorVersion,\n    externalMinorVersion,\n    upgrades,\n  );\n\n  const neededExecuteDowngrades: Array<Translations.DowngradeExecuteReturn> = GetNeededTranslations(\n    externalMajorVersion,\n    platformMajorVersion,\n    externalMinorVersion,\n    downgrades,\n  );\n\n  const neededNotificationDowngrades: Array<Translations.DowngradeNotification> = GetNeededTranslations(\n    externalMajorVersion,\n    platformMajorVersion,\n    externalMinorVersion,\n    notificationDowngrades,\n  );\n\n  // We want to apply the downgrades in reverse order in case of dependencies between them\n  neededExecuteDowngrades.reverse();\n  neededNotificationDowngrades.reverse();\n\n  return StackingVersionConverter.fromData(\n    externalVersion,\n    platformVersion,\n    neededExecuteUpgrades,\n    neededExecuteDowngrades,\n    neededNotificationDowngrades,\n  );\n}\n\nfunction GetNeededTranslations<T>(\n  externalMajorVersion: number,\n  platformMajorVersion: number,\n  externalMinorVersion: number,\n  majorMinorTranslators: MajorMinorTranslators<T>,\n): Array<T> {\n  const neededTranslations: Array<T> = [];\n\n  for (let major = externalMajorVersion; major <= platformMajorVersion; major++) {\n    if (major in majorMinorTranslators) {\n      const start = major === externalMajorVersion ? externalMinorVersion : 0;\n      const maximumMinorVersion = GetMaximumMinorIndex(Object.keys(majorMinorTranslators[major]));\n      for (let minor = start; minor <= maximumMinorVersion; minor++) {\n        if (minor in majorMinorTranslators[major]) {\n          neededTranslations.push(...majorMinorTranslators[major][minor]);\n        }\n      }\n    }\n  }\n\n  return neededTranslations;\n}\n\nexport function GetMaximumMinorIndex(minorVersions: Array<string>): number {\n  return minorVersions.map((a) => Number(a)).reduce((a, b) => (a > b ? a : b));\n}\n","import { ExecuteParameters, ExecuteResponse, ExtensionBootstrapInfo, Notification, VerbId } from '../JsApiInternalContract';\nimport { VisualId } from '../contract/Models';\nimport { NotificationId } from '../contract/Notifications';\n\n// tslint:disable:no-any\n\n/** This function is called when we receive old vers and parameters from the external before we send it to platform */\nexport type UpgradeExecuteCall = (verb: VerbId, parameters: ExecuteParameters) => { verb: VerbId; parameters: ExecuteParameters };\n\n/** This function is called when we received a response back from platform and we need to downgrade it to external's version */\nexport type DowngradeExecuteReturn = (executeResponse: ExecuteResponse) => ExecuteResponse;\n\n/** This function is called when we receive a notification from platform and we need to downgrade it to external's version */\nexport type DowngradeNotification = (notification: Notification) => Notification;\n\n// This is where we will start to define some of these translations.\n// When modifying existing models, add the requisite conversion functions here, then use them\n// in the VersionConverterFactory implementation. Import old versions as you would any other module\n\n// 0 <-> Translations\n// Uncomment this line to import from the V0 definition of the API\n// import * as V0 from '@tableau-api-internal-contract-js_v0';\n\n// 1 <-> 2 Translations\n// Uncomment this line to import from the V1 definition of the API\n// import * as V1 from '@tableau-api-internal-contract-js_v1';\n\nexport function DowngradeWorksheetNames(executeResponse: ExecuteResponse): ExecuteResponse {\n  // Fix the dashboard friendly name issue. The structures are compatible,\n  // so we still return the original reply, but we copy the SheetInfo.name\n  // into the DashboardZone.name, where v1 wants to find it.\n\n  const bootstrapInfo = executeResponse.result as ExtensionBootstrapInfo;\n  if (bootstrapInfo.extensionDashboardInfo !== undefined) {\n    bootstrapInfo.extensionDashboardInfo.zones.forEach((zone) => {\n      if (zone.sheetInfo) {\n        zone.name = zone.sheetInfo.name;\n      }\n    });\n  }\n\n  return executeResponse;\n}\n\nexport function DowngradeFlipboardZoneID(notification: Notification): Notification {\n  // Fix the FlipboardZoneId issue. Older external versions still check for flipboardZoneIDs.\n  // When running against a newer server, if flipboardZoneId is absent, set it to default(0).\n\n  if (notification.notificationId === NotificationId.SelectedMarksChanged) {\n    const visualModel = notification.data as VisualId;\n    if (visualModel.flipboardZoneID === undefined) {\n      visualModel.flipboardZoneID = 0;\n    }\n  }\n\n  return notification;\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId } from '../../JsApiInternalContract';\nimport { ExternalContractVersionConverter } from './ExternalContractVersionConverter';\n\n// tslint:disable:no-any\n\n/**\n * This version converter doesn't actually do anything but is useful for testing or when we have\n * a matching platform and external version number\n */\nexport class ExternalIdentityVersionConverter implements ExternalContractVersionConverter {\n  public downgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    return {\n      verb: verb as VerbId,\n      parameters: parameters as ExecuteParameters,\n    };\n  }\n\n  public upgradeExecuteReturn(executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters): ExecuteResponse {\n    return executeResponse;\n  }\n\n  public upgradeNotification(notification: Notification): Notification {\n    return notification;\n  }\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId, VersionNumber } from '../../JsApiInternalContract';\nimport { ExternalContractVersionConverter } from './ExternalContractVersionConverter';\nimport * as Translations from './ExternalVersionTranslations';\n\n// tslint:disable:no-any\n/**\n * The version converter is designed to allow the platform and external modules\n * to seemlessly communicate over two different versions of the internal API. This converter\n * supports external's version(minor) >= platform's version(minor). When executing\n * commands, it is used to downgrade the external representation to what platform knows on the way in\n * and upgrade the representations on the way out.\n */\nexport class ExternalStackingVersionConverter implements ExternalContractVersionConverter {\n  /**\n   * Creates a new instance of the StackingVersionConverter\n   *\n   * @param _externalVersion The version of the internal contract api-external-js is using\n   * @param _platformVersion The version of the internal contract the api-platform-js is using\n   * @param _downgradeExecuteCallTranslations Ordered list of the translations to perform when downgrading cmd parameters\n   * @param _upgradeExecuteReturnTranslations Ordered list of upgrade translations to perform after a cmd is executed\n   * @param _upgradeNotificationTranslations Ordered list of upgrade notfications to perform on events\n   */\n  public constructor(\n    private _externalVersion: VersionNumber,\n    private _platformVersion: VersionNumber,\n    private _downgradeExecuteCallTranslations: Array<Translations.DowngradeExecuteCall>,\n    private _upgradeExecuteReturnTranslations: Array<Translations.UpgradeExecuteReturn>,\n    private _upgradeNotificationTranslations: Array<Translations.UpgradeNotification>,\n  ) {\n    if (this._externalVersion.major > this._platformVersion.major) {\n      throw new Error(`Cannot convert between external version ${this._externalVersion.major}\n      and ${this._platformVersion.major}`);\n    }\n  }\n\n  public downgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    // Perform the downgrade of the verb and parameters to the level that platform is using\n    let downgraded = { verb: verb, parameters: parameters };\n    for (const downgradeTranslation of this._downgradeExecuteCallTranslations) {\n      downgraded = downgradeTranslation(downgraded.verb, downgraded.parameters);\n    }\n\n    return downgraded;\n  }\n\n  public upgradeExecuteReturn(executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters): ExecuteResponse {\n    // Perform the upgrade of the response to what the external module is expecting\n    let upgraded = executeResponse;\n    for (const upgradeTranslation of this._upgradeExecuteReturnTranslations) {\n      upgraded = upgradeTranslation(upgraded, verb, parameters);\n    }\n\n    return upgraded;\n  }\n\n  public upgradeNotification(notification: Notification): Notification {\n    // Perform the upgrade of notification to what the external module is expecting\n    let upgraded = notification;\n    for (const upgradeNotification of this._upgradeNotificationTranslations) {\n      upgraded = upgradeNotification(upgraded);\n    }\n\n    return upgraded;\n  }\n}\n","import { VersionNumber } from '../../JsApiInternalContract';\nimport { GetMaximumMinorIndex, MajorMinorTranslators, VersionEqualTo } from '../VersionConverterFactory';\nimport { ExternalContractVersionConverter } from './ExternalContractVersionConverter';\nimport { ExternalIdentityVersionConverter } from './ExternalIdentityVersionConverter';\nimport { ExternalStackingVersionConverter } from './ExternalStackingVersionConverter';\nimport * as TranslationsExternal from './ExternalVersionTranslations';\nimport {\n  DowngradeLogicalTableDataAsync,\n  DowngradeUnderlyingTableDataAsync,\n  UpgradeDataTableRowsAndColumns,\n  UpgradeDataTableTypes,\n} from './ExternalVersionTranslations';\n\n// A mapping from the current client version of internal-contract to an older platform version of the contract.\n// Each version bump can have an array of translations to perform in order.\n// These translations handle downgradeExecuteCall and upgradeExecuteReturn and are meant to be called on the\n// client/external side.\n// When updating the major or minor version of our internal-contract, you will need to update these data structures.\n// * If there are translations to add, add them to the version to 'upgrade from' or 'downgrade to'.\nexport const ExecuteMinorDowngradeCallExternal: MajorMinorTranslators<TranslationsExternal.DowngradeExecuteCall> = {\n  1: {\n    9: [], // Note that we put downgrades from 1.10 to 1.9 in the [1][9] bucket\n    13: [DowngradeUnderlyingTableDataAsync, DowngradeLogicalTableDataAsync],\n  },\n};\n\nexport const ExecuteMinorUpgradeReturnExternal: MajorMinorTranslators<TranslationsExternal.UpgradeExecuteReturn> = {\n  1: {\n    9: [UpgradeDataTableTypes], // Note that we put upgrades from 1.9 to 1.10 in the [1][9] bucket\n    29: [UpgradeDataTableRowsAndColumns], // 2021.1 was released with 1.29. Upgrade from 1.29 in the [1][29] bucket\n  },\n};\n\nexport const ExecuteMinorUpgradeNotification: MajorMinorTranslators<TranslationsExternal.UpgradeNotification> = {\n  1: {\n    9: [], // Note that we put upgrades from 1.9 to 1.10 in the [1][9] bucket\n  },\n};\n\n/**\n * Creates a new ExternalContractVersionConverter which has the ability to upgrade and downgrade\n * the contract between the two versions which are specified. If externalMajorVersion is less than\n * platformMajorVersion, an ExternalIdentityVersionConverter will be returned.\n * Handles upgrade/downgrade for both major and minor updates.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n */\nexport function CreateExternalCompatibleVersionConverter(\n  externalVersion: VersionNumber,\n  platformVersion: VersionNumber,\n): ExternalContractVersionConverter {\n  return CreateExternalCompatibleVersionConverterWithTranslators(\n    externalVersion,\n    platformVersion,\n    ExecuteMinorDowngradeCallExternal,\n    ExecuteMinorUpgradeReturnExternal,\n    ExecuteMinorUpgradeNotification,\n  );\n}\n\n/**\n * Implementation of CreateExternalCompatibleVersionConverterWithTranslators.\n * This function takes the upgrade, downgrade arrays so that all the logic can be tested.\n *\n * @param externalVersion VersionNumber of the internal contract which the external module is using\n * @param platformVersion VersionNumber of the internal contract which the platform is using\n * @param upgrades MajorMinorTranslators for response upgrades\n * @param downgrades MajorMinorTranslators for execute call downgrades\n */\nexport function CreateExternalCompatibleVersionConverterWithTranslators(\n  externalVersion: VersionNumber,\n  platformVersion: VersionNumber,\n  downgrades: MajorMinorTranslators<TranslationsExternal.DowngradeExecuteCall>,\n  upgrades: MajorMinorTranslators<TranslationsExternal.UpgradeExecuteReturn>,\n  upgradeNotifications: MajorMinorTranslators<TranslationsExternal.UpgradeNotification>,\n): ExternalContractVersionConverter {\n  const externalMajorVersion: number = externalVersion.major;\n  const platformMajorVersion: number = platformVersion.major;\n  const platformMinorVersion: number = platformVersion.minor;\n\n  // This check is present in VersionConverterFactory. We throw the same error here as well.\n  // Hence we only need to check the minor versions for translations.\n  if (externalMajorVersion > platformMajorVersion) {\n    throw new Error(`External version must be less than or equal to platform version.\n    externalMajorVersion=${externalMajorVersion} platformMajorVersion=${platformMajorVersion}`);\n  }\n\n  if (externalMajorVersion < platformMajorVersion || VersionEqualTo(externalVersion, platformVersion)) {\n    return new ExternalIdentityVersionConverter();\n  }\n\n  // Walk the span between the versions we have here and collect the upgrade and downgrades necessary\n  const neededExecuteCallDowngrade: Array<TranslationsExternal.DowngradeExecuteCall> = GetNeededExternalTranslations(\n    platformMajorVersion,\n    platformMinorVersion,\n    downgrades,\n  );\n\n  const neededExecuteReturnUpgrades: Array<TranslationsExternal.UpgradeExecuteReturn> = GetNeededExternalTranslations(\n    platformMajorVersion,\n    platformMinorVersion,\n    upgrades,\n  );\n\n  const neededNotificationUpgrades: Array<TranslationsExternal.UpgradeNotification> = GetNeededExternalTranslations(\n    platformMajorVersion,\n    platformMinorVersion,\n    upgradeNotifications,\n  );\n\n  // Reverse the downgrade calls, so that we start the downgrade from the external version to the platform version\n  neededExecuteCallDowngrade.reverse();\n  return new ExternalStackingVersionConverter(\n    externalVersion,\n    platformVersion,\n    neededExecuteCallDowngrade,\n    neededExecuteReturnUpgrades,\n    neededNotificationUpgrades,\n  );\n}\n\nfunction GetNeededExternalTranslations<T>(\n  platformMajorVersion: number,\n  platformMinorVersion: number,\n  majorMinorTranslators: MajorMinorTranslators<T>,\n): Array<T> {\n  const neededTranslations: Array<T> = [];\n\n  if (platformMajorVersion in majorMinorTranslators) {\n    const start = platformMinorVersion;\n    const maximumMinorVersion = GetMaximumMinorIndex(Object.keys(majorMinorTranslators[platformMajorVersion]));\n    for (let minor = start; minor <= maximumMinorVersion; minor++) {\n      if (minor in majorMinorTranslators[platformMajorVersion]) {\n        neededTranslations.push(...majorMinorTranslators[platformMajorVersion][minor]);\n      }\n    }\n  }\n\n  return neededTranslations;\n}\n","import {\n  ApiShowDataTableSentinel,\n  DataHeader,\n  DataTable,\n  DataTypeConverter,\n  ExecuteParameters,\n  ExecuteResponse,\n  InternalTableauError,\n  Notification,\n  ParameterId,\n  SelectedMarksTable,\n  UnderlyingDataTable,\n  VerbId,\n} from '../../JsApiInternalContract';\n\n// tslint:disable:no-any\n\n/** This function is called when we receive newer version and parameters from the external before we send it to platform */\nexport type DowngradeExecuteCall = (verb: VerbId, parameters: ExecuteParameters) => { verb: VerbId; parameters: ExecuteParameters };\n\n/** This function is called when we receive a response back from platform and we need to upgrade it to external's version\n *  The verb and parameters provide a context to decide how to handle the response.\n */\nexport type UpgradeExecuteReturn = (executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters) => ExecuteResponse;\n\n/** This function is called when we receive a notification from platform and we need to upgrade it to external's version */\nexport type UpgradeNotification = (notification: Notification) => Notification;\n\n// 1.2 -> 1.0 Translations\n// Uncomment this line to import from the V1 definition of the API\n// import * as V1 from '@tableau-api-internal-contract-js_v1';\n\n/**\n * Prior to 2019.2 (internal-contract v1.9), DataValue.value were all strings.\n * Go through all DataValue objects. If we have a string, but the type should not be a string,\n * convert it to the correct type. The type of DataValue.value is 'any' in the contract, so\n * this change doesn't need any updates to classes or types.\n */\nexport function UpgradeDataTableTypes(executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters): ExecuteResponse {\n  if (!executeResponse) {\n    return executeResponse;\n  }\n\n  const oldUnderlyingDataTable = executeResponse.result as UnderlyingDataTable;\n  if (oldUnderlyingDataTable.data !== undefined && oldUnderlyingDataTable.isSummary !== undefined) {\n    convertDataValues(oldUnderlyingDataTable.data);\n    return executeResponse;\n  }\n\n  const oldSelectedMarksTable = executeResponse.result as SelectedMarksTable;\n  if (oldSelectedMarksTable.data !== undefined && Array.isArray(oldSelectedMarksTable.data)) {\n    oldSelectedMarksTable.data.forEach((marksTable) => {\n      convertDataValues(marksTable);\n    });\n    return executeResponse;\n  }\n\n  return executeResponse;\n}\n\n/**\n * Prior to 2020.2 (internal-contract v1.13 and older), worksheet.getUnderlyingTableDataAsync doesn't exist.\n * Map it to the older GetUnderlyingData verb and validate the the logical table Id.\n **/\nexport function DowngradeUnderlyingTableDataAsync(\n  verb: VerbId,\n  parameters: ExecuteParameters,\n): {\n  verb: VerbId;\n  parameters: ExecuteParameters;\n} {\n  if (verb === VerbId.GetUnderlyingTableData) {\n    validateParametersForObjectModel(verb, parameters);\n    verb = VerbId.GetUnderlyingData;\n  }\n  return {\n    verb: verb,\n    parameters: parameters,\n  };\n}\n\n/**\n * Prior to 2020.2 (internal-contract v1.13 and older), datasource.getLogicalTableDataAsync doesn't exist.\n * Map it to the older GetDataSourceData verb and validate the the logical table Id.\n **/\nexport function DowngradeLogicalTableDataAsync(\n  verb: VerbId,\n  parameters: ExecuteParameters,\n): {\n  verb: VerbId;\n  parameters: ExecuteParameters;\n} {\n  if (verb === VerbId.GetLogicalTableData) {\n    validateParametersForObjectModel(verb, parameters);\n    verb = VerbId.GetDataSourceData;\n  }\n  return {\n    verb: verb,\n    parameters: parameters,\n  };\n}\n\nfunction convertDataValues(table: DataTable): void {\n  // dataTable is a two-dimensional array of data. First index is the row, second is the column.\n  if (table === undefined || table.dataTable === undefined || !Array.isArray(table.dataTable)) {\n    return;\n  }\n\n  table.dataTable.forEach((row) => {\n    row.forEach((dataValue, columnIndex) => {\n      const value = dataValue.value;\n      if (value !== null) {\n        dataValue.value = DataTypeConverter.convertValueAsStringToValue(value, table.headers[columnIndex].dataType);\n      }\n    });\n  });\n}\n\n// ToDo: TFS1069027 Refactor input verbs & parameters in api-internal-contract Upgrade/Downgrade framework\nfunction validateParametersForObjectModel(verb: VerbId, parameters: ExecuteParameters): void {\n  if (parameters[ParameterId.LogicalTableId] !== ApiShowDataTableSentinel.SingleTableId) {\n    throw new Error(`Invalid logical table id passed to ${verb}.`) as InternalTableauError;\n  }\n}\n\n/**\n * Prior to 2021.2 (internal-contract v1.29 and below), getSummaryDataAsync did not support maxRows,\n * and any get...DataAsync did not support columnsToIncludeById.\n * Trim result to maxRows if it is included in the parameters for getSummaryDataAsync\n * Trim columns to columnsToInclude if included in the parameters for any get...DataAsync\n */\nexport function UpgradeDataTableRowsAndColumns(\n  executeResponse: ExecuteResponse,\n  verb: VerbId,\n  parameters: ExecuteParameters,\n): ExecuteResponse {\n  if (isGetSummaryDataVerb(verb) && parameters[ParameterId.MaxRows]) {\n    executeResponse = adjustDataRowLength(executeResponse, parameters[ParameterId.MaxRows] as number);\n  }\n\n  if (isGetTableDataVerb(verb) && parameters[ParameterId.ColumnsToIncludeById]) {\n    executeResponse = adjustDataColumns(executeResponse, parameters[ParameterId.ColumnsToIncludeById] as string[]);\n  }\n\n  return executeResponse;\n}\n\nfunction isGetSummaryDataVerb(verb: VerbId): boolean {\n  return verb === VerbId.GetDataSummaryData;\n}\n\nfunction isGetTableDataVerb(verb: VerbId): boolean {\n  return (\n    verb === VerbId.GetDataSummaryData ||\n    verb === VerbId.GetUnderlyingTableData ||\n    verb === VerbId.GetLogicalTableData ||\n    verb === VerbId.GetDataSourceData ||\n    verb === VerbId.GetUnderlyingData\n  );\n}\n\nfunction adjustDataRowLength(executeResponse: ExecuteResponse, maxRows: number): ExecuteResponse {\n  const underlyingDataTable = executeResponse.result as UnderlyingDataTable;\n  if (!underlyingDataTable.data || !Array.isArray(underlyingDataTable.data.dataTable)) {\n    return executeResponse;\n  }\n\n  if (maxRows > 0 && maxRows < underlyingDataTable.data.dataTable.length) {\n    underlyingDataTable.data.dataTable.length = maxRows;\n  }\n  return executeResponse;\n}\n\nfunction adjustDataColumns(executeResponse: ExecuteResponse, columnsToInclude: string[]): ExecuteResponse {\n  if (columnsToInclude.length === 0) {\n    return executeResponse;\n  }\n\n  // verify that we have a valid UnderlyingDataTable\n  const underlyingDataTable = executeResponse.result as UnderlyingDataTable;\n  if (!underlyingDataTable.data || !Array.isArray(underlyingDataTable.data.dataTable) || !Array.isArray(underlyingDataTable.data.headers)) {\n    return executeResponse;\n  }\n\n  // 1. filter the headers to only columnsToInclude\n  // 2. use the new headers to filter all rows\n  // 3. update the indices in our new headers\n  const newHeaders: DataHeader[] = underlyingDataTable.data.headers.filter((header, index) =>\n    columnsToInclude.find((name) => name === header.fieldName),\n  );\n  underlyingDataTable.data.dataTable.forEach((row, index) => {\n    underlyingDataTable.data.dataTable[index] = row.filter(\n      (value, valueIndex) => newHeaders.findIndex((header) => header.index === valueIndex) !== -1,\n    );\n  });\n  let newIndex = 0;\n  underlyingDataTable.data.headers = newHeaders.map((header) => {\n    header.index = newIndex++;\n    return header;\n  });\n\n  return executeResponse;\n}\n","// Export everything which had been previously in the api-shared module\n\nexport { ApiVersion } from './ApiShared/ApiVersion';\nexport * from './ApiShared/CrossFrame/CrossFrameBootstrap';\nexport { CrossFrameDispatcher } from './ApiShared/CrossFrame/CrossFrameDispatcher';\nexport { DataSource } from './ApiShared/DataSource';\nexport { ExternalToInternalEnumMappings } from './ApiShared/EnumMappings/ExternalToInternalEnumMappings';\nexport { InternalToExternalEnumMappings } from './ApiShared/EnumMappings/InternalToExternalEnumMappings';\nexport { EventListenerManager } from './ApiShared/EventListenerManager';\nexport { Field } from './ApiShared/Field';\nexport { CustomViewImpl } from './ApiShared/Impl/CustomViewImpl';\nexport { DashboardImpl } from './ApiShared/Impl/DashboardImpl';\nexport { DashboardObjectImpl } from './ApiShared/Impl/DashboardObjectImpl';\nexport { DataSourceImpl } from './ApiShared/Impl/DataSourceImpl';\nexport { ParameterImpl } from './ApiShared/Impl/ParameterImpl';\nexport { SheetImpl } from './ApiShared/Impl/SheetImpl';\nexport { SheetInfoImpl } from './ApiShared/Impl/SheetInfoImpl';\nexport { SingleEventManagerImpl } from './ApiShared/Impl/SingleEventManagerImpl';\nexport { StoryImpl } from './ApiShared/Impl/StoryImpl';\nexport { StoryPointImpl } from './ApiShared/Impl/StoryPointImpl';\nexport { StoryPointInfoImpl } from './ApiShared/Impl/StoryPointInfoImpl';\nexport { WorkbookImpl } from './ApiShared/Impl/WorkbookImpl';\nexport { WorksheetImpl } from './ApiShared/Impl/WorksheetImpl';\nexport { Point } from './ApiShared/Point';\nexport { AnnotationService } from './ApiShared/Services/AnnotationService';\nexport { DataSourceService } from './ApiShared/Services/DataSourceService';\nexport { ExportService } from './ApiShared/Services/ExportService';\nexport { FilterService } from './ApiShared/Services/FilterService';\nexport { GetDataService } from './ApiShared/Services/GetDataService';\nexport { NotificationService, UnregisterFn } from './ApiShared/Services/NotificationService';\nexport { ParametersService } from './ApiShared/Services/ParametersService';\nexport * from './ApiShared/Services/RegisterAllSharedServices';\nexport { SelectionService } from './ApiShared/Services/SelectionService';\nexport * from './ApiShared/Services/ServiceRegistry';\nexport { SizeService } from './ApiShared/Services/SizeService';\nexport { StoryActivationService } from './ApiShared/Services/StoryActivationService';\nexport { VizService } from './ApiShared/Services/VizService';\nexport { ClientInfoServiceImpl } from './ApiShared/Services/impl/ClientInfoServiceImpl';\nexport { NotificationServiceImpl } from './ApiShared/Services/impl/NotificationServiceImpl';\nexport { NotificationServiceImplBase, Registration } from './ApiShared/Services/impl/NotificationServiceImplBase';\nexport { ServiceImplBase } from './ApiShared/Services/impl/ServiceImplBase';\nexport { SizeServiceImpl } from './ApiShared/Services/impl/SizeServiceImpl';\nexport { StoryActivationServiceImpl } from './ApiShared/Services/impl/StoryActivationServiceImpl';\nexport { SingleEventManager } from './ApiShared/SingleEventManager';\nexport { TableauError } from './ApiShared/TableauError';\nexport { Deferred } from './ApiShared/Utils/Deferred';\nexport { ErrorHelpers } from './ApiShared/Utils/ErrorHelpers';\nexport { ExportHelpers } from './ApiShared/Utils/ExportHelpers';\nexport { SheetUtils } from './ApiShared/Utils/SheetUtils';\nexport { VersionNumber } from './ApiShared/VersionNumber';\nexport { VersionedExternalApiDispatcher } from './VersionedExternalApiDispatcher';\n","import { VersionNumber } from './VersionNumber';\nimport { VersionNumberContract } from './VersionNumberContract';\n\n/**\n * This is the singleton wrapper of VersionNumber\n */\nexport class ApiVersion {\n  // Using some webpack tricks, we can inject this version into our code (kinda like c++ preprocessor stuff)\n  private static _instance: VersionNumberContract;\n\n  /**\n   * Gets the singleton instance of the version number.\n   */\n  public static get Instance(): VersionNumberContract {\n    return ApiVersion._instance;\n  }\n\n  public static SetVersionNumber(numString: string, isAlpha: boolean): void {\n    ApiVersion._instance = new VersionNumber(numString, isAlpha);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ConnectionDescriptionSummary } from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of a connection summary.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class ConnectionSummary implements Contract.ConnectionSummary {\n  public constructor(private _connectionInfo: ConnectionDescriptionSummary) {}\n\n  public get name(): string {\n    return this._connectionInfo.name;\n  }\n\n  public get id(): string {\n    return this._connectionInfo.id;\n  }\n\n  public get serverURI(): string {\n    return this._connectionInfo.serverURI;\n  }\n\n  public get type(): string {\n    return this._connectionInfo.type;\n  }\n}\n","import * as Contract from '@tableau/api-internal-contract-js';\nimport {\n  CommandResponseMessage,\n  CrossFrameMessenger,\n  InitializationOptions,\n  MESSAGING_VERSION as ApiMessagingVersion,\n} from '@tableau/api-internal-contract-js';\nimport { CrossFrameDispatcher } from './CrossFrameDispatcher';\n\n// Checks to see if we are running in an iframe currently: https://stackoverflow.com/a/326076/8821153\nfunction inIframe(thisWindow: Window): boolean {\n  try {\n    return thisWindow.self !== thisWindow.parent;\n  } catch (e) {\n    return true;\n  }\n}\n\n/**\n * Attempts to bootstrap the extension with a cross-frame parent where Tableau is running\n *\n * @param thisWindow The window which we are running in (injected for unit testing purposes)\n * @param internalContractVersion The version number of the internal contract we are using\n * @returns A promise which is doing the actual bootstrapping\n */\nexport function doCrossFrameBootstrap(\n  thisWindow: Window,\n  internalContractVersion: Contract.VersionNumber,\n  options: InitializationOptions,\n): Promise<Contract.InternalApiDispatcherFactory> {\n  return new Promise<Contract.InternalApiDispatcherFactory>((resolve, reject) => {\n    let parent: Window;\n\n    // Normally, we are running inside an iframe.  The exception to this is\n    // when we are running as an extension inside a dialog as part of the UINamespace\n    // functionality.  In that case, we want the opener of this window rather than the parent.\n    if (!inIframe(thisWindow)) {\n      parent = thisWindow.opener;\n    } else {\n      parent = thisWindow.parent;\n    }\n\n    if (!parent) {\n      reject('This extension is not running inside an iframe, desktop, or popup window. Initialization failed.');\n    }\n\n    // Create the messenger which will do he communication between this window and our parent\n    // Since we don't know where we are running yet, we have to make this initial origin '*'. Once\n    // we have successfully initialized our extension, we will limit where we send messages\n    const messenger = new CrossFrameMessenger(thisWindow, parent, '*');\n\n    // Prepare to send an initialization message to the parent frame\n    const initializationMessage = messenger.prepareInitializationMessage(internalContractVersion, ApiMessagingVersion, options);\n\n    // When we receive a response back from the parent, we check to make sure the guids match and then we know\n    // that the parent is aware of us and we can start communicating\n    messenger.setCommandResponseMessageHandler(function (msg: CommandResponseMessage): void {\n      // Verify we are getting a response from our initialize message\n      if (msg.commandGuid === initializationMessage.messageGuid) {\n        // The versioning of the dispatcher happens on the other side of our frame, and\n        // in a wrapper on this side. This one doesn't have any version knowledge.\n        const dispatcherFactory = () => new CrossFrameDispatcher(messenger);\n        resolve(dispatcherFactory);\n      }\n    });\n\n    // Now that our handlers are ready, start listening and send our initialization message\n    messenger.startListening();\n    initializationMessage.send();\n  });\n}\n","import { EmbeddingErrorCodes } from '@tableau/api-external-contract-js';\nimport {\n  CommandResponseMessage,\n  ExecuteParameters,\n  ExecuteResponse,\n  InternalApiDispatcher,\n  Messenger,\n  Model,\n  NotificationHandler,\n  NotificationMessage,\n  VerbId,\n} from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * This is an implementation of the InternalApiDispatcher interface which functions by passing messages\n * across a frame boundary. This is usually between the code where our javscript library has been included\n * by a 3rd party dev and another frame where Tableau server has content.\n */\nexport class CrossFrameDispatcher implements InternalApiDispatcher {\n  // Collection of pending promises which are waiting to be resolved. When we receive a response back from the other frame,\n  // these promises can be either resolved or rejected\n  private _pendingPromises: { [messageGuid: string]: { resolve: (response: ExecuteResponse) => void; reject: (error: Model) => void } } =\n    {};\n\n  // The collection of notification handlers which have been registered with this dispatcher\n  private _notificationHandlers: Array<NotificationHandler> = [];\n\n  /**\n   * Creates an instance of CrossFrameDispatcher which will use the given messenger to communicate\n   * @param _messenger an instantiated and listening messenger object\n   */\n  public constructor(private _messenger: Messenger) {\n    if (!this._messenger) {\n      throw 'Missing messenger object';\n    }\n\n    // Set up our message handlers. We only care about incoming notifications and command responses\n    this._messenger.setCommandResponseMessageHandler(this.onCommandResponse.bind(this));\n    this._messenger.setNotificationMessageHandler(this.onNotification.bind(this));\n  }\n\n  ////// Start InternalApiDispatcher implementation\n\n  public execute(verb: VerbId, parameters: ExecuteParameters): Promise<ExecuteResponse> {\n    // To execute a verb, we first prepare a command message and then define a promise.\n    const preparedMessage = this._messenger.prepareCommandMessage(verb, parameters);\n    const promise = new Promise<ExecuteResponse>((resolve, reject) => {\n      // Save off the pending promise by the messageGuid we are about to send. When a response is\n      // received, we'll be able to resolve this promise with the result\n      this._pendingPromises[preparedMessage.messageGuid] = { resolve: resolve, reject: reject };\n    });\n\n    // Actually send the message and return the promise\n    preparedMessage.send();\n    return promise;\n  }\n\n  public registerNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers.push(handler);\n  }\n\n  public unregisterNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers = this._notificationHandlers.filter((h) => h !== handler);\n  }\n\n  ////// End InternalApiDispatcher implementation\n\n  private onCommandResponse(response: CommandResponseMessage): void {\n    // We got a command response, look through the pending promises and resolve\n    if (Object.keys(this._pendingPromises).indexOf(response.commandGuid) < 0) {\n      return; // We don't have any reference to this command, just return\n    }\n\n    const pendingPromise = this._pendingPromises[response.commandGuid];\n\n    // If we have an error defined, reject the promise\n    if (response.error) {\n      pendingPromise.reject(response.error);\n    }\n\n    // If we have data defined, resolve the promise\n    if (response.data) {\n      pendingPromise.resolve({ result: response.data });\n    }\n\n    // Clean up our pending promises object\n    delete this._pendingPromises[response.commandGuid];\n  }\n\n  private onNotification(notificationMessage: NotificationMessage): void {\n    // Go through each notification handler we have registered and let them know a notification came in\n    for (const handler of this._notificationHandlers) {\n      try {\n        handler({ notificationId: notificationMessage.notificationId, data: notificationMessage.data });\n      } catch (e) {\n        // Incase of a IncompatibleVersionError, re-throw the error.\n        if ((e as TableauError).errorCode === EmbeddingErrorCodes.IncompatibleVersionError) {\n          throw e;\n        }\n        // Else Ignore  so if one handler errors, the other still get the message.\n      }\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataSourceImpl } from './Impl/DataSourceImpl';\n\nexport class DataSource implements Contract.DataSource {\n  public constructor(private _dataSourceImpl: DataSourceImpl) {}\n\n  public get name(): string {\n    return this._dataSourceImpl.name;\n  }\n\n  public get id(): string {\n    return this._dataSourceImpl.id;\n  }\n\n  public get fields(): Array<Contract.Field> {\n    return this._dataSourceImpl.fields;\n  }\n\n  public get extractUpdateTime(): string | undefined {\n    return this._dataSourceImpl.extractUpdateTime;\n  }\n\n  public get isExtract(): boolean {\n    return this._dataSourceImpl.isExtract;\n  }\n\n  public get isPublished(): boolean | undefined {\n    return this._dataSourceImpl.isPublished;\n  }\n\n  public publishedUrl(): string | undefined {\n    return this._dataSourceImpl.publishedUrl();\n  }\n\n  public refreshAsync(): Promise<void> {\n    return this._dataSourceImpl.refreshAsync();\n  }\n\n  public getActiveTablesAsync(): Promise<Array<Contract.TableSummary>> {\n    console.warn('DataSource.getActiveTablesAsync is deprecated. Please use DataSource.getLogicalTablesAsync.');\n    return this._dataSourceImpl.getActiveTablesAsync();\n  }\n\n  public getConnectionSummariesAsync(): Promise<Array<Contract.ConnectionSummary>> {\n    return this._dataSourceImpl.getConnectionSummariesAsync();\n  }\n\n  public getUnderlyingDataAsync(options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    console.warn(\n      'DataSource.getUnderlyingDataAsync is deprecated. Please use ' +\n        'DataSource.getLogicalTablesAsync and DataSource.getLogicalTableDataAsync.',\n    );\n    return this._dataSourceImpl.getUnderlyingDataAsync(options);\n  }\n\n  public getLogicalTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    return this._dataSourceImpl.getLogicalTablesAsync();\n  }\n\n  public getLogicalTableDataAsync(logicalTableId: string, options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    return this._dataSourceImpl.getLogicalTableDataAsync(logicalTableId, options);\n  }\n\n  public getLogicalTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount?: number,\n    options?: Contract.DataSourceUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    return this._dataSourceImpl.getLogicalTableDataReaderAsync(logicalTableId, pageRowCount, options);\n  }\n}\n","import {\n  DateRangeType as ExternalDateRangeType,\n  DialogStyle as ExternalDialogStyle,\n  FilterDomainType as ExternalDomainType,\n  FilterNullOption as ExternalNullOption,\n  FilterUpdateType as ExternalFilterUpdateType,\n  IncludeDataValuesOption,\n  PeriodType,\n  ReplaySpeedType,\n  SheetType as ExternalSheetType,\n  ZoneVisibilityType,\n} from '@tableau/api-external-contract-js';\nimport {\n  ApiShowDataTableFormat,\n  DateRangeType as InternalDateRangeType,\n  DateStepPeriod,\n  DialogStyle as InternalDialogStyle,\n  FilterDomainType as InternalDomainType,\n  FilterNullOption as InternalNullOption,\n  FilterUpdateType as InternalFilterUpdateType,\n  SheetType as InternalSheetType,\n} from '@tableau/api-internal-contract-js';\nimport { EnumConverter } from '../Utils/EnumConverter';\n\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\n/**\n * Maps enums used by the external-api-contract to the enums used\n * in the internal-api-contract, which developers code against.\n */\nexport class ExternalToInternalEnumMappings {\n  public static filterDomainType = new EnumConverter<ExternalDomainType, InternalDomainType>({\n    [ExternalDomainType.Relevant]: InternalDomainType.Relevant,\n    [ExternalDomainType.Database]: InternalDomainType.Database,\n  });\n\n  public static nullOptions = new EnumConverter<ExternalNullOption, InternalNullOption>({\n    [ExternalNullOption.AllValues]: InternalNullOption.AllValues,\n    [ExternalNullOption.NonNullValues]: InternalNullOption.NonNullValues,\n    [ExternalNullOption.NullValues]: InternalNullOption.NullValues,\n  });\n\n  public static filterUpdateType = new EnumConverter<ExternalFilterUpdateType, InternalFilterUpdateType>({\n    [ExternalFilterUpdateType.Add]: InternalFilterUpdateType.Add,\n    [ExternalFilterUpdateType.All]: InternalFilterUpdateType.All,\n    [ExternalFilterUpdateType.Remove]: InternalFilterUpdateType.Remove,\n    [ExternalFilterUpdateType.Replace]: InternalFilterUpdateType.Replace,\n  });\n\n  public static setVisibilityType = new EnumConverter<ZoneVisibilityType, boolean>({\n    [ZoneVisibilityType.Show]: true,\n    [ZoneVisibilityType.Hide]: false,\n  });\n\n  public static setReplaySpeedType = new EnumConverter<ReplaySpeedType, number>({\n    // these numbers are duration multipliers\n    // 2.0, for example, doubles the duration of the replay, slowing it down to 0.5x speed\n    [ReplaySpeedType.Slow]: 2.0,\n    [ReplaySpeedType.Normal]: 1.0,\n    [ReplaySpeedType.Fast]: 0.5,\n  });\n\n  public static sheetType = new EnumConverter<ExternalSheetType, InternalSheetType>({\n    [ExternalSheetType.Dashboard]: InternalSheetType.Dashboard,\n    [ExternalSheetType.Worksheet]: InternalSheetType.Worksheet,\n    [ExternalSheetType.Story]: InternalSheetType.Story,\n  });\n\n  public static showDataTableFormatType = new EnumConverter<IncludeDataValuesOption, ApiShowDataTableFormat>({\n    [IncludeDataValuesOption.AllValues]: ApiShowDataTableFormat.NativeAndFormattedValues,\n    [IncludeDataValuesOption.OnlyNativeValues]: ApiShowDataTableFormat.NativeValuesOnly,\n    [IncludeDataValuesOption.OnlyFormattedValues]: ApiShowDataTableFormat.FormattedValuesOnly,\n  });\n\n  public static periodType = new EnumConverter<PeriodType, DateStepPeriod>({\n    [PeriodType.Years]: DateStepPeriod.Years,\n    [PeriodType.Quarters]: DateStepPeriod.Quarters,\n    [PeriodType.Months]: DateStepPeriod.Months,\n    [PeriodType.Weeks]: DateStepPeriod.Weeks,\n    [PeriodType.Days]: DateStepPeriod.Days,\n    [PeriodType.Hours]: DateStepPeriod.Hours,\n    [PeriodType.Minutes]: DateStepPeriod.Minutes,\n    [PeriodType.Seconds]: DateStepPeriod.Seconds,\n  });\n\n  public static dateRangeType = new EnumConverter<ExternalDateRangeType, InternalDateRangeType>({\n    [ExternalDateRangeType.Last]: InternalDateRangeType.Last,\n    [ExternalDateRangeType.LastN]: InternalDateRangeType.LastN,\n    [ExternalDateRangeType.Next]: InternalDateRangeType.Next,\n    [ExternalDateRangeType.NextN]: InternalDateRangeType.NextN,\n    [ExternalDateRangeType.Current]: InternalDateRangeType.Current,\n    [ExternalDateRangeType.ToDate]: InternalDateRangeType.ToDate,\n  });\n\n  public static dialogStyles = new EnumConverter<ExternalDialogStyle, InternalDialogStyle>({\n    [ExternalDialogStyle.Window]: InternalDialogStyle.Window,\n    [ExternalDialogStyle.Modal]: InternalDialogStyle.Modal,\n    [ExternalDialogStyle.Modeless]: InternalDialogStyle.Modeless,\n  });\n}\n/* tslint:enable:typedef */\n","import {\n  AnnotationType as ExternalAnnotationType,\n  ClassNameKey as ExternalClassNameKey,\n  ColumnType as ExternalColumnType,\n  DashboardObjectType as ExternalDashboardObjectType,\n  DataType as ExternalDataType,\n  PeriodType as ExternalDatePeriod,\n  DateRangeType as ExternalDateRangeType,\n  ErrorCodes as ExternalErrorCodes,\n  ExtensionContext as ExternalExtensionsContext,\n  ExtensionMode as ExternalExtensionsMode,\n  FieldAggregationType as ExternalFieldAggregationType,\n  FieldRoleType as ExternalFieldRoleType,\n  FilterType as ExternalFilterType,\n  FilterUpdateType as ExternalFilterUpdateType,\n  HierarchicalLevelSelectionState as ExternalHierarchicalLevelSelectionState,\n  MarkType as ExternalMarkType,\n  ParameterValueType as ExternalParameterValueType,\n  SheetType as ExternalSheetType,\n} from '@tableau/api-external-contract-js';\nimport {\n  AnnotateEnum as InternalAnnotationType,\n  ClassNameKey as InternalClassNameKey,\n  ColumnType as InternalColumnType,\n  DashboardObjectType as InternalDashboardObjectType,\n  DataType as InternalDataType,\n  DateRangeType as InternalDateRangeType,\n  DateStepPeriod as InternalDateStepPeriod,\n  DomainRestrictionType as InternalDomainRestrictionType,\n  ErrorCodes as InternalErrorCodes,\n  ExtensionContext as InternalExtensionsContext,\n  ExtensionMode as InternalExtensionsMode,\n  FieldAggregationType as InternalFieldAggregationType,\n  FieldRoleType as InternalFieldRoleType,\n  FilterType as InternalFilterType,\n  FilterUpdateType as InternalFilterUpdateType,\n  HierarchicalLevelSelectionState as InternalHierarchicalLevelSelectionState,\n  MarkType as InternalMarkType,\n  SheetType as InternalSheetType,\n} from '@tableau/api-internal-contract-js';\nimport { EnumConverter } from '../Utils/EnumConverter';\n\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\n/**\n * Maps enums used by the internal-api-contract to the enums used\n * in the external-api-contract, which developers code against.\n */\nexport class InternalToExternalEnumMappings {\n  public static extensionContext = new EnumConverter<InternalExtensionsContext, ExternalExtensionsContext>({\n    [InternalExtensionsContext.Desktop]: ExternalExtensionsContext.Desktop,\n    [InternalExtensionsContext.Server]: ExternalExtensionsContext.Server,\n  });\n\n  public static extensionMode = new EnumConverter<InternalExtensionsMode, ExternalExtensionsMode>({\n    [InternalExtensionsMode.Authoring]: ExternalExtensionsMode.Authoring,\n    [InternalExtensionsMode.Viewing]: ExternalExtensionsMode.Viewing,\n  });\n\n  public static columnType = new EnumConverter<InternalColumnType, ExternalColumnType>({\n    [InternalColumnType.Continuous]: ExternalColumnType.Continuous,\n    [InternalColumnType.Discrete]: ExternalColumnType.Discrete,\n    [InternalColumnType.Unknown]: ExternalColumnType.Unknown,\n  });\n\n  public static fieldAggregationType = new EnumConverter<InternalFieldAggregationType, ExternalFieldAggregationType>({\n    [InternalFieldAggregationType.Attr]: ExternalFieldAggregationType.Attr,\n    [InternalFieldAggregationType.Avg]: ExternalFieldAggregationType.Avg,\n    [InternalFieldAggregationType.Collect]: ExternalFieldAggregationType.Collect,\n    [InternalFieldAggregationType.Count]: ExternalFieldAggregationType.Count,\n    [InternalFieldAggregationType.Countd]: ExternalFieldAggregationType.Countd,\n    [InternalFieldAggregationType.Day]: ExternalFieldAggregationType.Day,\n    [InternalFieldAggregationType.End]: ExternalFieldAggregationType.End,\n    [InternalFieldAggregationType.Hour]: ExternalFieldAggregationType.Hour,\n    [InternalFieldAggregationType.InOut]: ExternalFieldAggregationType.InOut,\n    [InternalFieldAggregationType.Kurtosis]: ExternalFieldAggregationType.Kurtosis,\n    [InternalFieldAggregationType.Max]: ExternalFieldAggregationType.Max,\n    [InternalFieldAggregationType.Mdy]: ExternalFieldAggregationType.Mdy,\n    [InternalFieldAggregationType.Median]: ExternalFieldAggregationType.Median,\n    [InternalFieldAggregationType.Min]: ExternalFieldAggregationType.Min,\n    [InternalFieldAggregationType.Minute]: ExternalFieldAggregationType.Minute,\n    [InternalFieldAggregationType.MonthYear]: ExternalFieldAggregationType.MonthYear,\n    [InternalFieldAggregationType.None]: ExternalFieldAggregationType.None,\n    [InternalFieldAggregationType.Qtr]: ExternalFieldAggregationType.Qtr,\n    [InternalFieldAggregationType.Quart1]: ExternalFieldAggregationType.Quart1,\n    [InternalFieldAggregationType.Quart3]: ExternalFieldAggregationType.Quart3,\n    [InternalFieldAggregationType.Second]: ExternalFieldAggregationType.Second,\n    [InternalFieldAggregationType.Skewness]: ExternalFieldAggregationType.Skewness,\n    [InternalFieldAggregationType.Stdev]: ExternalFieldAggregationType.Stdev,\n    [InternalFieldAggregationType.Stdevp]: ExternalFieldAggregationType.Stdevp,\n    [InternalFieldAggregationType.Sum]: ExternalFieldAggregationType.Sum,\n    [InternalFieldAggregationType.TruncDay]: ExternalFieldAggregationType.TruncDay,\n    [InternalFieldAggregationType.TruncHour]: ExternalFieldAggregationType.TruncHour,\n    [InternalFieldAggregationType.TruncMinute]: ExternalFieldAggregationType.TruncMinute,\n    [InternalFieldAggregationType.TruncMonth]: ExternalFieldAggregationType.TruncMonth,\n    [InternalFieldAggregationType.TruncQtr]: ExternalFieldAggregationType.TruncQtr,\n    [InternalFieldAggregationType.TruncSecond]: ExternalFieldAggregationType.TruncSecond,\n    [InternalFieldAggregationType.TruncWeek]: ExternalFieldAggregationType.TruncWeek,\n    [InternalFieldAggregationType.TruncYear]: ExternalFieldAggregationType.TruncYear,\n    [InternalFieldAggregationType.User]: ExternalFieldAggregationType.User,\n    [InternalFieldAggregationType.Var]: ExternalFieldAggregationType.Var,\n    [InternalFieldAggregationType.Varp]: ExternalFieldAggregationType.Varp,\n    [InternalFieldAggregationType.Week]: ExternalFieldAggregationType.Week,\n    [InternalFieldAggregationType.Weekday]: ExternalFieldAggregationType.Weekday,\n    [InternalFieldAggregationType.Year]: ExternalFieldAggregationType.Year,\n  });\n\n  public static fieldRoleType = new EnumConverter<InternalFieldRoleType, ExternalFieldRoleType>({\n    [InternalFieldRoleType.Dimension]: ExternalFieldRoleType.Dimension,\n    [InternalFieldRoleType.Measure]: ExternalFieldRoleType.Measure,\n    [InternalFieldRoleType.Unknown]: ExternalFieldRoleType.Unknown,\n  });\n\n  public static sheetType = new EnumConverter<InternalSheetType, ExternalSheetType>({\n    [InternalSheetType.Dashboard]: ExternalSheetType.Dashboard,\n    [InternalSheetType.Story]: ExternalSheetType.Story,\n    [InternalSheetType.Worksheet]: ExternalSheetType.Worksheet,\n  });\n\n  public static dashboardObjectType = new EnumConverter<InternalDashboardObjectType, ExternalDashboardObjectType>({\n    [InternalDashboardObjectType.Extension]: ExternalDashboardObjectType.Extension,\n    [InternalDashboardObjectType.Blank]: ExternalDashboardObjectType.Blank,\n    [InternalDashboardObjectType.Image]: ExternalDashboardObjectType.Image,\n    [InternalDashboardObjectType.Legend]: ExternalDashboardObjectType.Legend,\n    [InternalDashboardObjectType.PageFilter]: ExternalDashboardObjectType.PageFilter,\n    [InternalDashboardObjectType.ParameterControl]: ExternalDashboardObjectType.ParameterControl,\n    [InternalDashboardObjectType.QuickFilter]: ExternalDashboardObjectType.QuickFilter,\n    [InternalDashboardObjectType.Text]: ExternalDashboardObjectType.Text,\n    [InternalDashboardObjectType.Title]: ExternalDashboardObjectType.Title,\n    [InternalDashboardObjectType.WebPage]: ExternalDashboardObjectType.WebPage,\n    [InternalDashboardObjectType.Worksheet]: ExternalDashboardObjectType.Worksheet,\n  });\n\n  public static dataType = new EnumConverter<InternalDataType, ExternalDataType>({\n    [InternalDataType.Bool]: ExternalDataType.Bool,\n    [InternalDataType.Date]: ExternalDataType.Date,\n    [InternalDataType.DateTime]: ExternalDataType.DateTime,\n    [InternalDataType.Float]: ExternalDataType.Float,\n    [InternalDataType.Int]: ExternalDataType.Int,\n    [InternalDataType.Spatial]: ExternalDataType.Spatial,\n    [InternalDataType.String]: ExternalDataType.String,\n  });\n\n  public static filterUpdateType = new EnumConverter<InternalFilterUpdateType, ExternalFilterUpdateType>({\n    [InternalFilterUpdateType.Add]: ExternalFilterUpdateType.Add,\n    [InternalFilterUpdateType.All]: ExternalFilterUpdateType.All,\n    [InternalFilterUpdateType.Remove]: ExternalFilterUpdateType.Remove,\n    [InternalFilterUpdateType.Replace]: ExternalFilterUpdateType.Replace,\n  });\n\n  public static allowableValues = new EnumConverter<InternalDomainRestrictionType, ExternalParameterValueType>({\n    [InternalDomainRestrictionType.All]: ExternalParameterValueType.All,\n    [InternalDomainRestrictionType.List]: ExternalParameterValueType.List,\n    [InternalDomainRestrictionType.Range]: ExternalParameterValueType.Range,\n  });\n\n  public static dateStepPeriod = new EnumConverter<InternalDateStepPeriod, ExternalDatePeriod>({\n    [InternalDateStepPeriod.Years]: ExternalDatePeriod.Years,\n    [InternalDateStepPeriod.Quarters]: ExternalDatePeriod.Quarters,\n    [InternalDateStepPeriod.Months]: ExternalDatePeriod.Months,\n    [InternalDateStepPeriod.Weeks]: ExternalDatePeriod.Weeks,\n    [InternalDateStepPeriod.Days]: ExternalDatePeriod.Days,\n    [InternalDateStepPeriod.Hours]: ExternalDatePeriod.Hours,\n    [InternalDateStepPeriod.Minutes]: ExternalDatePeriod.Minutes,\n    [InternalDateStepPeriod.Seconds]: ExternalDatePeriod.Seconds,\n  });\n\n  public static dateRangeType = new EnumConverter<InternalDateRangeType, ExternalDateRangeType>({\n    [InternalDateRangeType.Current]: ExternalDateRangeType.Current,\n    [InternalDateRangeType.Last]: ExternalDateRangeType.Last,\n    [InternalDateRangeType.LastN]: ExternalDateRangeType.LastN,\n    [InternalDateRangeType.Next]: ExternalDateRangeType.Next,\n    [InternalDateRangeType.NextN]: ExternalDateRangeType.NextN,\n    [InternalDateRangeType.ToDate]: ExternalDateRangeType.ToDate,\n  });\n\n  public static errorCode = new EnumConverter<InternalErrorCodes, ExternalErrorCodes>(\n    {\n      [InternalErrorCodes.INITIALIZATION_ERROR]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.INTERNAL_ERROR]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.MISSING_ENUM_MAPPING]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.MISSING_PARAMETER]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.PERMISSION_DENIED]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.PRES_MODEL_PARSING_ERROR]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.UNKNOWN_VERB_ID]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.VERSION_NOT_CONFIGURED]: ExternalErrorCodes.APINotInitialized,\n      [InternalErrorCodes.VISIBILITY_ERROR]: ExternalErrorCodes.VisibilityError,\n    },\n    ExternalErrorCodes.InternalError,\n  );\n\n  public static filterType = new EnumConverter<InternalFilterType, ExternalFilterType>({\n    [InternalFilterType.Categorical]: ExternalFilterType.Categorical,\n    [InternalFilterType.Range]: ExternalFilterType.Range,\n    [InternalFilterType.RelativeDate]: ExternalFilterType.RelativeDate,\n    [InternalFilterType.Hierarchical]: ExternalFilterType.Hierarchical,\n  });\n\n  public static classNameKey = new EnumConverter<InternalClassNameKey, ExternalClassNameKey>({\n    [InternalClassNameKey.DashboardTitle]: ExternalClassNameKey.DashboardTitle,\n    [InternalClassNameKey.StoryTitle]: ExternalClassNameKey.StoryTitle,\n    [InternalClassNameKey.Tooltip]: ExternalClassNameKey.Tooltip,\n    [InternalClassNameKey.Worksheet]: ExternalClassNameKey.Worksheet,\n    [InternalClassNameKey.WorksheetTitle]: ExternalClassNameKey.WorksheetTitle,\n    // Temporary until we fix 1317266 - Platform hasn't been updated currently because near branch is closed\n    ['dashboard-title']: ExternalClassNameKey.DashboardTitle,\n    ['story-title']: ExternalClassNameKey.StoryTitle,\n    ['tooltip']: ExternalClassNameKey.Tooltip,\n    ['worksheet']: ExternalClassNameKey.Worksheet,\n    ['worksheet-title']: ExternalClassNameKey.WorksheetTitle,\n  });\n\n  public static hierarchicalLevelSelectionState = new EnumConverter<\n    InternalHierarchicalLevelSelectionState,\n    ExternalHierarchicalLevelSelectionState\n  >({\n    [InternalHierarchicalLevelSelectionState.AllSelected]: ExternalHierarchicalLevelSelectionState.AllSelected,\n    [InternalHierarchicalLevelSelectionState.NoneSelected]: ExternalHierarchicalLevelSelectionState.NoneSelected,\n    [InternalHierarchicalLevelSelectionState.SomeSelected]: ExternalHierarchicalLevelSelectionState.SomeSelected,\n    [InternalHierarchicalLevelSelectionState.UnknownSelected]: ExternalHierarchicalLevelSelectionState.UnknownSelected,\n  });\n\n  public static annotationType = new EnumConverter<InternalAnnotationType, ExternalAnnotationType>({\n    [InternalAnnotationType.Area]: ExternalAnnotationType.Area,\n    [InternalAnnotationType.Mark]: ExternalAnnotationType.Mark,\n    [InternalAnnotationType.Point]: ExternalAnnotationType.Point,\n  });\n\n  public static markType = new EnumConverter<InternalMarkType, ExternalMarkType>({\n    [InternalMarkType.Area]: ExternalMarkType.Area,\n    [InternalMarkType.Bar]: ExternalMarkType.Bar,\n    [InternalMarkType.Circle]: ExternalMarkType.Circle,\n    [InternalMarkType.GanttBar]: ExternalMarkType.GanttBar,\n    [InternalMarkType.Heatmap]: ExternalMarkType.Heatmap,\n    [InternalMarkType.Line]: ExternalMarkType.Line,\n    [InternalMarkType.Map]: ExternalMarkType.Map,\n    [InternalMarkType.Pie]: ExternalMarkType.Pie,\n    [InternalMarkType.Polygon]: ExternalMarkType.Polygon,\n    [InternalMarkType.Shape]: ExternalMarkType.Shape,\n    [InternalMarkType.Square]: ExternalMarkType.Square,\n    [InternalMarkType.Text]: ExternalMarkType.Text,\n    [InternalMarkType.VizExtension]: ExternalMarkType.VizExtension,\n  });\n}\n/* tslint:enable:typedef */\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, TableauEventType } from '@tableau/api-external-contract-js';\nimport { SingleEventManager } from './SingleEventManager';\nimport { TableauError } from './TableauError';\n\n/**\n * Class designed to register and unregister handlers from a user. Only those events\n * which are added via AddNewEventType will be supported by this instance\n */\nexport class EventListenerManager implements Contract.EventListenerManager {\n  private _eventListenerManagers: { [tableauEventType: string]: SingleEventManager };\n\n  public constructor() {\n    this._eventListenerManagers = {};\n  }\n\n  public addEventListener(eventType: TableauEventType, handler: Contract.TableauEventHandlerFn): Contract.TableauEventUnregisterFn {\n    if (!this._eventListenerManagers.hasOwnProperty(eventType)) {\n      throw new TableauError(ErrorCodes.UnsupportedEventName, `Cannot add event, unsupported event type: ${eventType}`);\n    }\n\n    return this._eventListenerManagers[eventType].addEventListener(handler);\n  }\n\n  public removeEventListener(eventType: TableauEventType, handler: Contract.TableauEventHandlerFn): boolean {\n    if (!this._eventListenerManagers.hasOwnProperty(eventType)) {\n      throw new TableauError(ErrorCodes.UnsupportedEventName, `Cannot remove event, unsupported event type: ${eventType}`);\n    }\n\n    return this._eventListenerManagers[eventType].removeEventListener(handler);\n  }\n\n  protected addNewEventType(eventManager: SingleEventManager): void {\n    this._eventListenerManagers[eventManager.eventType] = eventManager;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ColumnType, DataType, FieldAggregationType, FieldRoleType } from '@tableau/api-external-contract-js';\nimport { FieldImpl } from './Impl/FieldImpl';\n\nexport class Field implements Contract.Field {\n  public constructor(private _fieldImpl: FieldImpl) {}\n\n  public get name(): string {\n    return this._fieldImpl.name;\n  }\n\n  public get id(): string {\n    return this._fieldImpl.id;\n  }\n\n  public get description(): string | undefined {\n    return this._fieldImpl.description;\n  }\n\n  public get dataType(): DataType {\n    return this._fieldImpl.dataType;\n  }\n\n  public get aggregation(): FieldAggregationType {\n    return this._fieldImpl.aggregation;\n  }\n\n  public get dataSource(): Contract.DataSource {\n    return this._fieldImpl.dataSource;\n  }\n\n  public get role(): FieldRoleType {\n    return this._fieldImpl.role;\n  }\n\n  public get columnType(): ColumnType {\n    return this._fieldImpl.columnType;\n  }\n\n  public get isCalculatedField(): boolean {\n    return this._fieldImpl.isCalculatedField;\n  }\n\n  public get isCombinedField(): boolean {\n    return this._fieldImpl.isCombinedField;\n  }\n\n  public get isGenerated(): boolean {\n    return this._fieldImpl.isGenerated;\n  }\n\n  public get isGeospatial(): boolean {\n    return this._fieldImpl.isGeospatial;\n  }\n\n  public get isHidden(): boolean {\n    return this._fieldImpl.isHidden;\n  }\n\n  public get isPresentOnPublishedDatasource(): boolean {\n    return this._fieldImpl.isPresentOnPublishedDatasource;\n  }\n}\n","import { CustomViewModel } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, ServiceNames, VizService } from '../../ApiShared';\nexport class CustomViewImpl {\n  private _luid: string;\n  private _name: string;\n  private _shared: boolean;\n  private _isDefault: boolean;\n  private _ownerName: string;\n  private _url: string;\n  public constructor(customViewModel: CustomViewModel, private _registryId: number) {\n    this._luid = customViewModel.luid;\n    this._name = customViewModel.name;\n    this._shared = customViewModel.shared;\n    this._isDefault = customViewModel.isDefault;\n    this._ownerName = customViewModel.owner.userFriendlyName;\n    this._url = customViewModel.url;\n  }\n\n  public get luid() {\n    return this._luid;\n  }\n\n  public get name() {\n    return this._name;\n  }\n\n  public set name(name: string) {\n    this._name = name;\n  }\n\n  public get shared() {\n    return this._shared;\n  }\n\n  public set shared(shared: boolean) {\n    this._shared = shared;\n  }\n\n  public get isDefault() {\n    return this._isDefault;\n  }\n\n  public set isDefault(isDefault: boolean) {\n    this._isDefault = isDefault;\n  }\n\n  public get ownerName() {\n    return this._ownerName;\n  }\n\n  public get url() {\n    return this._url;\n  }\n\n  public saveAsync(): Promise<CustomViewImpl> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<VizService>(ServiceNames.Viz);\n    return service.saveAsync(this);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  DashboardLayoutChange,\n  DashboardLayoutChangeDetails,\n  ErrorCodes,\n  SharedErrorCodes,\n  SheetType,\n} from '@tableau/api-external-contract-js';\nimport { DashboardObjectType, DashboardZone, SheetPath, VisualId } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\nimport { Point } from '../Point';\nimport { AnimationService } from '../Services/AnimationService';\nimport { FilterService } from '../Services/FilterService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { ZoneService } from '../Services/ZoneService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { DashboardObjectImpl } from './DashboardObjectImpl';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryPointImpl } from './StoryPointImpl';\nimport { WorksheetImpl } from './WorksheetImpl';\n\nexport class DashboardImpl extends SheetImpl {\n  private _worksheetsImpl: Array<WorksheetImpl>;\n  private _objects: Array<DashboardObjectImpl>;\n  private zoneMap: Map<number, DashboardObjectImpl>;\n\n  public constructor(\n    _sheetInfo: SheetInfoImpl,\n    private _zones: Array<DashboardZone>,\n    private _sheetPath: SheetPath,\n    _registryId: number,\n    private _parentStoryPointImpl: StoryPointImpl | null,\n    private _activeDashboardObjectId: number = 0,\n  ) {\n    super(_sheetInfo, _registryId);\n  }\n\n  public get worksheetsImpl(): Array<WorksheetImpl> {\n    return this._worksheetsImpl;\n  }\n\n  public get objects(): Array<DashboardObjectImpl> {\n    return this._objects;\n  }\n\n  public get parentStoryPoint(): StoryPointImpl | null {\n    return this._parentStoryPointImpl;\n  }\n\n  public get activeDashboardObjectId(): number {\n    return this._activeDashboardObjectId;\n  }\n\n  public get activeDashboardName(): string {\n    return this._sheetPath.sheetName;\n  }\n\n  public initializeWithPublicInterfaces(): void {\n    this._worksheetsImpl = new Array<WorksheetImpl>();\n    this._objects = new Array<DashboardObjectImpl>();\n    this.zoneMap = new Map<number, DashboardObjectImpl>();\n\n    // Process all the zones which are contained in this dashboard\n    for (const zone of this._zones) {\n      let worksheetImpl: WorksheetImpl | undefined = undefined;\n\n      const zoneSize: Contract.Size = { width: zone.width, height: zone.height };\n      // As the dashboard is active, all other zones in the dashboard are inactive.\n      const isActive = false;\n\n      if (zone.zoneType === DashboardObjectType.Worksheet || zone.zoneType === DashboardObjectType.QuickFilter) {\n        let worksheetName = '';\n        let worksheetUrl = '';\n        let isHidden = false;\n        if (zone.sheetInfo) {\n          // zone.sheetInfo was not initialized prior to internal-contract 1.6.0\n          worksheetName = zone.sheetInfo.name;\n\n          // worksheetUrl & isHidden is for Embedding only\n          worksheetUrl = zone.sheetInfo.url || '';\n          // If there's a url, then it's not hidden\n          isHidden = worksheetUrl === '';\n        } else {\n          worksheetName = zone.name;\n        }\n        // Indexes, isActive and some more properties in sheetInfoImpl are embedding specific.\n        // But we init them for both extensions and embedding as the Models will only use what is relevant.\n        const sheetInfoImpl = new SheetInfoImpl(\n          worksheetName,\n          SheetType.Worksheet,\n          zoneSize,\n          this._worksheetsImpl.length,\n          isActive,\n          isHidden,\n          worksheetUrl,\n        );\n\n        const vizId: VisualId = {\n          worksheet: worksheetName,\n          dashboard: this._sheetInfoImpl.name,\n          storyboard: this._sheetPath.storyboard,\n          flipboardZoneID: this._sheetPath.flipboardZoneID,\n          storyPointID: this._sheetPath.storyPointID,\n        };\n\n        worksheetImpl = new WorksheetImpl(sheetInfoImpl, this._registryId, vizId, this, this._parentStoryPointImpl);\n        if (zone.zoneType === DashboardObjectType.Worksheet) {\n          this._worksheetsImpl.push(worksheetImpl);\n        }\n      }\n\n      const zonePoint = new Point(zone.x, zone.y);\n\n      const dashboardObjectImpl = new DashboardObjectImpl(\n        this,\n        InternalToExternalEnumMappings.dashboardObjectType.convert(zone.zoneType),\n        zonePoint,\n        zoneSize,\n        worksheetImpl,\n        zone.name,\n        zone.isFloating !== undefined ? zone.isFloating : false, // before 1.6.0 we didn't have isFloating, so we assume false\n        zone.isVisible !== undefined ? zone.isVisible : true, // before 1.6.0 we didn't have isVisible, so we assume true\n        zone.zoneId,\n        zone.fieldId,\n      );\n\n      this._objects.push(dashboardObjectImpl);\n      this.zoneMap.set(zone.zoneId, dashboardObjectImpl);\n    }\n  }\n\n  public setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap: Contract.DashboardObjectVisibilityMap | object): Promise<void> {\n    const zoneService = ApiServiceRegistry.get(this._registryId).getService<ZoneService>(ServiceNames.Zone);\n\n    return zoneService.setVisibilityAsync(/*Dashboard Name*/ this.name, this.zoneMap, dashboardObjectVisibilityMap);\n  }\n\n  public getDashboardObjectById(dashboardObjectId: number): DashboardObjectImpl | undefined {\n    return this.zoneMap.get(dashboardObjectId);\n  }\n\n  public updateZones(newZones: Array<DashboardZone>, newActiveZoneId = 0, newActiveDashboardName = ''): DashboardLayoutChangeDetails {\n    // getting previous dashboard objects, active zone ID and active dashboard name\n    const oldDashboardObjects = this._objects;\n    const oldZoneMap = this.zoneMap;\n    const oldActiveZoneId = this._activeDashboardObjectId;\n    const oldActiveDashboardName = this._sheetPath.sheetName;\n    // updating zones and reinitializing instance variables\n    this._zones = newZones;\n    this._activeDashboardObjectId = newActiveZoneId;\n    this._sheetPath.sheetName = newActiveDashboardName;\n    this._sheetInfoImpl.name = newActiveDashboardName;\n    this.initializeWithPublicInterfaces();\n    // getting new dashboard objects\n    const newDashboardObjects = this._objects;\n    const newZoneMap = this.zoneMap;\n    // initializing map for changes\n    const zoneChanges: DashboardLayoutChangeDetails = new Map();\n\n    // comparing old dashboard objects with new ones\n    oldDashboardObjects.forEach((oldObject) => {\n      const oldId: number = oldObject.id;\n\n      // checking if zone was removed\n      if (!newZoneMap.has(oldId)) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.Removed);\n        return;\n      }\n\n      const newObject = newZoneMap.get(oldId);\n      if (oldObject.isFloating !== newObject!.isFloating) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.IsFloatingChanged);\n      }\n\n      if (oldObject.isVisible !== newObject!.isVisible) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.IsVisibleChanged);\n      }\n\n      if (oldObject.name !== newObject!.name) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.NameChanged);\n      }\n\n      if (oldObject.position.x !== newObject!.position.x || oldObject.position.y !== newObject!.position.y) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.PositionChanged);\n      }\n\n      if (oldObject.size.width !== newObject!.size.width || oldObject.size.height !== newObject!.size.height) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.SizeChanged);\n      }\n    });\n\n    // Checking for any added zones\n    newDashboardObjects.forEach((newObject) => {\n      if (!oldZoneMap.has(newObject.id)) {\n        this.addChange(newObject.id, zoneChanges, DashboardLayoutChange.Added);\n      }\n    });\n\n    // Checking if zone selection has changed\n    if (oldActiveZoneId !== newActiveZoneId) {\n      if (newActiveZoneId !== 0) {\n        this.addChange(newActiveZoneId, zoneChanges, DashboardLayoutChange.Selected);\n      }\n      if (oldActiveZoneId !== 0) {\n        this.addChange(oldActiveZoneId, zoneChanges, DashboardLayoutChange.Deselected);\n      }\n    }\n\n    // Checking if switched to another dashboard\n    if (oldActiveDashboardName !== newActiveDashboardName) {\n      this.addChange(0, zoneChanges, DashboardLayoutChange.DashboardChanged);\n    }\n\n    return zoneChanges;\n  }\n\n  private addChange(zoneId: number, zoneChanges: DashboardLayoutChangeDetails, change: DashboardLayoutChange): void {\n    if (!zoneChanges.has(zoneId)) {\n      zoneChanges.set(zoneId, []);\n    }\n\n    zoneChanges.get(zoneId)!.push(change);\n  }\n\n  public moveAndResizeDashboardObjectsAsync(\n    dashboardObjectPositionAndSizeUpdateArray: Contract.DashboardObjectPositionAndSizeUpdateArray,\n  ): Promise<void> {\n    const zoneService = ApiServiceRegistry.get(this._registryId).getService<ZoneService>(ServiceNames.Zone);\n\n    return zoneService.moveAndResizeAsync(/*Dashboard Name*/ this.name, this.zoneMap, dashboardObjectPositionAndSizeUpdateArray);\n  }\n\n  public replayAnimationAsync(replaySpeed: Contract.ReplaySpeedType): Promise<void> {\n    const animationService = ApiServiceRegistry.get(this._registryId).getService<AnimationService>(ServiceNames.Animation);\n\n    return animationService.replayAsync(replaySpeed);\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    this.verifyActiveSheetOrEmbeddedInActiveStoryPoint();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getDashboardFiltersAsync();\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    ErrorHelpers.verifyEnumValue<Contract.FilterUpdateType>(updateType, Contract.FilterUpdateType, 'FilterUpdateType');\n    ErrorHelpers.verifyStringParameter(fieldName, 'fieldName');\n    if (!Array.isArray(values)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'values parameter for applyDashboardFilterAsync must be an array');\n    }\n    this.verifyActiveSheetOrEmbeddedInActiveStoryPoint();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyDashboardFilterAsync(fieldName, values, updateType, options);\n  }\n\n  // @W-12986439: remove once initializeWithPublicInterfaces is moved to the constructor for this class\n  // This method only exists since worksheetsImpl can be undefined, but we need the worksheet names in the Export APIs\n  public getWorksheetNamesFromZones(): Array<string> {\n    const worksheetNames: string[] = [];\n    for (const zone of this._zones) {\n      if (zone.zoneType !== DashboardObjectType.Worksheet) {\n        continue;\n      }\n      // zone.sheetInfo was not initialized prior to internal-contract 1.6.0\n      const worksheetName = zone.sheetInfo ? zone.sheetInfo.name : zone.name;\n      worksheetNames.push(worksheetName);\n    }\n\n    return worksheetNames;\n  }\n\n  private verifyActiveSheetOrEmbeddedInActiveStoryPoint() {\n    const isRootAndActiveDashboard = this.active;\n    const isWithinActiveStoryPoint = this.parentStoryPoint != null && this.parentStoryPoint.active;\n    if (!isRootAndActiveDashboard && !isWithinActiveStoryPoint) {\n      throw new TableauError(SharedErrorCodes.NotActiveSheet, 'Operation not allowed on non-active sheet');\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardObjectType } from '@tableau/api-external-contract-js';\nimport { DashboardImpl } from './DashboardImpl';\nimport { WorksheetImpl } from './WorksheetImpl';\n\n/**\n * Implementation of the dashboard objects - the zones in a dashboard.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class DashboardObjectImpl {\n  public constructor(\n    private _dashboardImpl: DashboardImpl,\n    private _type: DashboardObjectType,\n    private _position: Contract.Point,\n    private _size: Contract.Size,\n    private _worksheetImpl: WorksheetImpl | undefined,\n    private _name: string,\n    private _isFloating: boolean,\n    private _isVisible: boolean,\n    private _id: number,\n    private _fieldId: string | undefined,\n  ) {}\n\n  public get dashboardImpl(): DashboardImpl {\n    return this._dashboardImpl;\n  }\n\n  public get type(): DashboardObjectType {\n    return this._type;\n  }\n\n  public get position(): Contract.Point {\n    return this._position;\n  }\n\n  public get size(): Contract.Size {\n    return this._size;\n  }\n\n  public get worksheetImpl(): WorksheetImpl | undefined {\n    return this._worksheetImpl;\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get isFloating(): boolean {\n    return this._isFloating;\n  }\n\n  public get isVisible(): boolean {\n    return this._isVisible;\n  }\n\n  public get id(): number {\n    return this._id;\n  }\n\n  public get fieldId(): string | undefined {\n    return this._fieldId;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { IncludeDataValuesOption } from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport { ConnectionSummary } from '../ConnectionSummary';\nimport { Field } from '../Field';\nimport { LogicalTable } from '../LogicalTable';\nimport { DataSourceService } from '../Services/DataSourceService';\nimport { GetDataService } from '../Services/GetDataService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { TableSummary } from '../TableSummary';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { FieldImpl } from './FieldImpl';\n\nexport class DataSourceImpl {\n  private _fields: Array<Field>;\n\n  public constructor(private _dataSourceInfo: InternalContract.DataSource, private _registryId: number) {\n    this._fields = _dataSourceInfo.fields.map((fieldModel) => {\n      const fieldImpl = new FieldImpl(fieldModel, this);\n      return new Field(fieldImpl);\n    });\n  }\n\n  public get name(): string {\n    return this._dataSourceInfo.name;\n  }\n\n  public get id(): string {\n    return this._dataSourceInfo.id;\n  }\n\n  public get extractUpdateTime(): string | undefined {\n    return this._dataSourceInfo.extractUpdateTime;\n  }\n\n  public get fields(): Array<Contract.Field> {\n    return this._fields;\n  }\n\n  public get isExtract(): boolean {\n    return this._dataSourceInfo.isExtract;\n  }\n\n  public get isPublished(): boolean | undefined {\n    return this._dataSourceInfo.isPublished;\n  }\n\n  public publishedUrl(): string | undefined {\n    return this._dataSourceInfo.publishedUrl;\n  }\n\n  public getMaxPageRowLimit(): number {\n    return 10000;\n  }\n\n  public refreshAsync(): Promise<void> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.refreshAsync(this._dataSourceInfo.id);\n  }\n\n  public getConnectionSummariesAsync(): Promise<Contract.ConnectionSummary[]> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.getConnectionSummariesAsync(this._dataSourceInfo.id).then<Contract.ConnectionSummary[]>((summaries) => {\n      return summaries.map((summary) => new ConnectionSummary(summary));\n    });\n  }\n\n  public getActiveTablesAsync(): Promise<Array<Contract.TableSummary>> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.getActiveTablesAsync(this._dataSourceInfo.id).then<Array<Contract.TableSummary>>((tableInfos) => {\n      return tableInfos.map((tableInfo) => new TableSummary(tableInfo));\n    });\n  }\n\n  public getUnderlyingDataAsync(options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    const getDataService = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return getDataService.getDataSourceDataAsync(\n      this.id,\n      !!options.ignoreAliases,\n      options.maxRows || 0, // 0 and [] are defaults\n      options.columnsToInclude || [],\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getLogicalTableDataAsync(logicalTableId: string, options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    const getDataService = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return getDataService.getLogicalTableDataAsync(\n      this.id,\n      logicalTableId,\n      !!options.ignoreAliases,\n      options.maxRows || 0, // 0 and [] are defaults\n      options.columnsToInclude || [],\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getLogicalTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount?: number,\n    options?: Contract.DataSourceUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    const getDataService = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return getDataService.getLogicalTableDataReaderAsync(\n      this.id,\n      logicalTableId,\n      pageRowCount || this.getMaxPageRowLimit(),\n      !!options.ignoreAliases,\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public initializeWithPublicInterfaces(dataSource: Contract.DataSource): void {\n    ErrorHelpers.verifyInternalValue(dataSource, 'dataSource');\n\n    this._fields = this._dataSourceInfo.fields.map((fieldModel) => {\n      const fieldImpl = new FieldImpl(fieldModel, dataSource);\n      return new Field(fieldImpl);\n    });\n  }\n\n  public getLogicalTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.getLogicalTablesAsync(this.id).then<Array<Contract.LogicalTable>>((logicalTableInfos) => {\n      return logicalTableInfos.map((logicalTableInfo) => new LogicalTable(logicalTableInfo));\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\n\nexport class FieldImpl {\n  public constructor(private _fieldInfo: InternalContract.Field, private _parentDataSource?: Contract.DataSource) {}\n\n  public get name(): string {\n    return this._fieldInfo.name;\n  }\n\n  public get id(): string {\n    return this._fieldInfo.id;\n  }\n\n  public get description(): string | undefined {\n    return this._fieldInfo.description;\n  }\n\n  public get dataType(): Contract.DataType {\n    return this._fieldInfo.dataType ?? Contract.DataType.Unknown;\n  }\n\n  public get aggregation(): Contract.FieldAggregationType {\n    return InternalToExternalEnumMappings.fieldAggregationType.convert(this._fieldInfo.aggregation);\n  }\n\n  public get dataSource(): Contract.DataSource {\n    if (!this._parentDataSource)\n      throw new Error(\n        `Data source information is not available for this field. Please use getFieldAsync method to get field's data source information`,\n      );\n    return this._parentDataSource;\n  }\n\n  public get role(): Contract.FieldRoleType {\n    return InternalToExternalEnumMappings.fieldRoleType.convert(this._fieldInfo.role);\n  }\n\n  public get columnType(): Contract.ColumnType {\n    let definedValue: InternalContract.ColumnType = this._fieldInfo.columnType || InternalContract.ColumnType.Unknown;\n    return InternalToExternalEnumMappings.columnType.convert(definedValue);\n  }\n\n  public get isCalculatedField(): boolean {\n    return this._fieldInfo.isCalculatedField;\n  }\n\n  public get isCombinedField(): boolean {\n    return this._fieldInfo.isCombinedField;\n  }\n\n  public get isGenerated(): boolean {\n    return this._fieldInfo.isGenerated;\n  }\n\n  public get isGeospatial(): boolean {\n    return this._fieldInfo.isGeospatial;\n  }\n\n  public get isHidden(): boolean {\n    return this._fieldInfo.isHidden;\n  }\n\n  public get isPresentOnPublishedDatasource(): boolean {\n    return this._fieldInfo.isPresentOnPublishedDatasource;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataType, ParameterValueType, PeriodType } from '@tableau/api-external-contract-js';\nimport { ParameterInfo } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\nimport { DataValue } from '../Models/GetDataModels';\nimport { ParametersService } from '../Services/ParametersService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { DataValueFactory } from '../Utils/DataValueFactory';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { Param } from '../Utils/Param';\n\nexport class ParameterImpl {\n  private _allowableValues: Contract.ParameterDomainRestriction;\n  private _globalFieldName: string;\n  private _parameterInfo: ParameterInfo;\n\n  public constructor(parameterInfo: ParameterInfo, private _registryId: number) {\n    this.setParameterInfo(parameterInfo);\n  }\n\n  public get name(): string {\n    return this._parameterInfo.name;\n  }\n\n  public get currentValue(): DataValue {\n    return DataValueFactory.MakeParameterDataValue(this._parameterInfo.currentValue, this._parameterInfo.dataType);\n  }\n\n  public get dataType(): DataType {\n    return InternalToExternalEnumMappings.dataType.convert(this._parameterInfo.dataType);\n  }\n\n  public get id(): string {\n    return this._globalFieldName;\n  }\n\n  public get allowableValues(): Contract.ParameterDomainRestriction {\n    return this._allowableValues;\n  }\n\n  public changeValueAsync(newValue: string | number | boolean | Date): Promise<DataValue> {\n    ErrorHelpers.verifyParameter(newValue, 'newValue');\n\n    const coercedValue = Param.serializeParameterValue(newValue);\n    const parametersService = ApiServiceRegistry.get(this._registryId).getService<ParametersService>(ServiceNames.Parameters);\n    return parametersService.changeParameterValueAsync(this._globalFieldName, coercedValue).then((parameterInfo) => {\n      this.setParameterInfo(parameterInfo);\n      return this.currentValue;\n    });\n  }\n\n  private setParameterInfo(parameterInfo: ParameterInfo): void {\n    this._parameterInfo = parameterInfo;\n    this._globalFieldName = parameterInfo.fieldName;\n\n    const type = InternalToExternalEnumMappings.allowableValues.convert(parameterInfo.allowableValuesType);\n    let listValues: Array<DataValue> | undefined;\n    let minValue: DataValue | undefined;\n    let maxValue: DataValue | undefined;\n    let stepSize: number | undefined;\n    let dateStepPeriod: PeriodType | undefined;\n\n    if (type === ParameterValueType.List) {\n      const values = parameterInfo.allowableValues || [];\n      listValues = values.map((val) => DataValueFactory.MakeParameterDataValue(val, parameterInfo.dataType));\n    } else if (type === ParameterValueType.Range) {\n      minValue = parameterInfo.minValue && DataValueFactory.MakeParameterDataValue(parameterInfo.minValue, parameterInfo.dataType);\n      maxValue = parameterInfo.maxValue && DataValueFactory.MakeParameterDataValue(parameterInfo.maxValue, parameterInfo.dataType);\n      stepSize = parameterInfo.stepSize;\n      dateStepPeriod = parameterInfo.dateStepPeriod && InternalToExternalEnumMappings.dateStepPeriod.convert(parameterInfo.dateStepPeriod);\n    }\n\n    this._allowableValues = {\n      type: type,\n      allowableValues: listValues,\n      minValue: minValue,\n      maxValue: maxValue,\n      stepSize: stepSize,\n      dateStepPeriod: dateStepPeriod,\n    };\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { SheetPath } from '@tableau/api-internal-contract-js';\nimport { ClientInfoService } from '../Services/ClientInfoService';\nimport { ParametersService } from '../Services/ParametersService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { SizeService } from '../Services/SizeService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { Param } from '../Utils/Param';\nimport { SheetUtils } from '../Utils/SheetUtils';\nimport { ParameterImpl } from './ParameterImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\n\ninterface PartialSheetSize {\n  /**\n   * Contains an enumeration value of one of the following: AUTOMATIC, EXACTLY, RANGE, ATLEAST, and ATMOST.\n   */\n  readonly behavior: Contract.SheetSizeBehavior;\n\n  /**\n   *  This is only defined when behavior is EXACTLY, RANGE, or ATLEAST.\n   */\n  readonly minSize?: Partial<Contract.Size>;\n\n  /**\n   *  This is only defined when behavior is EXACTLY, RANGE or ATMOST.\n   */\n  readonly maxSize?: Partial<Contract.Size>;\n}\n\nexport class SheetImpl {\n  public constructor(protected _sheetInfoImpl: SheetInfoImpl, protected _registryId: number) {}\n\n  public get name(): string {\n    return this._sheetInfoImpl.name;\n  }\n\n  public get sheetType(): Contract.SheetType {\n    return this._sheetInfoImpl.sheetType;\n  }\n\n  public get sheetPath(): SheetPath {\n    return this._sheetInfoImpl.sheetPath;\n  }\n\n  public get size(): Contract.Size | Contract.SheetSize {\n    return this._sheetInfoImpl.sheetSize;\n  }\n\n  public get hidden(): boolean {\n    if (this._sheetInfoImpl.isHidden !== undefined) {\n      return this._sheetInfoImpl.isHidden;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `isHidden not implemented`);\n  }\n\n  public get active(): boolean {\n    if (this._sheetInfoImpl.isActive !== undefined) {\n      return this._sheetInfoImpl.isActive;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `active not implemented`);\n  }\n\n  public set active(active: boolean) {\n    if (this._sheetInfoImpl.isActive !== undefined) {\n      this._sheetInfoImpl.active = active;\n    }\n  }\n\n  public get index(): number {\n    if (this._sheetInfoImpl.index !== undefined) {\n      return this._sheetInfoImpl.index;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `index not implemented`);\n  }\n\n  public get url(): string {\n    if (this._sheetInfoImpl.url !== undefined) {\n      return this._sheetInfoImpl.url;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `url not implemented`);\n  }\n\n  private getSheetSize(): Contract.SheetSize {\n    if (!SheetUtils.isValidSheetSize(this.size)) {\n      throw new TableauError(Contract.EmbeddingErrorCodes.InternalError, 'size is not of type SheetSize');\n    }\n\n    return this.size;\n  }\n\n  public findParameterAsync(parameterName: string): Promise<ParameterImpl | undefined> {\n    ErrorHelpers.verifyParameter(parameterName, 'parameterName');\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ParametersService>(ServiceNames.Parameters);\n    return service.findParameterByNameAsync(parameterName);\n  }\n\n  public getParametersAsync(): Promise<Array<ParameterImpl>> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<ParametersService>(ServiceNames.Parameters);\n    return service.getParametersForSheetAsync(this.sheetPath);\n  }\n\n  public changeSizeAsync(newSize: Contract.SheetSize): Promise<Contract.SheetSize> {\n    const invalidSizeError = new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Invalid sheet size parameter');\n    if (!newSize || !newSize.behavior) {\n      throw invalidSizeError;\n    }\n\n    const partialSheetSize = this.normalizeSheetSize(newSize);\n\n    const isAutomatic = partialSheetSize.behavior === Contract.SheetSizeBehavior.Automatic;\n    if (!isAutomatic && !partialSheetSize.minSize && !partialSheetSize.maxSize) {\n      throw invalidSizeError;\n    }\n\n    if (!isAutomatic && this.sheetType === Contract.SheetType.Worksheet) {\n      throw new TableauError(\n        Contract.EmbeddingErrorCodes.InvalidSizeBehaviorOnWorksheet,\n        'Only SheetSizeBehavior.Automatic is allowed on Worksheets',\n      );\n    }\n\n    if (isAutomatic && this.getSheetSize().behavior === partialSheetSize.behavior) {\n      return Promise.resolve(newSize);\n    }\n\n    const processedNewSize = this.processNewSize(partialSheetSize);\n\n    const sizeService = ApiServiceRegistry.get(this._registryId).getService<SizeService>(ServiceNames.Size);\n    return sizeService.changeSizeAsync(this.name, processedNewSize).then(() => {\n      const clientInfoService = ApiServiceRegistry.get(this._registryId).getService<ClientInfoService>(ServiceNames.ClientInfo);\n\n      return clientInfoService.getClientInfoAsync().then((bootstrapInfo) => {\n        const sheet = bootstrapInfo.publishedSheets.find((s) => s.name === this.name);\n        if (!sheet) {\n          throw new TableauError(Contract.SharedErrorCodes.InternalError, `Can't find sheet with name ${this.name}`);\n        }\n\n        const sheetSize = SheetUtils.getSheetSizeFromSizeConstraints(sheet.sizeConstraint);\n        this._sheetInfoImpl.sheetSize = sheetSize;\n\n        return sheetSize;\n      });\n    });\n  }\n\n  private normalizeSheetSize(newSize: Contract.SheetSize): PartialSheetSize {\n    const { behavior } = newSize;\n\n    ErrorHelpers.verifyEnumValue<Contract.SheetSizeBehavior>(behavior, Contract.SheetSizeBehavior, 'SheetSizeBehavior');\n\n    const minSize = SheetImpl.parseDimensions(newSize.minSize);\n    const maxSize = SheetImpl.parseDimensions(newSize.maxSize);\n\n    return { behavior, minSize, maxSize };\n  }\n\n  private processNewSize(newSize: PartialSheetSize): Contract.SheetSize {\n    const { behavior, minSize: minSizeMaybe, maxSize: maxSizeMaybe } = newSize;\n\n    const hasMinWidth = !Param.isNullOrUndefined(minSizeMaybe?.width);\n    const hasMinHeight = !Param.isNullOrUndefined(minSizeMaybe?.height);\n    const hasMaxWidth = !Param.isNullOrUndefined(maxSizeMaybe?.width);\n    const hasMaxHeight = !Param.isNullOrUndefined(maxSizeMaybe?.height);\n    const hasValidMinSize = hasMinWidth && hasMinHeight;\n    const hasValidMaxSize = hasMaxWidth && hasMaxHeight;\n\n    switch (behavior) {\n      case Contract.SheetSizeBehavior.Automatic: {\n        return { behavior };\n      }\n\n      case Contract.SheetSizeBehavior.AtMost: {\n        if (!maxSizeMaybe || !hasValidMaxSize) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.MissingMaxSize, 'Missing maxSize for SheetSizeBehavior.AtMost');\n        }\n\n        const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n        if (maxSize.width < 0 || maxSize.height < 0) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Size value cannot be less than zero');\n        }\n\n        return { behavior, maxSize };\n      }\n\n      case Contract.SheetSizeBehavior.AtLeast: {\n        if (!minSizeMaybe || !hasValidMinSize) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.MissingMinSize, 'Missing minSize for SheetSizeBehavior.AtLeast');\n        }\n\n        const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n        if (minSize.width < 0 || minSize.height < 0) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Size value cannot be less than zero');\n        }\n\n        return { behavior, minSize };\n      }\n\n      case Contract.SheetSizeBehavior.Range: {\n        if (!minSizeMaybe || !maxSizeMaybe || !hasValidMinSize || !hasValidMaxSize) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.MissingMinMaxSize, 'Missing minSize or maxSize for SheetSizeBehavior.Range');\n        }\n\n        const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n        const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n\n        if (\n          minSize.width < 0 ||\n          minSize.height < 0 ||\n          maxSize.width < 0 ||\n          maxSize.height < 0 ||\n          minSize.width > maxSize.width ||\n          minSize.height > maxSize.height\n        ) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Missing minSize or maxSize for SheetSizeBehavior.Range');\n        }\n\n        return { behavior, minSize, maxSize };\n      }\n\n      case Contract.SheetSizeBehavior.Exactly: {\n        if (minSizeMaybe && maxSizeMaybe) {\n          if (hasValidMinSize && hasValidMaxSize) {\n            const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n            const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n\n            if (minSize.width !== maxSize.width || minSize.height !== maxSize.height) {\n              throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Conflicting size values for SheetSizeBehavior.Exactly');\n            }\n\n            return { behavior, minSize, maxSize };\n          }\n\n          if (hasValidMinSize) {\n            const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n            return { behavior, minSize, maxSize: minSize };\n          }\n\n          if (hasValidMaxSize) {\n            const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n            return { behavior, minSize: maxSize, maxSize };\n          }\n        }\n\n        throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Invalid sheet size parameter');\n      }\n\n      default: {\n        throw new TableauError(Contract.SharedErrorCodes.InternalError, `Unsupported sheet size behavior: ${behavior}`);\n      }\n    }\n  }\n\n  private static parseDimensions = (size: Contract.Size | undefined): Partial<Contract.Size> => {\n    const empty = { width: undefined, height: undefined };\n\n    if (!size) {\n      return empty;\n    }\n\n    const { success: widthParsed, parsed: parsedWidth } = Param.tryParseNumber(size.width);\n    const { success: heightParsed, parsed: parsedHeight } = Param.tryParseNumber(size.height);\n\n    if (widthParsed && heightParsed) {\n      return { width: parsedWidth!, height: parsedHeight! };\n    }\n\n    if (widthParsed) {\n      return { width: parsedWidth! };\n    }\n\n    if (heightParsed) {\n      return { height: parsedHeight! };\n    }\n\n    return empty;\n  };\n}\n","import { SheetSize as EmbeddingSheetSize, Size as ExtensionSheetSize, SheetType } from '@tableau/api-external-contract-js';\nimport { SheetPath } from '@tableau/api-internal-contract-js';\n\nexport class SheetInfoImpl {\n  public constructor(\n    private _name: string,\n    private _sheetType: SheetType,\n    private _sheetSize: ExtensionSheetSize | EmbeddingSheetSize,\n    private _index?: number,\n    private _isActive?: boolean,\n    private _isHidden?: boolean,\n    private _url?: string,\n  ) {}\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public set name(sheetName: string) {\n    this._name = sheetName;\n  }\n\n  public get sheetSize(): ExtensionSheetSize | EmbeddingSheetSize {\n    return this._sheetSize;\n  }\n\n  public set sheetSize(value: ExtensionSheetSize | EmbeddingSheetSize) {\n    this._sheetSize = value;\n  }\n\n  public get sheetType(): SheetType {\n    return this._sheetType;\n  }\n\n  public get sheetPath(): SheetPath {\n    return {\n      sheetName: this.name,\n      isDashboard: this.sheetType === SheetType.Dashboard,\n      // TODO - Stories\n    };\n  }\n\n  public get index(): number | undefined {\n    return this._index;\n  }\n\n  public get isActive(): boolean | undefined {\n    return this._isActive;\n  }\n\n  public set active(active: boolean) {\n    this._isActive = active;\n  }\n\n  public get isHidden(): boolean | undefined {\n    return this._isHidden;\n  }\n\n  public get url(): string | undefined {\n    return this._url;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { SingleEventManager } from '../SingleEventManager';\n\n/**\n * This class implements the SingleEventManager interface for a single type of Tableau event\n *\n * @template TEventType The Tableau event type this class specializes\n */\nexport class SingleEventManagerImpl<TEventType extends Contract.TableauEvent> implements SingleEventManager {\n  private _eventType: TableauEventType;\n  private _handlers: Array<(eventObj: TEventType) => void>;\n\n  public constructor(eventType: TableauEventType) {\n    this._eventType = eventType;\n    this._handlers = [];\n  }\n\n  public get eventType(): TableauEventType {\n    return this._eventType;\n  }\n\n  public addEventListener(handler: (eventObj: TEventType) => void): Contract.TableauEventUnregisterFn {\n    this._handlers.push(handler);\n    return () => this.removeEventListener(handler);\n  }\n\n  public removeEventListener(handler: (eventObj: TEventType) => void): boolean {\n    const beforeCount = this._handlers.length;\n    this._handlers = this._handlers.filter((h) => h !== handler);\n    return beforeCount > this._handlers.length;\n  }\n\n  public triggerEvent(eventGenerator: () => TEventType): void {\n    for (const handler of this._handlers) {\n      try {\n        const eventModel = eventGenerator();\n        handler(eventModel);\n      } catch (e) {\n        // Since this handler could be outside our control, just catch anything it throws and continue on\n        continue;\n      }\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { SheetInfo, StoryModel, StoryPointModel } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { StoryActivationService } from '../Services/StoryActivationService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { ShortLivedDeferred } from '../Utils/ShortLivedDeferred';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryPointImpl } from './StoryPointImpl';\nimport { StoryPointInfoImpl } from './StoryPointInfoImpl';\n\nexport class StoryImpl extends SheetImpl {\n  private _activeStoryPointImpl: StoryPointImpl;\n  private _storyPointInfoImpls: Array<StoryPointInfoImpl> = [];\n  private _deferred: ShortLivedDeferred<StoryPointImpl>;\n\n  public constructor(\n    protected _sheetInfoImpl: SheetInfoImpl,\n    storyModel: StoryModel,\n    private _publishedSheetInfos: Array<SheetInfo>,\n    protected _registryId: number,\n  ) {\n    super(_sheetInfoImpl, _registryId);\n    this._deferred = new ShortLivedDeferred<StoryPointImpl>();\n    this.initializeStory(storyModel);\n  }\n\n  private initializeStory(storyModel: StoryModel) {\n    storyModel.storyPoints.forEach((storyPointModel) => {\n      const isActive = storyPointModel.index === storyModel.activeStoryPointIndex;\n      const storyPointInfoImpl = new StoryPointInfoImpl(\n        storyPointModel.caption,\n        storyPointModel.index,\n        storyPointModel.storyPointId,\n        isActive,\n        storyPointModel.updated,\n        this,\n      );\n      this._storyPointInfoImpls.push(storyPointInfoImpl);\n\n      if (isActive) {\n        this._activeStoryPointImpl = new StoryPointImpl(\n          storyPointInfoImpl,\n          this._publishedSheetInfos,\n          this._registryId,\n          storyPointModel.containedSheetInfo,\n        );\n      }\n    });\n  }\n\n  private updateStoryInfo(index: number, storyPointModel: StoryPointModel) {\n    if (!this._storyPointInfoImpls) {\n      return;\n    }\n\n    let storyInfoImpl = this._storyPointInfoImpls[index];\n    if (storyInfoImpl.storyPointId !== storyPointModel.storyPointId) {\n      throw new TableauError(\n        Contract.EmbeddingErrorCodes.StoryPointIdMismatch,\n        `We should not be updating a story point when the IDs don't match. Existing storyPointID=${storyInfoImpl.storyPointId}, newStoryPointID=${storyPointModel.storyPointId}`,\n      );\n    }\n    storyInfoImpl.caption = storyPointModel.caption;\n    storyInfoImpl.updated = storyPointModel.updated;\n\n    if (this._activeStoryPointImpl.storyPointId === storyPointModel.storyPointId) {\n      this._activeStoryPointImpl.updated = storyInfoImpl.updated;\n    }\n  }\n\n  public updateStory(storyPointModel: StoryPointModel) {\n    if (!this._storyPointInfoImpls) {\n      return;\n    }\n\n    this._storyPointInfoImpls.forEach((storyPointInfoImpl) => {\n      const isActive = storyPointInfoImpl.storyPointId === storyPointModel.storyPointId;\n      if (isActive) {\n        // update the state\n        storyPointInfoImpl.caption = storyPointModel.caption;\n        storyPointInfoImpl.index = storyPointModel.index;\n        storyPointInfoImpl.active = true;\n        storyPointInfoImpl.updated = storyPointModel.updated;\n\n        // re-initialize activeStoryPointImpl\n        this._activeStoryPointImpl = new StoryPointImpl(\n          storyPointInfoImpl,\n          this._publishedSheetInfos,\n          this._registryId,\n          storyPointModel.containedSheetInfo,\n        );\n      } else {\n        // set old ones to false\n        storyPointInfoImpl.active = false;\n      }\n    });\n\n    if (this.activeStoryPoint) {\n      this._deferred.resolve(this.activeStoryPoint);\n    }\n  }\n\n  public get activeStoryPoint(): StoryPointImpl | undefined {\n    return this._activeStoryPointImpl;\n  }\n\n  public get storyPointsInfo(): Array<StoryPointInfoImpl> {\n    return this._storyPointInfoImpls;\n  }\n\n  public get isActive(): boolean {\n    return this._sheetInfoImpl.active;\n  }\n\n  public get isHidden(): boolean {\n    return !!this._sheetInfoImpl.isHidden;\n  }\n\n  public activateNextStoryPointAsync(): Promise<StoryPointImpl> {\n    if (this._activeStoryPointImpl.index === this._storyPointInfoImpls.length - 1) {\n      return Promise.resolve(this._activeStoryPointImpl);\n    }\n\n    let promise = this._deferred.getNewPromiseOrThrowIfBusy();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n    service.activateNextStoryPointAsync();\n    return promise;\n  }\n\n  public activatePreviousStoryPointAsync(): Promise<StoryPointImpl> {\n    if (this._activeStoryPointImpl.index === 0) {\n      return Promise.resolve(this._activeStoryPointImpl);\n    }\n\n    let promise = this._deferred.getNewPromiseOrThrowIfBusy();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n    service.activatePreviousStoryPointAsync();\n    return promise;\n  }\n\n  public activateStoryPointAsync(index: number): Promise<StoryPointImpl> {\n    ErrorHelpers.verifyParameter(index, 'index');\n    ErrorHelpers.verifyParameterType(index, 'number', 'index');\n\n    if (index < 0 || index >= this._storyPointInfoImpls.length) {\n      throw new TableauError(Contract.EmbeddingErrorCodes.IndexOutOfRange, 'The index passed to this command is out of range.');\n    }\n\n    if (index === this._activeStoryPointImpl.index) {\n      return Promise.resolve(this._activeStoryPointImpl);\n    }\n\n    let promise = this._deferred.getNewPromiseOrThrowIfBusy();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n    service.activateStoryPointAsync(index);\n    return promise;\n  }\n\n  public revertStoryPointAsync(index: number): Promise<StoryPointInfoImpl> {\n    ErrorHelpers.verifyParameter(index, 'index');\n    ErrorHelpers.verifyParameterType(index, 'number', 'index');\n\n    if (index < 0 || index >= this._storyPointInfoImpls.length) {\n      throw new TableauError(Contract.EmbeddingErrorCodes.IndexOutOfRange, 'The index passed to this command is out of range.');\n    }\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n\n    return service.revertStoryPointAsync(index).then<StoryPointInfoImpl>((response) => {\n      this.updateStoryInfo(response.index, response);\n      const storyPointInfoImpl = new StoryPointInfoImpl(\n        response.caption,\n        response.index,\n        response.storyPointId,\n        false,\n        response.updated,\n        this,\n      );\n      return storyPointInfoImpl;\n    });\n  }\n\n  public clearPendingPromises(): void {\n    if (this._deferred) {\n      this._deferred.reject('All pending promises cleared');\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ContainedSheetInfoModel, SheetInfo, SheetPath, VisualId } from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../TableauError';\nimport { SheetUtils } from '../Utils/SheetUtils';\nimport { DashboardImpl } from './DashboardImpl';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryImpl } from './StoryImpl';\nimport { StoryPointInfoImpl } from './StoryPointInfoImpl';\nimport { WorksheetImpl } from './WorksheetImpl';\n\nexport class StoryPointImpl {\n  private _containedSheetImpl: SheetImpl;\n  constructor(\n    private _storyPointInfoImpl: StoryPointInfoImpl,\n    sheetInfos: Array<SheetInfo>,\n    registryId: number,\n    containedSheetInfo?: ContainedSheetInfoModel,\n  ) {\n    if (containedSheetInfo) {\n      this._containedSheetImpl = this.createContainedSheet(containedSheetInfo, sheetInfos, registryId);\n    }\n  }\n\n  public get index(): number {\n    return this._storyPointInfoImpl.index;\n  }\n\n  public get caption(): string {\n    return this._storyPointInfoImpl.caption;\n  }\n\n  public get active(): boolean {\n    return this._storyPointInfoImpl.active;\n  }\n\n  public get updated(): boolean {\n    return this._storyPointInfoImpl.updated;\n  }\n\n  public set updated(updated: boolean) {\n    this._storyPointInfoImpl.updated = updated;\n  }\n\n  public get parentStory(): StoryImpl {\n    return this._storyPointInfoImpl.parentStory;\n  }\n\n  public get containedSheet(): SheetImpl | undefined {\n    return this._containedSheetImpl;\n  }\n\n  public get storyPointId(): number {\n    return this._storyPointInfoImpl.storyPointId;\n  }\n\n  private createContainedSheet(containedSheetInfo: ContainedSheetInfoModel, sheetInfos: Array<SheetInfo>, registryId: number): SheetImpl {\n    const containedSheetIdx = -1;\n\n    const publishedSheetInfo = SheetUtils.getPublishedSheetInfoByName(containedSheetInfo.name, sheetInfos);\n    const containedSheetSize = SheetUtils.createAutomaticSize();\n    const isContainedSheetHidden = publishedSheetInfo === undefined;\n    const containedSheetUrl = publishedSheetInfo ? publishedSheetInfo.url : '';\n    // Contained sheets aren't active - the containing sheet is active.\n    const containedSheetActive = false;\n\n    const containedSheetInfoImpl = new SheetInfoImpl(\n      containedSheetInfo.name,\n      SheetUtils.getSheetTypeEnum(containedSheetInfo.sheetType),\n      containedSheetSize,\n      containedSheetIdx,\n      containedSheetActive,\n      isContainedSheetHidden,\n      containedSheetUrl,\n    );\n\n    let sheetImpl: SheetImpl;\n    switch (containedSheetInfoImpl.sheetType) {\n      case Contract.SheetType.Worksheet: {\n        const vizId: VisualId = {\n          worksheet: containedSheetInfoImpl.name,\n        };\n\n        sheetImpl = new WorksheetImpl(containedSheetInfoImpl, registryId, vizId, null, this);\n        break;\n      }\n      case Contract.SheetType.Dashboard: {\n        const sheetPath: SheetPath = {\n          sheetName: containedSheetInfoImpl.name,\n          isDashboard: true,\n        };\n\n        sheetImpl = new DashboardImpl(containedSheetInfoImpl, containedSheetInfo.dashboardZones, sheetPath, registryId, this);\n        break;\n      }\n      default: {\n        throw new TableauError(Contract.SharedErrorCodes.ServerError, 'Invalid SheetType');\n      }\n    }\n\n    return sheetImpl;\n  }\n}\n","import { StoryImpl } from './StoryImpl';\n\nexport class StoryPointInfoImpl {\n  public constructor(\n    private _caption: string,\n    private _index: number,\n    private _storyPointId: number,\n    private _active: boolean,\n    private _updated: boolean,\n    private _parentStoryImpl: StoryImpl,\n  ) {}\n\n  public get caption() {\n    return this._caption;\n  }\n\n  public set caption(caption: string) {\n    this._caption = caption;\n  }\n\n  public get index() {\n    return this._index;\n  }\n\n  public set index(index: number) {\n    this._index = index;\n  }\n\n  public get storyPointId() {\n    return this._storyPointId;\n  }\n\n  public get active() {\n    return this._active;\n  }\n\n  public set active(isActive: boolean) {\n    this._active = isActive;\n  }\n\n  public get updated() {\n    return this._updated;\n  }\n\n  public set updated(isUpdated: boolean) {\n    this._updated = isUpdated;\n  }\n\n  public get parentStory() {\n    return this._parentStoryImpl;\n  }\n}\n","export class WorkbookImpl {}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  ApiMenuType,\n  ContextMenuOptions,\n  DateRangeType,\n  ErrorCodes,\n  FilterNullOption,\n  IncludeDataValuesOption,\n  PeriodType,\n  SelectionUpdateType,\n  SharedErrorCodes,\n  TooltipContext,\n} from '@tableau/api-external-contract-js';\nimport { DataSchema, DataSource as DataSourceInfo, VisualId, WorksheetDataSourceInfo } from '@tableau/api-internal-contract-js';\nimport { DataSource } from '../DataSource';\nimport { LogicalTable } from '../LogicalTable';\nimport { AccessibilityService } from '../Services/AccessibilityService';\nimport { AnnotationService } from '../Services/AnnotationService';\nimport { DataSourceService } from '../Services/DataSourceService';\nimport { ExternalContextMenuService } from '../Services/ExternalContextMenuService';\nimport { FilterService } from '../Services/FilterService';\nimport { GetDataService, GetDataType } from '../Services/GetDataService';\nimport { SelectionService } from '../Services/SelectionService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { VisualModelService } from '../Services/VisualModelService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { DashboardImpl } from './DashboardImpl';\nimport { DataSourceImpl } from './DataSourceImpl';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryPointImpl } from './StoryPointImpl';\n\nexport class WorksheetImpl extends SheetImpl {\n  public constructor(\n    sheetInfoImpl: SheetInfoImpl,\n    _registryId: number,\n    private _visualId: VisualId,\n    private _parentDashboardImpl: DashboardImpl | null,\n    private _parentStoryPointImpl: StoryPointImpl | null,\n  ) {\n    super(sheetInfoImpl, _registryId);\n  }\n\n  public get parentDashboard(): DashboardImpl | null {\n    return this._parentDashboardImpl;\n  }\n\n  public get parentStoryPoint(): StoryPointImpl | null {\n    return this._parentStoryPointImpl;\n  }\n\n  public get visualId(): VisualId {\n    return this._visualId;\n  }\n\n  public getMaxPageRowLimit(): number {\n    return 10000;\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    ErrorHelpers.verifyEnumValue<Contract.FilterUpdateType>(updateType, Contract.FilterUpdateType, 'Contract.FilterUpdateType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyFilterAsync(this.visualId, fieldName, values, updateType, options);\n  }\n\n  public applyRangeFilterAsync(fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\n    ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n    ErrorHelpers.verifyParameter(filterOptions, 'filterOptions');\n    if (filterOptions.nullOption) {\n      ErrorHelpers.verifyEnumValue<FilterNullOption>(filterOptions.nullOption, FilterNullOption, 'FilterNullOption');\n    } else {\n      ErrorHelpers.verifyRangeParamType(filterOptions.min, filterOptions.max);\n    }\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyRangeFilterAsync(this.visualId, fieldName, filterOptions);\n  }\n\n  public applyHierarchicalFilterAsync(\n    fieldName: string,\n    values: Array<string> | Contract.HierarchicalLevels,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n    ErrorHelpers.verifyParameter(values, 'values');\n    ErrorHelpers.verifyEnumValue<Contract.FilterUpdateType>(updateType, Contract.FilterUpdateType, 'Contract.FilterUpdateType');\n    if (!Array.isArray(values) && !values.levels) {\n      throw new TableauError(\n        ErrorCodes.InvalidParameter,\n        'values parameter for applyHierarchicalFilterAsync must be an array or contain a levels key',\n      );\n    }\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyHierarchicalFilterAsync(this.visualId, fieldName, values, updateType, options);\n  }\n\n  public clearFilterAsync(fieldName: string): Promise<string> {\n    ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.clearFilterAsync(this.visualId, fieldName);\n  }\n\n  public applyRelativeDateFilterAsync(fieldName: string, options: Contract.RelativeDateFilterOptions): Promise<string> {\n    ErrorHelpers.verifyStringParameter(fieldName, 'fieldName');\n    ErrorHelpers.verifyParameter(options, 'options');\n    ErrorHelpers.verifyEnumValue<PeriodType>(options.periodType, PeriodType, 'PeriodType');\n    ErrorHelpers.verifyEnumValue<DateRangeType>(options.rangeType, DateRangeType, 'DateRangeType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyRelativeDateFilterAsync(this.visualId, fieldName, options);\n  }\n\n  public getDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n    return service.getDataSourcesAsync(this.visualId).then<Array<Contract.DataSource>>((result) => {\n      const dataSchema: DataSchema = result;\n      const worksheetDataSourceInfo: WorksheetDataSourceInfo = dataSchema.worksheetDataSchemaMap[this.name];\n\n      const dataSources: Array<Contract.DataSource> = [];\n\n      // First, add the primary datasource.  By convention, it comes first in the returned array.\n      const primaryId: string = worksheetDataSourceInfo.primaryDataSource;\n      dataSources.push(this.createDataSourceFromInfo(dataSchema.dataSources[primaryId]));\n\n      // Then, loop through any secondary data sources and add them.\n      for (const secondaryId of worksheetDataSourceInfo.referencedDataSourceList) {\n        if (secondaryId !== primaryId) {\n          dataSources.push(this.createDataSourceFromInfo(dataSchema.dataSources[secondaryId]));\n        }\n      }\n\n      return dataSources;\n    });\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getFiltersAsync(this.visualId);\n  }\n\n  public getSelectedMarksAsync(): Promise<Contract.MarksCollection> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getSelectedMarksAsync(this.visualId);\n  }\n\n  public getHighlightedMarksAsync(): Promise<Contract.MarksCollection> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getHighlightedMarksAsync(this.visualId);\n  }\n\n  public getSummaryDataAsync(options: Contract.GetSummaryDataOptions): Promise<Contract.DataTable> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return service.getUnderlyingDataAsync(\n      this.visualId,\n      GetDataType.Summary,\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      true,\n      options.columnsToIncludeById || [],\n      options.maxRows || 0,\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getSummaryDataReaderAsync(pageRowCount: number, options: Contract.GetSummaryDataOptions): Promise<Contract.DataTableReader> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return service.getSummaryDataReaderAsync(\n      this.visualId,\n      pageRowCount || this.getMaxPageRowLimit(),\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      true, // includeAllColumns (can be overridden by columnsToIncludeById)\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getVisualSpecificationAsync(): Promise<Contract.VisualSpecification> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<VisualModelService>(ServiceNames.VisualModel);\n\n    return service.getVisualSpecificationAsync(this.visualId);\n  }\n\n  public getSummaryColumnsInfoAsync(): Promise<Array<Contract.Column>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getSummaryColumnsInfoAsync(this.visualId);\n  }\n\n  public getUnderlyingDataAsync(options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n    return service.getUnderlyingDataAsync(\n      this.visualId,\n      GetDataType.Underlying,\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      !!options.includeAllColumns,\n      options.columnsToIncludeById || [],\n      options.maxRows || 0,\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getUnderlyingTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n    return service.getUnderlyingTablesAsync(this.visualId).then<Array<Contract.LogicalTable>>((logicalTableInfos) => {\n      return logicalTableInfos.map((logicalTableInfo) => new LogicalTable(logicalTableInfo));\n    });\n  }\n\n  public getUnderlyingTableDataAsync(logicalTableId: string, options?: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n    return service.getUnderlyingTableDataAsync(\n      this.visualId,\n      logicalTableId,\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      !!options.includeAllColumns,\n      options.columnsToIncludeById || [],\n      options.maxRows || 0,\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getUnderlyingTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount?: number,\n    options?: Contract.GetUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n    return service.getUnderlyingTableDataReaderAsync(\n      this.visualId,\n      logicalTableId,\n      pageRowCount || this.getMaxPageRowLimit(),\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      !!options.includeAllColumns,\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public clearSelectedMarksAsync(): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.clearSelectedMarksAsync(this.visualId);\n  }\n\n  public selectMarksByValueAsync(selections: Array<Contract.SelectionCriteria>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    ErrorHelpers.verifyParameter(selections, 'fieldName');\n    ErrorHelpers.verifyEnumValue<SelectionUpdateType>(selectionUpdateType, SelectionUpdateType, 'SelectionUpdateType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.selectMarksByValueAsync(this.visualId, selections, selectionUpdateType);\n  }\n\n  public selectMarksByIdAsync(selections: Array<Contract.MarkInfo>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    ErrorHelpers.verifyParameter(selections, 'fieldName');\n    ErrorHelpers.verifyEnumValue<SelectionUpdateType>(selectionUpdateType, SelectionUpdateType, 'SelectionUpdateType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.selectMarksByIdAsync(this.visualId, selections, selectionUpdateType);\n  }\n\n  public annotateMarkAsync(mark: Contract.MarkInfo, annotationText: string): Promise<void> {\n    ErrorHelpers.verifyParameter(mark, 'mark');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<AnnotationService>(ServiceNames.Annotation);\n    return service.annotateMarkAsync(this.visualId, mark, annotationText);\n  }\n\n  public getAnnotationsAsync(): Promise<Array<Contract.Annotation>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<AnnotationService>(ServiceNames.Annotation);\n    return service.getAnnotationsAsync(this.visualId);\n  }\n\n  public removeAnnotationAsync(annotation: Contract.Annotation) {\n    ErrorHelpers.verifyParameter(annotation, 'annotation');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<AnnotationService>(ServiceNames.Annotation);\n    return service.removeAnnotationAsync(this.visualId, annotation);\n  }\n\n  public appendContextMenuAsync(targetMenu: ApiMenuType, config: ContextMenuOptions): Promise<string> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.appendContextMenuAsync(this.visualId.worksheet, targetMenu, config);\n  }\n\n  public removeContextMenuAsync(targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.removeContextMenuAsync(this.visualId.worksheet, targetMenu, menuItemId);\n  }\n\n  public executeContextMenuAsync(targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.executeContextMenuAsync(this.visualId.worksheet, targetMenu, menuItemId);\n  }\n\n  public renameContextMenuAsync(targetMenu: ApiMenuType, menuHeader: string, menuDescription: string): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.renameContextMenuAsync(this.visualId.worksheet, targetMenu, menuHeader, menuDescription);\n  }\n\n  public hoverTupleAsync(hoveredTuple?: number, tooltip?: TooltipContext | null, allowHoverActions?: boolean): Promise<void> {\n    if (this.isInsideDashboardExtension()) {\n      return Promise.reject(\n        new TableauError(Contract.SharedErrorCodes.ImplementationError, `hoverTupleAsync is not supported in dashboard extensions`),\n      );\n    }\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.hoverTupleAsync(this.visualId, hoveredTuple, tooltip, allowHoverActions);\n  }\n\n  public selectTuplesAsync(selectedTuples: Array<number>, selectOption: Contract.SelectOptions, tooltip?: TooltipContext): Promise<void> {\n    if (this.isInsideDashboardExtension()) {\n      return Promise.reject(\n        new TableauError(Contract.SharedErrorCodes.ImplementationError, `selectTuplesAsync is not supported in dashboard extensions`),\n      );\n    }\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.selectTuplesAsync(this.visualId, selectedTuples, selectOption, tooltip);\n  }\n\n  public getTooltipTextAsync(tupleId: number): Promise<String> {\n    if (this.isInsideDashboardExtension()) {\n      return Promise.reject(\n        new TableauError(Contract.SharedErrorCodes.ImplementationError, `getTooltipTextAsync is not supported in dashboard extensions`),\n      );\n    }\n    const service = ApiServiceRegistry.get(this._registryId).getService<AccessibilityService>(ServiceNames.Accessibility);\n    return service.getTooltipTextAsync(this.visualId, tupleId);\n  }\n\n  public leaveMarkNavigationAsync(): Promise<void> {\n    if (this.isInsideDashboardExtension()) {\n      return Promise.reject(\n        new TableauError(\n          Contract.SharedErrorCodes.ImplementationError,\n          `leaveMarkNavigationAsync is not supported in dashboard extensions`,\n        ),\n      );\n    }\n    const service = ApiServiceRegistry.get(this._registryId).getService<AccessibilityService>(ServiceNames.Accessibility);\n    return service.leaveMarkNavigationAsync(this.visualId);\n  }\n\n  private createDataSourceFromInfo(dataSourceInfo: DataSourceInfo): Contract.DataSource {\n    const dataSourceImpl = new DataSourceImpl(dataSourceInfo, this._registryId);\n    const dataSource = new DataSource(dataSourceImpl);\n    dataSourceImpl.initializeWithPublicInterfaces(dataSource);\n    return dataSource;\n  }\n\n  private verifyActiveSheet() {\n    const isRootAndActiveWorksheet = this.active;\n    const isInsideActiveDashboard = this.isInsideActiveDashboard();\n    const isInsideActiveStoryPoint = this.isInsideActiveStoryPoint();\n\n    if (!isRootAndActiveWorksheet && !isInsideActiveDashboard && !isInsideActiveStoryPoint) {\n      throw new TableauError(SharedErrorCodes.NotActiveSheet, 'Operation not allowed on non-active sheet');\n    }\n  }\n\n  private isInsideActiveStoryPoint() {\n    return this._parentStoryPointImpl && this._parentStoryPointImpl.active;\n  }\n\n  private isInsideActiveDashboard() {\n    return this._parentDashboardImpl && this._parentDashboardImpl.active;\n  }\n\n  private isInsideDashboardExtension() {\n    return this._parentDashboardImpl !== null;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { LogicalTableInfo } from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of a logical table.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class LogicalTable implements Contract.LogicalTable {\n  public constructor(private _logicalTable: LogicalTableInfo) {}\n\n  public get id(): string {\n    return this._logicalTable.id;\n  }\n\n  public get caption(): string {\n    return this._logicalTable.caption;\n  }\n}\n","import { TooltipTextRequest, VisualId } from '@tableau/api-internal-contract-js';\n\nexport class TooltipTextRequestModel implements TooltipTextRequest {\n  public constructor(public visualIdPresModel: VisualId, public tupleId: number) {}\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DateRangeType, FilterDomainType, FilterType, PeriodType } from '@tableau/api-external-contract-js';\nimport { HierarchicalLevelSelectionState } from '@tableau/api-external-contract-js/lib/src/ExternalContract/Shared/Namespaces/Tableau';\nimport { DataSourceService } from '../Services/DataSourceService';\nimport { FilterService } from '../Services/FilterService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\n\nexport class Filter implements Contract.Filter {\n  public constructor(\n    protected _worksheetName: string,\n    protected _fieldName: string,\n    protected _filterType: FilterType,\n    protected _fieldId: string,\n    protected _registryId: number,\n  ) {}\n\n  public get worksheetName(): string {\n    return this._worksheetName;\n  }\n\n  public get fieldName(): string {\n    return this._fieldName;\n  }\n\n  public get fieldId(): string {\n    return this._fieldId;\n  }\n\n  public get filterType(): FilterType {\n    return this._filterType;\n  }\n\n  public getFieldAsync(): Promise<Contract.Field> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n    return service.getFieldAsync(this._fieldId);\n  }\n\n  public getAppliedWorksheetsAsync(): Promise<Array<string>> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getAppliedWorksheetsAsync(this._worksheetName, this._fieldId);\n  }\n\n  public setAppliedWorksheetsAsync(applyToWorksheets: Array<string>): Promise<Array<string>> {\n    ErrorHelpers.verifyParameter(applyToWorksheets, 'applyToWorksheets');\n    const uniqueWorksheets = new Set(applyToWorksheets);\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.setAppliedWorksheetsAsync(this._worksheetName, this._fieldName, this._fieldId, Array.from(uniqueWorksheets));\n  }\n}\n\nexport class CategoricalFilter extends Filter implements Contract.CategoricalFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _appliedValues: Array<Contract.DataValue>,\n    private _isExcludeMode: boolean,\n    private _isAllSelected?: boolean,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n\n  public get isAllSelected(): boolean | undefined {\n    return this._isAllSelected;\n  }\n\n  public get appliedValues(): Array<Contract.DataValue> {\n    return this._appliedValues;\n  }\n\n  public get isExcludeMode(): boolean {\n    return this._isExcludeMode;\n  }\n\n  public getDomainAsync(domainType?: FilterDomainType): Promise<Contract.CategoricalDomain> {\n    if (!domainType) {\n      domainType = FilterDomainType.Relevant;\n    }\n\n    ErrorHelpers.verifyEnumValue<FilterDomainType>(domainType, FilterDomainType, 'FilterDomainType');\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getCategoricalDomainAsync(this._worksheetName, this._fieldId, domainType);\n  }\n}\n\nexport class HierarchicalDataValue implements Contract.HierarchicalFilterDataValue {\n  public constructor(private _value: Contract.DataValue, private _hierarchicalPath: string, private _level: number) {}\n\n  public get value(): Contract.DataValue {\n    return this._value;\n  }\n\n  public get hierarchicalPath(): string {\n    return this._hierarchicalPath;\n  }\n\n  public get level(): number {\n    return this._level;\n  }\n}\n\nexport class HierarchicalLevelDetail implements Contract.HierarchicalLevelDetail {\n  public constructor(private _name: string, private _levelSelectionState: HierarchicalLevelSelectionState) {}\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get levelSelectionState(): HierarchicalLevelSelectionState {\n    return this._levelSelectionState;\n  }\n}\n\nexport class HierarchicalFilter extends Filter implements Contract.HierarchicalFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _dimensionName: string,\n    private _hierarchyCaption: string,\n    private _numberOfLevels: number,\n    private _levelDetails: Array<Contract.HierarchicalLevelDetail>,\n    private _appliedValues: Array<Contract.HierarchicalFilterDataValue>,\n    private _isAllSelected: boolean,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n  getDomainAsync(domainType?: Contract.FilterDomainType): Promise<Contract.CategoricalDomain> {\n    throw new Error('Method not implemented.');\n  }\n\n  public get dimensionName(): string {\n    return this._dimensionName;\n  }\n\n  public get hierarchyCaption(): string {\n    return this._hierarchyCaption;\n  }\n\n  public get numberOfLevels(): number {\n    return this._numberOfLevels;\n  }\n\n  public get levelDetails(): Contract.HierarchicalLevelDetail[] {\n    return this._levelDetails;\n  }\n\n  public get isAllSelected(): boolean {\n    return this._isAllSelected;\n  }\n\n  public get appliedValues(): Array<Contract.HierarchicalFilterDataValue> {\n    return this._appliedValues;\n  }\n}\n\nexport class RangeFilter extends Filter implements Contract.RangeFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _min: Contract.DataValue,\n    private _max: Contract.DataValue,\n    private _includeNullValues: boolean,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n\n  public get minValue(): Contract.DataValue {\n    return this._min;\n  }\n\n  public get maxValue(): Contract.DataValue {\n    return this._max;\n  }\n\n  public get includeNullValues(): boolean {\n    return this._includeNullValues;\n  }\n\n  public getDomainAsync(domainType?: FilterDomainType): Promise<Contract.RangeDomain> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    if (!domainType) {\n      domainType = FilterDomainType.Relevant;\n    }\n\n    ErrorHelpers.verifyEnumValue<FilterDomainType>(domainType, FilterDomainType, 'FilterDomainType');\n\n    return service.getRangeDomainAsync(this._worksheetName, this._fieldId, domainType);\n  }\n}\n\nexport class RelativeDateFilter extends Filter implements Contract.RelativeDateFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _anchorDate: Contract.DataValue,\n    private _periodType: PeriodType,\n    private _rangeType: DateRangeType,\n    private _rangeN: number,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n\n  public get anchorDate(): Contract.DataValue {\n    return this._anchorDate;\n  }\n\n  public get periodType(): PeriodType {\n    return this._periodType;\n  }\n\n  public get rangeType(): DateRangeType {\n    return this._rangeType;\n  }\n\n  public get rangeN(): number {\n    return this._rangeN;\n  }\n}\n\nexport class CategoricalDomain implements Contract.CategoricalDomain {\n  public constructor(private _values: Array<Contract.DataValue>, private _domainType: FilterDomainType) {}\n\n  public get values(): Array<Contract.DataValue> {\n    return this._values;\n  }\n\n  public get type(): FilterDomainType {\n    return this._domainType;\n  }\n}\n\nexport class RangeDomain implements Contract.RangeDomain {\n  public constructor(private _min: Contract.DataValue, private _max: Contract.DataValue, private _domainType: FilterDomainType) {}\n\n  public get type(): FilterDomainType {\n    return this._domainType;\n  }\n\n  public get min(): Contract.DataValue {\n    return this._min;\n  }\n\n  public get max(): Contract.DataValue {\n    return this._max;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataType, MarkType } from '@tableau/api-external-contract-js';\n\nexport class DataTable implements Contract.DataTable {\n  private _name: string;\n\n  public constructor(\n    private _data: Array<Array<Contract.DataValue>>,\n    private _columns: Array<Contract.Column>,\n    private _totalRowCount: number,\n    private _isTotalRowCountLimited: boolean,\n    private _isSummaryData: boolean,\n    private _marksInfo?: Array<MarkInfo>,\n  ) {\n    this._name = _isSummaryData ? 'Summary Data Table' : 'Underlying Data Table';\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get data(): Array<Array<Contract.DataValue>> {\n    return this._data;\n  }\n\n  public get columns(): Array<Contract.Column> {\n    return this._columns;\n  }\n\n  public get marksInfo(): Array<Contract.MarkInfo> | undefined {\n    return this._marksInfo;\n  }\n\n  public get totalRowCount(): number {\n    return this._totalRowCount;\n  }\n\n  public get isTotalRowCountLimited(): boolean | undefined {\n    return this._isTotalRowCountLimited;\n  }\n\n  public get isSummaryData(): boolean | undefined {\n    return this._isSummaryData;\n  }\n}\n\nexport class MarkInfo implements Contract.MarkInfo {\n  public constructor(private _type: MarkType, private _color: string, private _tupleId?: number) {}\n\n  public get type(): MarkType {\n    return this._type;\n  }\n\n  public get color(): string {\n    return this._color;\n  }\n\n  public get tupleId(): number | undefined {\n    return this._tupleId;\n  }\n}\n\nexport class Column implements Contract.Column {\n  public constructor(\n    private _fieldName: string,\n    private _fieldId: string,\n    private _dataType: DataType,\n    private _isReferenced: boolean,\n    private _index: number,\n  ) {}\n\n  public get fieldName(): string {\n    return this._fieldName;\n  }\n\n  public get fieldId(): string {\n    return this._fieldId;\n  }\n\n  public get dataType(): DataType {\n    return this._dataType;\n  }\n\n  public get isReferenced(): boolean {\n    return this._isReferenced;\n  }\n\n  public get index(): number {\n    return this._index;\n  }\n}\n\nexport class DataValue implements Contract.DataValue {\n  /* tslint:disable:no-any */\n  public constructor(private _value: any, private _nativeValue: any, private _formattedValue?: string) {}\n\n  public get value(): any {\n    return this._value;\n  }\n\n  public get nativeValue(): any {\n    return this._nativeValue;\n  }\n\n  public get formattedValue(): string | undefined {\n    return this._formattedValue;\n  }\n  /* tslint:enable:no-any */\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { GetDataService } from '../Services/GetDataService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\n\nexport class DataTableReader implements Contract.DataTableReader {\n  public constructor(protected _id: string, protected _totalRowCount: number, protected _pageRowCount, private _registryId: number) {\n    this._pageCount = Math.ceil(_totalRowCount / _pageRowCount);\n  }\n  protected _pageCount: number;\n\n  public get totalRowCount(): number {\n    return this._totalRowCount;\n  }\n\n  public get pageCount(): number {\n    return this._pageCount;\n  }\n\n  public getPageAsync(pageNumber: number): Promise<Contract.DataTable> {\n    ErrorHelpers.verifyRange(pageNumber, 0, this._pageCount);\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getPageAsync(this._id, pageNumber, this._pageRowCount);\n  }\n\n  public async getAllPagesAsync(maxRows?: number): Promise<Contract.DataTable> {\n    const firstPage: Contract.DataTable = await this.getPageAsync(0);\n    maxRows = maxRows || this.totalRowCount;\n    const rowsRequested = Math.min(maxRows, this.totalRowCount);\n    const pagesRequested = Math.ceil(rowsRequested / this._pageRowCount);\n\n    // Fetch up to 400 pages, with a default of 10,000 pageRowCount that gives us 4,000,000 rows\n    const pagesToFetch = Math.min(pagesRequested, 400);\n    const isDataLimited = pagesToFetch < pagesRequested;\n    let remainingData: Array<Array<Array<Contract.DataValue>>> = [];\n    for (let i = 1; i < pagesToFetch; i++) {\n      const page = await this.getPageAsync(i);\n      remainingData.push(page.data);\n    }\n\n    let fullData = firstPage.data.concat(...remainingData);\n    // This slices the array only if maxRows has been set and is less than totalRowCount\n    fullData.length = rowsRequested;\n\n    return {\n      name: firstPage.name,\n      data: fullData,\n      columns: firstPage.columns,\n      totalRowCount: isDataLimited ? pagesToFetch * this._pageRowCount : rowsRequested,\n      isTotalRowCountLimited: isDataLimited,\n      isSummaryData: firstPage.isSummaryData,\n    };\n  }\n\n  public releaseAsync(): Promise<void> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.releaseAsync(this._id);\n  }\n}\n","import { TooltipContext } from '@tableau/api-external-contract-js';\nimport { HoverTupleInteraction, SelectOptions, SelectTuplesInteraction, VisualId } from '@tableau/api-internal-contract-js';\n\n/**\n * Selection Model.\n */\nexport class SelectionModel {\n  public qualifiedFieldCaption: string;\n}\n\n/**\n * Value based selection model. Meant for hierarchical, range and categorical selections.\n */\nexport class ValueSelectionModel extends SelectionModel {\n  public selectValues: Array<string> = [];\n}\n\n/**\n * Hierarchical value selection model\n */\nexport class HierarchicalSelectionModel extends ValueSelectionModel {}\n\n/**\n * Range based value selection model\n */\nexport class RangeSelectionModel extends SelectionModel {\n  public minValue: string;\n  public maxValue: string;\n  public included: string;\n}\n\n/**\n * Dimension value selection model\n */\nexport class DimensionSelectionModel extends ValueSelectionModel {}\n/**\n * Tuple based selection model\n */\nexport class TupleSelectionModel {\n  public selectionType: string;\n  public objectIds: Array<string> = [];\n}\n\n/**\n * Container class to populate all the selection models when parsing input\n */\nexport class SelectionModelsContainer {\n  public hierModelArr: Array<HierarchicalSelectionModel> = [];\n  public dimModelArr: Array<DimensionSelectionModel> = [];\n  public quantModelArr: Array<RangeSelectionModel> = [];\n  public selection: TupleSelectionModel;\n}\n\nexport class SelectTuplesInteractionModel implements SelectTuplesInteraction {\n  public constructor(\n    public visualIdPresModel: VisualId,\n    public tupleIds: Array<number> = [],\n    public selectOptions: SelectOptions,\n    public tooltipContext?: TooltipContext,\n  ) {}\n}\n\nexport class HoverTupleInteractionModel implements HoverTupleInteraction {\n  public constructor(\n    public visualIdPresModel: VisualId,\n    public tupleId: number,\n    public tooltipContext?: TooltipContext | null,\n    public allowHoverActions?: boolean,\n  ) {}\n}\n","import * as Contract from '@tableau/api-external-contract-js';\n\nexport class Point implements Contract.Point {\n  public constructor(private _x: number, private _y: number) {}\n\n  public get x(): number {\n    return this._x;\n  }\n\n  public get y(): number {\n    return this._y;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { IncludeDataValuesOption } from '@tableau/api-external-contract-js';\nimport { VisualId } from '@tableau/api-internal-contract-js';\nimport { ApiService } from './ServiceRegistry';\n\n/**\n * Defines which type of getData call to make.\n */\nexport enum GetDataType {\n  Summary = 'summary',\n  Underlying = 'underlying',\n}\n\n/**\n * Service for implementing the logic for various getData calls\n *\n * @interface GetDataService\n * @extends {ApiService}\n */\nexport interface GetDataService extends ApiService {\n  /**\n   * Gets the limit of rows for getUnderlyingDataAsync\n   */\n  getMaxRowLimit(): number;\n\n  /**\n   * Gets the underlying data for a particular visual\n   *\n   * @param {VisualId} visualId  The visual id\n   * @param {GetDataType} getType  The type of getData call to make\n   * @param {boolean} ignoreAliases  Whether or not aliases should be ignored\n   * @param {boolean} ignoreSelection  Whether or not selection should be ignored\n   * @param {boolean} includeAllColumns  Should all columns be included\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns.\n   * @param {number} maxRows  Maximum number of rows to return\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getUnderlyingDataAsync(\n    visualId: VisualId,\n    getType: GetDataType,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   * @param {number} pageRowCount The number of rows per page. The default and maximum is 10,000 rows.\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {boolean} ignoreSelection  Whether selections in this viz should be ignored in the returned data\n   * @param {boolean} includeAllColumns  Should all columns be included\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns\n   * @returns {Promise<Contract.DataTableReader>}  Data table reader to access the underlying data\n   */\n  getSummaryDataReaderAsync(\n    visualId: VisualId,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader>;\n\n  /**\n   * Gets the currently selected marks for a given visual\n   *\n   * @param {VisualId} visualId  The visual id\n   * @returns {Promise<ActiveMarks>}  Collection of data tables with the active marks\n   */\n  getSelectedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection>;\n\n  /**\n   * Gets the currently highlighted marks for a given visual\n   *\n   * @param {VisualId} visualId  The visual id\n   * @returns {Promise<ActiveMarks>}  Collection of data tables with the active marks\n   */\n  getHighlightedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection>;\n\n  /**\n   * @param {string} datasourceId  The id of the datasource\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {number} maxRows The maximum number of rows to retrieve\n   * @param {Array<string>} columnsToInclude Columns which should be returned specified by caption. Empty means all columns\n   * @param {Array<string>} columnsToIncludeById Columns which should be returned specified by name. Empty means all columns\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getDataSourceDataAsync(\n    datasourceId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {string} datasourceId  The id of the datasource\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {number} maxRows The maximum number of rows to retrieve\n   * @param {Array<string>} columnsToInclude Columns which should be returned specified by caption. Empty means all columns\n   * @param {Array<string>} columnsToIncludeById Columns which should be returned specified by name. Empty means all columns\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getLogicalTableDataAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {string} datasourceId  The id of the datasource\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {number} pageRowCount The number of rows per page. The default and maximum is 10,000 rows.\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {Array<string>} columnsToIncludeById Columns which should be returned specified by name. Empty means all columns\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getLogicalTableDataReaderAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {boolean} ignoreSelection  Whether selections in this viz should be ignored in the returned data\n   * @param {boolean} includeAllColumns  Whether to include all columns or only the referenced columns\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns.\n   * @param {number} maxRows The maximum number of rows to retrieve\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getUnderlyingTableDataAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {number} pageRowCount The number of rows per page. The default and maximum is 10,000 rows.\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {boolean} ignoreSelection  Whether selections in this viz should be ignored in the returned data\n   * @param {boolean} includeAllColumns  Whether to include all columns or only the referenced columns\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns.\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getUnderlyingTableDataReaderAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   */\n  getSummaryColumnsInfoAsync(visualId: VisualId): Promise<Array<Contract.Column>>;\n\n  /**\n   * @param tableId     The table id used to fetch data.\n   * @param pageNumber  The page number (zero-based).\n   * @param pageSize    The page size of the owning DataTableReader\n   * @returns           A DataTable containing the requested page. The number of rows returned\n   *                    can be less than requested at the end of the data.\n   */\n  getPageAsync(tableId: string, pageNumber: number, pageSize: number): Promise<Contract.DataTable>;\n\n  /**\n   * @param tableId     The table id used to fetch data.\n   */\n  releaseAsync(tableId: string): Promise<void>;\n}\n","import { InternalApiDispatcher, VersionNumber } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry } from './ServiceRegistry';\nimport { AccessibilityServiceImpl } from './impl/AccessibilityServiceImpl';\nimport { AnimationServiceImpl } from './impl/AnimationServiceImpl';\nimport { AnnotationServiceImpl } from './impl/AnnotationServiceImpl';\nimport { DataSourceServiceImpl } from './impl/DataSourceServiceImpl';\nimport { ExportServiceImpl } from './impl/ExportServiceImpl';\nimport { ExternalContextMenuServiceImpl } from './impl/ExternalContextMenuServiceImpl';\nimport { FilterServiceImpl } from './impl/FilterServiceImpl';\nimport { GetDataServiceImpl } from './impl/GetDataServiceImpl';\nimport { NotificationServiceImpl } from './impl/NotificationServiceImpl';\nimport { ParametersServiceImpl } from './impl/ParametersServiceImpl';\nimport { SelectionServiceImpl } from './impl/SelectionServiceImpl';\nimport { SizeServiceImpl } from './impl/SizeServiceImpl';\nimport { VisualModelServiceImpl } from './impl/VisualModelServiceImpl';\nimport { VizServiceImpl } from './impl/VizServiceImpl';\nimport { ZoneServiceImpl } from './impl/ZoneServiceImpl';\n\nexport function registerAllSharedServices(dispatcher: InternalApiDispatcher, registryId: number, platformVersion?: VersionNumber): void {\n  ApiServiceRegistry.get(registryId).registerService(new AnimationServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new DataSourceServiceImpl(dispatcher, registryId, platformVersion));\n  ApiServiceRegistry.get(registryId).registerService(new ExportServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new GetDataServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new FilterServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new NotificationServiceImpl(dispatcher));\n  ApiServiceRegistry.get(registryId).registerService(new ParametersServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new SelectionServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new AnnotationServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new ZoneServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new SizeServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new VisualModelServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new VizServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new ExternalContextMenuServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new AccessibilityServiceImpl(dispatcher, registryId));\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * Base interface for an api service\n */\nexport interface ApiService {\n  /**\n   * Gets the name for this service.\n   */\n  readonly serviceName: string;\n}\n\n/**\n * Collection of service name which will be registered in the api-shared project\n */\nexport const enum ServiceNames {\n  Accessibility = 'accessibility',\n  Authentication = 'authentication',\n  ClientInfo = 'client-info-service',\n  DataSourceService = 'data-source-service',\n  GetData = 'get-data-service',\n  Filter = 'filter-service',\n  Notification = 'notification-service',\n  Parameters = 'parameters-service',\n  Selection = 'selection-service',\n  Annotation = 'annotation-service',\n  Zone = 'zone-service',\n  Animation = 'animation-service',\n  Viz = 'viz-service',\n  ExternalContextMenu = 'external-context-menu-service',\n  Initialization = 'initialization-service',\n  StoryActivation = 'story-activation-service',\n  Size = 'size-service',\n  Export = 'export-service',\n  VisualModel = 'visual-model-service',\n}\n\n/**\n * Do some global declarations so we can create a singleton on the window object\n */\ndeclare global {\n  interface Window {\n    __tableauApiServiceRegistry: { [registryId: number]: ServiceRegistry };\n  }\n}\n\nwindow.__tableauApiServiceRegistry = window.__tableauApiServiceRegistry || {};\n\nexport interface ServiceRegistry {\n  /**\n   * Registers a new service into the service registry. Any existing one will\n   * be overwritten. the service is registered under service.serviceName\n   *\n   * @param {ApiService} service The servive to register\n   */\n  registerService(service: ApiService): void;\n\n  /**\n   * Retrieves the given service from the registry. If there is not a\n   * service registered under that name, throws and error\n   *\n   * @template T The type of the service\n   * @param {string} serviceName The name of the service.\n   * @returns {T} The requested service\n   */\n  getService<T extends ApiService>(serviceName: string): T;\n}\n\nclass ServiceRegistryImpl implements ServiceRegistry {\n  private _services: { [serviceName: string]: ApiService };\n\n  public constructor() {\n    this._services = {};\n  }\n\n  public registerService(service: ApiService): void {\n    this._services[service.serviceName] = service;\n  }\n\n  public getService<T extends ApiService>(serviceName: string): T {\n    if (!this._services.hasOwnProperty(serviceName)) {\n      throw new TableauError(ErrorCodes.InternalError, `Service not registered: ${serviceName}`);\n    }\n\n    return this._services[serviceName] as T;\n  }\n}\n\n/**\n * Static class used for getting access to the single instance\n * of the ApiServiceRegistry associated with the registryId.\n *\n * Extensions by design don't need to store/access multiple service registries. Their single instance of ServiceRegistry is\n * stored/access with registryId = 0.\n *\n * Whereas Embedding needs to be aware of which ServiceRegistry to use when there are multiple vizzes embedded.\n * An example of how window.__tableauApiServiceRegistry will look when there are two vizzes: { 0 : ServiceRegistry, 1 : ServiceRegistry}\n * where registry ID of 0 & 1 refers to viz's internal identifier (which is generated by VizManager).\n */\nexport class ApiServiceRegistry {\n  /**\n   * Gets the singleton instance of the ServiceRegistry\n   */\n  public static get(registryId: number): ServiceRegistry {\n    if (!window.__tableauApiServiceRegistry || !window.__tableauApiServiceRegistry[registryId]) {\n      ApiServiceRegistry.setInstance(registryId, new ServiceRegistryImpl());\n    }\n\n    if (!window.__tableauApiServiceRegistry[registryId]) {\n      throw new TableauError(ErrorCodes.InternalError, 'Service registry failed');\n    }\n\n    return window.__tableauApiServiceRegistry[registryId];\n  }\n\n  /**\n   * Helper method that sets the service registry instance for the corresponding registryId. Can be used by unit tests\n   *\n   * @param {ServiceRegistry} serviceRegistry The new registry\n   */\n  public static setInstance(registryId: number, serviceRegistry: ServiceRegistry): void {\n    if (!window.__tableauApiServiceRegistry) {\n      window.__tableauApiServiceRegistry = {};\n    }\n    window.__tableauApiServiceRegistry[registryId] = serviceRegistry;\n  }\n\n  /**\n   * Only used by unit tests\n   */\n  public static clearRegistry(): void {\n    window.__tableauApiServiceRegistry = {};\n  }\n\n  // Private to avoid anyone constructing this\n  private constructor() {}\n}\n","import { ExecuteParameters, ParameterId, VerbId, VisualId } from '@tableau/api-internal-contract-js';\nimport { TooltipTextRequestModel } from '../../Models/AccessibilityModels';\nimport { AccessibilityService } from '../AccessibilityService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class AccessibilityServiceImpl extends ServiceImplBase implements AccessibilityService {\n  public get serviceName(): string {\n    return ServiceNames.Accessibility;\n  }\n\n  public getTooltipTextAsync(visualId: VisualId, tupleId: number): Promise<String> {\n    let tooltipTextRequest = new TooltipTextRequestModel(visualId, tupleId);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getTooltipTextAsync',\n      [ParameterId.TooltipTextRequest]: tooltipTextRequest,\n    };\n\n    return this.execute(VerbId.GetTooltipText, parameters).then<String>((response) => {\n      return response.result as String;\n    });\n  }\n\n  public leaveMarkNavigationAsync(visualId: VisualId): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'leaveMarkNavigationAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n\n    return this.execute(VerbId.RaiseLeaveMarkNavNotification, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import { ReplaySpeedType } from '@tableau/api-external-contract-js';\nimport { ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ExternalToInternalEnumMappings as ExternalEnumConverter } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { ErrorHelpers } from '../../Utils/ErrorHelpers';\nimport { AnimationService } from '../AnimationService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class AnimationServiceImpl extends ServiceImplBase implements AnimationService {\n  public get serviceName(): string {\n    return ServiceNames.Animation;\n  }\n\n  public replayAsync(replaySpeed: ReplaySpeedType): Promise<void> {\n    const parameters = {\n      [ParameterId.ReplaySpeed]: 1.0,\n    };\n\n    ErrorHelpers.verifyEnumValue<ReplaySpeedType>(replaySpeed, ReplaySpeedType, 'ReplaySpeedType');\n    parameters[ParameterId.ReplaySpeed] = ExternalEnumConverter.setReplaySpeedType.convert(replaySpeed);\n\n    return this.execute(VerbId.ReplayAnimation, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { AnnotateEnum, Annotation, ExecuteParameters, ParameterId, VerbId, VisualId } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../../EnumMappings/InternalToExternalEnumMappings';\nimport { SelectionModelsContainer, TupleSelectionModel } from '../../Models/SelectionModels';\nimport { TableauError } from '../../TableauError';\nimport { AnnotationService } from '../AnnotationService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class AnnotationServiceImpl extends ServiceImplBase implements AnnotationService {\n  public get serviceName(): string {\n    return ServiceNames.Annotation;\n  }\n\n  /**\n   * Method to annotate a mark on the given worksheet.\n   *\n   * @param visualId\n   * @param mark\n   * @param annotationText\n   */\n  public annotateMarkAsync(visualId: VisualId, mark: Contract.MarkInfo, annotationText: string): Promise<void> {\n    const selectionModelContainer: SelectionModelsContainer = this.parseMarkSelectionIds([mark]);\n    const dummyTargetPoint = { x: 0, y: 0 };\n    const formattedText = `<formatted-text><run>${annotationText}</run></formatted-text>`;\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'annotateMarkAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.AnnotateEnum]: AnnotateEnum.Mark,\n      [ParameterId.TargetPoint]: dummyTargetPoint,\n      [ParameterId.SelectionList]: [selectionModelContainer.selection],\n      [ParameterId.FormattedText]: formattedText,\n    };\n    return this.execute(VerbId.CreateAnnotation, parameters).then<void>((response) => {\n      // Expecting an empty model and hence the void response.\n      return;\n    });\n  }\n\n  /**\n   * Method to retrieve annotations for the given worksheet.\n   *\n   * @param visualId\n   * @returns {Promise<Array<Annotation>>}\n   */\n  public getAnnotationsAsync(visualId: VisualId): Promise<Array<Contract.Annotation>> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getAnnotationsAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetAnnotations, parameters).then<Array<Contract.Annotation>>((response) => {\n      const annotationsList = response.result as Array<Annotation>;\n      return this.annotationFilterMap(annotationsList);\n    });\n  }\n\n  /**\n   * Method to remove an annotation from a given worksheet.\n   *\n   * @param visualId\n   * @param annotation\n   */\n  public removeAnnotationAsync(visualId: VisualId, annotation: Contract.Annotation): Promise<void> {\n    const selectionModelContainer: SelectionModelsContainer = this.parseAnnotationSelectionIds([annotation]);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'removeAnnotationAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.SelectionList]: [selectionModelContainer.selection],\n    };\n    return this.execute(VerbId.RemoveAnnotation, parameters).then<void>((response) => {\n      // Expecting an empty model and hence the void response.\n      return;\n    });\n  }\n\n  /**\n   * Method to prepare the pres models for selection by MarksInfo\n   * @param marks\n   */\n  private parseMarkSelectionIds(marks: Array<Contract.MarkInfo>): SelectionModelsContainer {\n    const ids: Array<string> = [];\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n    marks.forEach((mark) => {\n      const tupleId: number | undefined = mark.tupleId;\n      if (tupleId !== undefined && tupleId !== null && tupleId > 0) {\n        ids.push(tupleId.toString()); // collect the tuple ids\n      } else {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'invalid tupleId');\n      }\n    });\n    if (ids.length !== 0) {\n      // tuple ids based selection\n      const tupleSelectionModel: TupleSelectionModel = new TupleSelectionModel();\n      tupleSelectionModel.selectionType = 'tuples';\n      tupleSelectionModel.objectIds = ids;\n      selectionModelContainer.selection = tupleSelectionModel;\n    }\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to prepare the pres models for selection by MarkAnnotationInfo\n   * @param marks\n   */\n  private parseAnnotationSelectionIds(annotations: Array<Contract.Annotation>): SelectionModelsContainer {\n    const ids: Array<string> = [];\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n    annotations.forEach((annotation) => {\n      const annotationId: number | undefined = annotation.annotationId;\n      if (annotationId !== undefined && annotationId !== null && annotationId >= 0) {\n        ids.push(annotationId.toString()); // collect the annotation ids\n      } else {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'invalid annotationId');\n      }\n    });\n    if (ids.length !== 0) {\n      // annotation ids based selection\n      const tupleSelectionModel: TupleSelectionModel = new TupleSelectionModel();\n      tupleSelectionModel.selectionType = 'annotations';\n      tupleSelectionModel.objectIds = ids;\n      selectionModelContainer.selection = tupleSelectionModel;\n    }\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to map Annotation to MarkAnnotationInfo\n   * @param annotation\n   * @returns {Annotation}\n   */\n  private mapAnnotation(annotation: Annotation): Contract.Annotation {\n    return {\n      annotationHTML: annotation.annotationText,\n      annotationId: annotation.annotationId,\n      annotationText: annotation.annotationPlainText,\n      annotationType: InternalToExternalEnumMappings.annotationType.convert(annotation.annotateEnum),\n      tupleId: annotation.tupleId!,\n    };\n  }\n\n  /**\n   * Filter the Annotations to Mark Annotations, and map them to MarkAnnotationInfo\n   * @param annotations\n   * @returns {Array<Annotation>}\n   */\n  private annotationFilterMap(annotations: Array<Annotation>): Array<Contract.Annotation> {\n    const annotationInfos = annotations.map((annotation) => this.mapAnnotation(annotation));\n\n    return annotationInfos;\n  }\n}\n","import { EmbeddingBootstrapInfo, ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ClientInfoService } from '../ClientInfoService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ClientInfoServiceImpl extends ServiceImplBase implements ClientInfoService {\n  public get serviceName(): string {\n    return ServiceNames.ClientInfo;\n  }\n\n  public getClientInfoAsync(): Promise<EmbeddingBootstrapInfo> {\n    const verb = VerbId.GetEmbeddingClientInfo;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getClientInfoAsync',\n    };\n\n    return this.execute(verb, parameters).then<EmbeddingBootstrapInfo>((response) => {\n      const clientInfo = response.result as EmbeddingBootstrapInfo;\n      return clientInfo;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes } from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport {\n  ConnectionDescriptionSummary,\n  DataSchema,\n  ExecuteParameters,\n  InternalApiDispatcher,\n  LogicalTableInfo,\n  ParameterId,\n  TableInfo,\n  TableInfos,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport { DataSource } from '../../DataSource';\nimport { Field } from '../../Field';\nimport { DataSourceImpl } from '../../Impl/DataSourceImpl';\nimport { FieldImpl } from '../../Impl/FieldImpl';\nimport { TableauError } from '../../TableauError';\nimport { DataSourceService } from '../DataSourceService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport const SENTINEL_LOGICAL_TABLE_INFO: LogicalTableInfo = {\n  id: InternalContract.ApiShowDataTableSentinel.SingleTableId,\n  caption: InternalContract.ApiShowDataTableSentinel.SingleTableCaption,\n};\n\n// The minimum platform version when Object Model was supported\nconst platformVersionObjectModelSupport = { major: 1, minor: 20, fix: 1 };\n\nexport class DataSourceServiceImpl extends ServiceImplBase implements DataSourceService {\n  // Since Object Model is supported since Tableau 2020.2, DataSourceServiceImpl can be initialized with the\n  // platform version when OM was supported. Once we drop support for Tableau versions <= 2020.1, all additional\n  // code in here for Object Model can be removed.\n  public constructor(\n    dispatcher: InternalApiDispatcher,\n    registryId: number,\n    private _platformVersion: InternalContract.VersionNumber = platformVersionObjectModelSupport,\n  ) {\n    super(dispatcher, registryId);\n  }\n  public get serviceName(): string {\n    return ServiceNames.DataSourceService;\n  }\n\n  public refreshAsync(dataSourceId?: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'refreshAsync',\n      [ParameterId.DeltaTimeMs]: 0,\n      [ParameterId.ShouldRefreshDS]: true,\n    };\n\n    // On server: Not passing the datasource id will refresh all datasources.\n    if (dataSourceId) {\n      parameters[ParameterId.DataSourceId] = dataSourceId;\n    }\n\n    return this.execute(VerbId.RefreshDataSource, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public getActiveTablesAsync(dataSourceId: string): Promise<Array<TableInfo>> {\n    const joinParameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getActiveTablesAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n    };\n\n    // Get the description of the tables used by this connection\n    return this.execute(VerbId.GetActiveTables, joinParameters).then<Array<TableInfo>>((joinResponse) => {\n      const tableInfos = joinResponse.result as TableInfos;\n\n      // getActiveTables is unsupported for cubes and GA. We do not have a connection type property\n      // available from the platform (intentionally, to reduce code churn as new connections are added).\n      // Instead,just check if any tables are returned. This array will be empty for any non-table based datasource.\n      if (tableInfos.tables.length === 0) {\n        throw new TableauError(ErrorCodes.UnsupportedMethodForDataSourceType, `getActiveTables is not supported for: ${dataSourceId}`);\n      }\n\n      return tableInfos.tables;\n    });\n  }\n\n  public getDataSourcesAsync(visualId: VisualId): Promise<DataSchema> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getDataSourcesAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetDataSources, parameters).then<DataSchema>((response) => {\n      const dataSchema = response.result as DataSchema;\n      return dataSchema;\n    });\n  }\n\n  public getAllDataSourcesAsync(): Promise<DataSchema> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getAllDataSourcesAsync',\n    };\n    return this.execute(VerbId.GetAllDataSources, parameters).then<DataSchema>((response) => {\n      const dataSchema = response.result as DataSchema;\n      return dataSchema;\n    });\n  }\n\n  public getConnectionSummariesAsync(dataSourceId: string): Promise<ConnectionDescriptionSummary[]> {\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getConnectionSummariesAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n    };\n\n    // Get the description of the tables used by this connection\n    return this.execute(VerbId.GetConnectionDescriptionSummaries, params).then<ConnectionDescriptionSummary[]>((response) => {\n      const descriptionSummaries = response.result as ConnectionDescriptionSummary[];\n      return descriptionSummaries;\n    });\n  }\n\n  public getFieldAsync(globalfieldName: string): Promise<Contract.Field> {\n    const verb = VerbId.GetFieldAndDataSource;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getFieldAsync',\n      [ParameterId.FieldId]: globalfieldName,\n    };\n\n    return this.execute(verb, parameters).then<Contract.Field>((response) => {\n      const dataSource = response.result[ParameterId.DataSource] as InternalContract.DataSource;\n      const field = response.result[ParameterId.Field] as Field;\n      return this.convertField(field, this.convertDataSource(dataSource));\n    });\n  }\n\n  public getLogicalTablesAsync(dataSourceId: string): Promise<Array<LogicalTableInfo>> {\n    if (!this.isObjectModelSupportedByPlatform()) {\n      /**\n       * This sentinel ID can be passed to datasource.getLogicalTableData.\n       * Once the desktop is upgraded to a version that supports object model,\n       * the sentinel ID will automatically fetch the upgraded table.\n       * */\n      return new Promise<Array<LogicalTableInfo>>((resolve) => resolve([SENTINEL_LOGICAL_TABLE_INFO]));\n    }\n\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getLogicalTablesAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n    };\n    return this.execute(VerbId.GetLogicalTables, params).then<Array<LogicalTableInfo>>((response) => {\n      return response.result as Array<LogicalTableInfo>;\n    });\n  }\n\n  public getUnderlyingTablesAsync(visualId: VisualId): Promise<Array<LogicalTableInfo>> {\n    if (!this.isObjectModelSupportedByPlatform()) {\n      /**\n       * This sentinel ID can be passed to worksheet.getUnderlyingTableData.\n       * Once the desktop is upgraded to a version that supports object model,\n       * the sentinel ID will automatically fetch the upgraded table.\n       * */\n      return new Promise<Array<LogicalTableInfo>>((resolve) => resolve([SENTINEL_LOGICAL_TABLE_INFO]));\n    }\n\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getUnderlyingTablesAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetUnderlyingTables, params).then<Array<LogicalTableInfo>>((response) => {\n      return response.result as Array<LogicalTableInfo>;\n    });\n  }\n\n  private convertField(field: InternalContract.Field, dataSource: Contract.DataSource): Contract.Field {\n    return new Field(new FieldImpl(field, dataSource));\n  }\n\n  private convertDataSource(dataSource: InternalContract.DataSource): Contract.DataSource {\n    return new DataSource(new DataSourceImpl(dataSource, this._registryId));\n  }\n\n  private isObjectModelSupportedByPlatform(): boolean {\n    const platformVersionNoObjectModelSupport = { major: 1, minor: 13, fix: 0 };\n    return InternalContract.VersionLessThan(platformVersionNoObjectModelSupport, this._platformVersion);\n  }\n}\n","import {\n  ExecuteParameters,\n  ExportCrosstabSheetMap,\n  ExportFile,\n  ExportPDFOptions as InternalExportPDFOptions,\n  ParameterId,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport {\n  CrosstabFileFormat,\n  ExportDataOptions,\n  ExportPDFOptions as ExternalExportPDFOptions,\n  ExportScenariosForPDFAndPowerPoint,\n  SharedErrorCodes,\n  SheetType as ExternalSheetType,\n} from '@tableau/api-external-contract-js';\nimport { ExternalToInternalEnumMappings } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { ExportHelpers } from '../../Utils/ExportHelpers';\nimport { ExportService } from '../ExportService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ErrorHelpers } from '../../Utils/ErrorHelpers';\nimport { TableauError } from '../../TableauError';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ExportServiceImpl extends ServiceImplBase implements ExportService {\n  public get serviceName(): string {\n    return ServiceNames.Export;\n  }\n\n  public getExportCrosstabSheetMapAsync(currentSheetType: ExternalSheetType): Promise<ExportCrosstabSheetMap> {\n    const verb = VerbId.GetExportCrosstabSheetMap;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getExportCrosstabSheetMapAsync',\n      [ParameterId.CurrentSheetType]: ExternalToInternalEnumMappings.sheetType.convert(currentSheetType),\n    };\n    return this.execute(verb, parameters).then<ExportCrosstabSheetMap>((response) => {\n      const result = response.result as ExportCrosstabSheetMap;\n      return result;\n    });\n  }\n\n  public async exportCrosstabAsync(\n    sheetName: string,\n    format: CrosstabFileFormat,\n    exportableWorksheetNames: Array<string>,\n    currentSheetType: ExternalSheetType,\n  ): Promise<ExportFile> {\n    ErrorHelpers.verifySheetName(exportableWorksheetNames, sheetName);\n    ErrorHelpers.verifyEnumValue<CrosstabFileFormat>(format, CrosstabFileFormat, 'CrosstabFileFormat');\n\n    // The pres layer command for exporting Crosstab uses SimpleSheetIdentifiers instead of sheet names.\n    // The extensions-and-embedding-api current does not store references to the SimpleSheetIdentifiers of its sheets\n    // so we call a pres layer command that gives us the SimpleSheetIdentifier for each sheet name that appears in the\n    // export Crosstab dialog popup.\n    const sheetNameToIdMap = await this.getExportCrosstabSheetMapAsync(currentSheetType);\n    if (!sheetNameToIdMap[sheetName]) {\n      throw new TableauError(SharedErrorCodes.InternalError, 'missing sheet doc id from sheetMap');\n    }\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportCrosstabAsync',\n      [ParameterId.SheetIdentifier]: sheetNameToIdMap[sheetName],\n      [ParameterId.SendNotifications]: true, // send notification on pres layer that triggers file download\n    };\n\n    // pres layer command invoked depends on the crosstab file format\n    let verb;\n    switch (format) {\n      case CrosstabFileFormat.CSV:\n        verb = VerbId.ExportCrosstabCsvDownload;\n        // CSV only parameter: see browser-clients/export-crosstab-options-dialog repo\n        parameters[ParameterId.UseTabDelimiters] = true;\n        break;\n      case CrosstabFileFormat.Excel:\n        verb = VerbId.ExportCrosstabExcelDownload;\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'unsupported Crosstab file format.');\n    }\n\n    return this.execute(verb, parameters)\n      .then<ExportFile>((response) => {\n        const result = response.result as ExportFile;\n        return result;\n      })\n      .catch(() => {\n        throw new TableauError(SharedErrorCodes.CrosstabCreationError, 'An unexpected error occurred while generating the document.');\n      });\n  }\n\n  public exportDataAsync(visualId: VisualId, options: ExportDataOptions): Promise<void> {\n    ErrorHelpers.verifyExportDataOptions(options);\n\n    // Remove any duplicates from the input array\n    const columnsAsSet: Set<string> = new Set(options.columnsToIncludeById);\n    const columnsToIncludeById = Array.from(columnsAsSet);\n\n    const verb = VerbId.ExportDataDownload;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportDataAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.IgnoreAliases]: options.ignoreAliases ?? false,\n      [ParameterId.ColumnsToIncludeById]: columnsToIncludeById,\n    };\n\n    return this.execute(verb, parameters)\n      .then<void>(() => {})\n      .catch(() => {\n        throw new TableauError(SharedErrorCodes.DataCreationError, 'An unexpected error occurred while generating the document.');\n      });\n  }\n\n  public exportPowerPointAsync(sheetNames: Array<string>, exportScenarios: ExportScenariosForPDFAndPowerPoint): Promise<ExportFile> {\n    ErrorHelpers.verifySheetNamesForPDFAndPPT(sheetNames, exportScenarios);\n\n    // Note: the ExportOriginUrl param is listed as optional for the pres layer command we are invoking; however,\n    // recent changes were made that enforced the use of the empty string when invoking this command with no ExportOriginUrl.\n    // see browser-clients/export-powerpoint-options-dialog repo.\n    const verb = VerbId.ExportPowerpointDownload;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportPowerPointAsync',\n      [ParameterId.ExportOriginUrl]: '',\n      [ParameterId.SelectedSheetNames]: sheetNames,\n    };\n\n    return this.execute(verb, parameters)\n      .then<ExportFile>((response) => {\n        const result = response.result as ExportFile;\n        return result;\n      })\n      .catch(() => {\n        throw new TableauError(\n          SharedErrorCodes.PowerPointCreationError,\n          'An error occured while attempting to generate the PowerPoint file.',\n        );\n      });\n  }\n\n  public async exportPDFAsync(\n    sheetNames: Array<string>,\n    externalExportPdfOptions: ExternalExportPDFOptions,\n    exportScenarios: ExportScenariosForPDFAndPowerPoint,\n  ): Promise<ExportFile> {\n    ErrorHelpers.verifyExportPDFOptions(externalExportPdfOptions);\n    ErrorHelpers.verifySheetNamesForPDFAndPPT(sheetNames, exportScenarios);\n\n    const internalExportPdfOptions: InternalExportPDFOptions = await this.getExportPDFOptionsAsync();\n    ExportHelpers.updateInternalExportPDFOptions(internalExportPdfOptions, externalExportPdfOptions, sheetNames);\n\n    const verb = VerbId.ExportPdfDownload;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportPDFAsync',\n      [ParameterId.ExportPdfOptions]: internalExportPdfOptions,\n    };\n\n    return this.execute(verb, parameters)\n      .then<ExportFile>((response) => {\n        const result = response.result as ExportFile;\n        return result;\n      })\n      .catch(() => {\n        throw new TableauError(SharedErrorCodes.PDFCreationError, 'Unable to create PDF because something went wrong. Try again.');\n      });\n  }\n\n  public getExportPDFOptionsAsync(): Promise<InternalExportPDFOptions> {\n    const verb = VerbId.GetExportPdfOptions;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getExportPdfOptionsAsync',\n    };\n    return this.execute(verb, parameters).then<InternalExportPDFOptions>((response) => {\n      const result = response.result as InternalExportPDFOptions;\n      return result;\n    });\n  }\n}\n","import { ApiMenuType, ContextMenuOptions } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ExternalContextMenuService } from '../ExternalContextMenuService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ExternalContextMenuServiceImpl extends ServiceImplBase implements ExternalContextMenuService {\n  public get serviceName(): string {\n    return ServiceNames.ExternalContextMenu;\n  }\n\n  public appendContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, config: ContextMenuOptions): Promise<string> {\n    const verb = VerbId.AppendExternalMenuItem;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'appendContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuItemDisplayName]: config.displayName,\n    };\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      const newMenuItemId = response.result as string;\n      return newMenuItemId;\n    });\n  }\n\n  public removeContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    const verb = VerbId.RemoveExternalMenuItem;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'removeContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuItemId]: menuItemId,\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public executeContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    const verb = VerbId.ExecuteExternalMenuItem;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'executeContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuItemId]: menuItemId,\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public renameContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, menuHeader: string, menuDescription: string): Promise<void> {\n    const verb = VerbId.RenameExternalMenu;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'renameContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuHeader]: menuHeader,\n      [ParameterId.ExternalMenuDescription]: menuDescription,\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  DateRangeType,\n  EmbeddingErrorCodes,\n  ErrorCodes,\n  FilterDomainType,\n  FilterType as ExternalFilterType,\n  SharedErrorCodes,\n} from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport { ExecuteParameters, FilterType, ParameterId, VerbId, VisualId } from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../../../ApiShared';\nimport { ExternalToInternalEnumMappings as ExternalEnumConverter } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { InternalToExternalEnumMappings as InternalEnumConverter } from '../../EnumMappings/InternalToExternalEnumMappings';\nimport {\n  CategoricalDomain,\n  CategoricalFilter,\n  HierarchicalDataValue,\n  HierarchicalFilter,\n  HierarchicalLevelDetail,\n  RangeDomain,\n  RangeFilter,\n  RelativeDateFilter,\n} from '../../Models/FilterModels';\nimport { DataValue } from '../../Models/GetDataModels';\nimport { DataValueFactory } from '../../Utils/DataValueFactory';\nimport { Param } from '../../Utils/Param';\nimport { FilterService } from '../FilterService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class FilterServiceImpl extends ServiceImplBase implements FilterService {\n  public get serviceName(): string {\n    return ServiceNames.Filter;\n  }\n\n  public applyFilterAsync(\n    visualId: VisualId,\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    filterOptions: Contract.FilterOptions,\n  ): Promise<string> {\n    const verb = VerbId.ApplyCategoricalFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n    if (!Array.isArray(values)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'values parameter for applyFilterAsync must be an array');\n    }\n    parameters[ParameterId.FilterValues] = values;\n    parameters[ParameterId.FilterUpdateType] = ExternalEnumConverter.filterUpdateType.convert(updateType);\n    parameters[ParameterId.IsExcludeMode] =\n      filterOptions === undefined || filterOptions.isExcludeMode === undefined ? false : filterOptions.isExcludeMode;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return fieldName;\n    });\n  }\n\n  public applyRangeFilterAsync(visualId: VisualId, fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\n    const verb = VerbId.ApplyRangeFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyRangeFilterAsync',\n    };\n\n    if (filterOptions.min !== undefined && filterOptions.min !== null) {\n      let min: string | number;\n      if (filterOptions.min instanceof Date) {\n        min = Param.serializeDateForPlatform(filterOptions.min);\n      } else {\n        min = filterOptions.min;\n      }\n      parameters[ParameterId.FilterRangeMin] = min;\n    }\n\n    if (filterOptions.max !== undefined && filterOptions.max !== null) {\n      let max: string | number;\n      if (filterOptions.max instanceof Date) {\n        max = Param.serializeDateForPlatform(filterOptions.max);\n      } else {\n        max = filterOptions.max;\n      }\n      parameters[ParameterId.FilterRangeMax] = max;\n    }\n\n    // The null option is used with min+max for 'include-range' or 'include-range-or-null'\n    if (filterOptions.nullOption) {\n      parameters[ParameterId.FilterRangeNullOption] = ExternalEnumConverter.nullOptions.convert(filterOptions.nullOption);\n    }\n\n    parameters[ParameterId.FieldName] = fieldName;\n    parameters[ParameterId.VisualId] = visualId;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      this.apiFilterHandlerCheckForCommandError(response.result as { [key: string]: string });\n      return fieldName;\n    });\n  }\n\n  public applyHierarchicalFilterAsync(\n    visualId: VisualId,\n    fieldName: string,\n    values: Array<string> | Contract.HierarchicalLevels,\n    updateType: Contract.FilterUpdateType,\n    filterOptions: Contract.FilterOptions,\n  ): Promise<string> {\n    const verb = VerbId.HierarchicalFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyHierarchicalFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n\n    const hierarchicalLevels = (values as Contract.HierarchicalLevels).levels;\n\n    if (Array.isArray(hierarchicalLevels) && hierarchicalLevels.length > 0) {\n      parameters[ParameterId.FilterLevels] = hierarchicalLevels;\n    } else if ((values as Array<String>).length > 0) {\n      parameters[ParameterId.FilterValues] = values;\n    } else {\n      // the server command expects empty list for clearing the filter\n      // it also expects eithers FilterLevels or FilterValues to be set\n      parameters[ParameterId.FilterLevels] = [];\n    }\n\n    parameters[ParameterId.FilterUpdateType] = ExternalEnumConverter.filterUpdateType.convert(updateType);\n    parameters[ParameterId.IsExcludeMode] = filterOptions && !!filterOptions.isExcludeMode;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return fieldName;\n    });\n  }\n\n  public clearFilterAsync(visualId: VisualId, fieldName: string): Promise<string> {\n    const verb = VerbId.ClearFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'clearFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n    return this.execute(verb, parameters).then<string>((resposne) => {\n      return fieldName;\n    });\n  }\n\n  public applyRelativeDateFilterAsync(visualId: VisualId, fieldName: string, options: Contract.RelativeDateFilterOptions) {\n    const verb = VerbId.ApplyRelativeDateFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyRelativeDateFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n    parameters[ParameterId.PeriodType] = ExternalEnumConverter.periodType.convert(options.periodType);\n    parameters[ParameterId.DateRangeType] = ExternalEnumConverter.dateRangeType.convert(options.rangeType);\n    if (options.rangeType === DateRangeType.LastN || options.rangeType === DateRangeType.NextN) {\n      if (options.rangeN === undefined || options.rangeN === null) {\n        throw new TableauError(\n          EmbeddingErrorCodes.MissingRangeNForRelativeDateFilters,\n          'Missing rangeN field for a relative date filter of LASTN or NEXTN.',\n        );\n      }\n      parameters[ParameterId.RangeN] = options.rangeN;\n    }\n\n    if (options.anchorDate !== undefined && options.anchorDate !== null) {\n      parameters[ParameterId.AnchorDate] = this.convertAnchorDate(options.anchorDate);\n    }\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return response.result as string;\n    });\n  }\n\n  public getFiltersAsync(visualId: VisualId): Promise<Array<Contract.Filter>> {\n    const verb = VerbId.GetFilters;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getFiltersAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    return this.execute(verb, parameters).then<Array<Contract.Filter>>((response) => {\n      const filters = response.result as Array<InternalContract.Filter>;\n      return this.convertDomainFilters(filters);\n    });\n  }\n\n  public getCategoricalDomainAsync(\n    worksheetName: string,\n    fieldId: string,\n    domainType: FilterDomainType,\n  ): Promise<Contract.CategoricalDomain> {\n    const verb = VerbId.GetCategoricalDomain;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getCategoricalDomainAsync',\n    };\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n\n    parameters[ParameterId.FieldId] = fieldId;\n    parameters[ParameterId.DomainType] = ExternalEnumConverter.filterDomainType.convert(domainType);\n    return this.execute(verb, parameters).then<Contract.CategoricalDomain>((response) => {\n      const domain = response.result as InternalContract.CategoricalDomain;\n      return this.convertCategoricalDomain(domain, domainType);\n    });\n  }\n\n  public getRangeDomainAsync(worksheetName: string, fieldId: string, domainType: FilterDomainType): Promise<Contract.RangeDomain> {\n    const verb = VerbId.GetRangeDomain;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getRangeDomainAsync',\n    };\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n\n    parameters[ParameterId.FieldId] = fieldId;\n    parameters[ParameterId.DomainType] = ExternalEnumConverter.filterDomainType.convert(domainType);\n    return this.execute(verb, parameters).then<Contract.RangeDomain>((response) => {\n      const domain = response.result as InternalContract.RangeDomain;\n\n      return this.convertRangeDomain(domain, domainType);\n    });\n  }\n\n  public getDashboardFiltersAsync(): Promise<Array<Contract.Filter>> {\n    const verb = VerbId.GetDashboardFilters;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getDashboardFiltersAsync',\n    };\n    return this.execute(verb, parameters).then<Array<Contract.Filter>>((response) => {\n      const filters = response.result as Array<InternalContract.Filter>;\n      return this.convertDomainFilters(filters);\n    });\n  }\n\n  public applyDashboardFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    filterOptions: Contract.FilterOptions,\n  ): Promise<string> {\n    const verb = VerbId.DashboardCategoricalFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyDashboardFilterAsync',\n    };\n    parameters[ParameterId.FieldName] = fieldName;\n    parameters[ParameterId.FilterValues] = values;\n    parameters[ParameterId.FilterUpdateType] = ExternalEnumConverter.filterUpdateType.convert(updateType);\n    parameters[ParameterId.IsExcludeMode] = filterOptions && !!filterOptions.isExcludeMode;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return response.result as string;\n    });\n  }\n\n  public async getAppliedWorksheetsAsync(worksheetName: string, fieldId: string): Promise<Array<string>> {\n    const sharedFilterModel = await this.executeGetAppliedWorksheets(worksheetName, fieldId, 'getAppliedWorksheetsAsync');\n    const worksheetNames: string[] = [];\n    sharedFilterModel.worksheets?.map((worksheetInfo: InternalContract.SharedFilterWorksheetModel) => {\n      if (worksheetInfo.isSelected) {\n        worksheetNames.push(worksheetInfo.worksheetName);\n      }\n    });\n    return worksheetNames;\n  }\n\n  public async setAppliedWorksheetsAsync(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    applyToWorksheets: Array<string>,\n  ): Promise<Array<string>> {\n    const sharedFilterModel = await this.executeGetAppliedWorksheets(worksheetName, fieldId, 'getAppliedWorksheetsAsyncInternal');\n    if (!sharedFilterModel || !sharedFilterModel.worksheets) {\n      throw new TableauError(SharedErrorCodes.InternalError, 'This filter does not apply to multiple worksheets');\n    }\n\n    const allowedWorksheets: string[] = [];\n    let activeWorksheet = '';\n    sharedFilterModel.worksheets.forEach((worksheet) => {\n      // Get active worksheet\n      if (worksheet.isActive) {\n        activeWorksheet = worksheet.worksheetName;\n      }\n\n      // Populate allowed worksheets\n      if (worksheet.isSelected || worksheet.isEnabled) {\n        allowedWorksheets.push(worksheet.worksheetName);\n      }\n    });\n\n    if (activeWorksheet === '') {\n      throw new TableauError(SharedErrorCodes.InternalError, 'No active worksheet');\n    }\n\n    if (!applyToWorksheets.includes(activeWorksheet)) {\n      throw new TableauError(SharedErrorCodes.InternalError, `${activeWorksheet} must be included in the applied worksheets`);\n    }\n\n    applyToWorksheets.forEach((sheet) => {\n      // check if it's present within compatible sheets\n      if (!allowedWorksheets.includes(sheet)) {\n        throw new TableauError(SharedErrorCodes.InternalError, `The field ${fieldName} isn't applicable to the worksheet ${sheet}`);\n      }\n    });\n\n    const verb = VerbId.ChangeSharedFilter;\n    const parameters: ExecuteParameters = {};\n    parameters[ParameterId.FunctionName] = 'setAppliedWorksheetsAsync';\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n    parameters[ParameterId.FieldId] = fieldId;\n    parameters[ParameterId.SharedFilterSheets] = applyToWorksheets;\n\n    return this.execute(verb, parameters).then<string[]>((response) => {\n      return applyToWorksheets;\n    });\n  }\n\n  // Helper Methods\n\n  private executeGetAppliedWorksheets(\n    worksheetName: string,\n    fieldId: string,\n    telemetryFunctionName: string,\n  ): Promise<InternalContract.SharedFilterModel> {\n    const verb = VerbId.GetSharedFilter;\n    const parameters: ExecuteParameters = {};\n    parameters[ParameterId.FunctionName] = telemetryFunctionName;\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n    parameters[ParameterId.FieldId] = fieldId;\n\n    return this.execute(verb, parameters).then<InternalContract.SharedFilterModel>((response) => {\n      const sharedFilterModel = response.result as InternalContract.SharedFilterModel;\n      return sharedFilterModel;\n    });\n  }\n\n  private convertDomainFilters(domainFilters: Array<InternalContract.Filter>): Array<Contract.Filter> {\n    const filters: Array<Contract.Filter> = [];\n    domainFilters.forEach((domainFilter) => {\n      switch (domainFilter.filterType) {\n        case FilterType.Categorical: {\n          const filter = domainFilter as InternalContract.CategoricalFilter;\n          if (filter) {\n            filters.push(this.convertCategoricalFilter(filter));\n          } else {\n            throw new Error('Invalid Categorical Filter');\n          }\n          break;\n        }\n\n        case FilterType.Hierarchical: {\n          const filter = domainFilter as InternalContract.HierarchicalFilter;\n          if (filter) {\n            filters.push(this.convertHierarchicalFilter(filter));\n          } else {\n            throw new Error('Invalid Hierarchical Filter');\n          }\n          break;\n        }\n\n        case FilterType.Range: {\n          const filter = domainFilter as InternalContract.RangeFilter;\n          if (filter) {\n            filters.push(this.convertRangeFilter(filter));\n          } else {\n            throw new Error('Invalid Range Filter');\n          }\n          break;\n        }\n\n        case FilterType.RelativeDate: {\n          const filter = domainFilter as InternalContract.RelativeDateFilter;\n          if (filter) {\n            filters.push(this.convertRelativeDateFilter(filter));\n          } else {\n            throw new Error('Invalid Relative Date Filter');\n          }\n          break;\n        }\n\n        default: {\n          break;\n        }\n      }\n    });\n    return filters;\n  }\n\n  private convertCategoricalFilter(domainFilter: InternalContract.CategoricalFilter): Contract.CategoricalFilter {\n    const appliedValues: Array<Contract.DataValue> = domainFilter.values.map((dv) => {\n      return DataValueFactory.MakeFilterDataValue(dv);\n    });\n\n    return new CategoricalFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      FilterType.Categorical,\n      this._registryId,\n      appliedValues,\n      domainFilter.isExclude,\n      domainFilter.isAllSelected,\n    );\n  }\n\n  private convertHierarchicalFilter(domainFilter: InternalContract.HierarchicalFilter): Contract.HierarchicalFilter {\n    const appliedValues: Array<Contract.HierarchicalFilterDataValue> = domainFilter.values.map((hierarchicalDataValue) => {\n      return new HierarchicalDataValue(\n        DataValueFactory.MakeFilterDataValue(hierarchicalDataValue.value),\n        hierarchicalDataValue.hierarchicalPath,\n        hierarchicalDataValue.level,\n      );\n    });\n\n    const levelDetails: Array<Contract.HierarchicalLevelDetail> = domainFilter.levelInfo.map((aLevel) => {\n      return new HierarchicalLevelDetail(\n        aLevel.name,\n        InternalEnumConverter.hierarchicalLevelSelectionState.convert(aLevel.levelSelectionState),\n      );\n    });\n\n    return new HierarchicalFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      FilterType.Hierarchical,\n      this._registryId,\n      domainFilter.dimensionName,\n      domainFilter.hierarchyCaption,\n      domainFilter.levels,\n      levelDetails,\n      appliedValues,\n      domainFilter.isAllSelected,\n    );\n  }\n\n  private convertRangeFilter(domainFilter: InternalContract.RangeFilter): Contract.RangeFilter {\n    const minValue: DataValue = DataValueFactory.MakeFilterDataValue(domainFilter.min);\n    const maxValue: DataValue = DataValueFactory.MakeFilterDataValue(domainFilter.max);\n    return new RangeFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      FilterType.Range,\n      this._registryId,\n      minValue,\n      maxValue,\n      domainFilter.includeNullValues,\n    );\n  }\n\n  private convertRelativeDateFilter(domainFilter: InternalContract.RelativeDateFilter): Contract.RelativeDateFilter {\n    const anchorDateValue: DataValue = DataValueFactory.MakeFilterDataValue(domainFilter.anchorDate);\n    return new RelativeDateFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      ExternalFilterType.RelativeDate,\n      this._registryId,\n      anchorDateValue,\n      InternalEnumConverter.dateStepPeriod.convert(domainFilter.periodType),\n      InternalEnumConverter.dateRangeType.convert(domainFilter.rangeType),\n      domainFilter.rangeN,\n    );\n  }\n\n  private convertCategoricalDomain(domain: InternalContract.CategoricalDomain, domainType: FilterDomainType): Contract.CategoricalDomain {\n    const values: Array<DataValue> = domain.values.map((domainDv) => {\n      return DataValueFactory.MakeFilterDataValue(domainDv);\n    });\n    return new CategoricalDomain(values, domainType);\n  }\n\n  private convertRangeDomain(domain: InternalContract.RangeDomain, domainType: FilterDomainType): Contract.RangeDomain {\n    const min: DataValue = DataValueFactory.MakeFilterDataValue(domain.min);\n    const max: DataValue = DataValueFactory.MakeFilterDataValue(domain.max);\n    return new RangeDomain(min, max, domainType);\n  }\n\n  private convertAnchorDate(anchorDate: Date): string {\n    // Converts a Date object into a string format that the server expects for date/time values.\n    // If anchorDate doesn't represent a valid Date object, any of these would be NaN.\n    const year = anchorDate.getUTCFullYear();\n    const month = anchorDate.getUTCMonth() + 1;\n    const day = anchorDate.getUTCDate();\n    const hh = anchorDate.getUTCHours();\n    const mm = anchorDate.getUTCMinutes();\n    const sec = anchorDate.getUTCSeconds();\n\n    if (isNaN(year) || isNaN(month) || isNaN(day) || isNaN(hh) || isNaN(mm) || isNaN(sec)) {\n      throw new TableauError(EmbeddingErrorCodes.InvalidDateParameter, 'Invalid date parameter: anchorDate');\n    }\n\n    const result = `${year}-${month}-${day} ${hh}:${mm}:${sec}`;\n    return result;\n  }\n\n  private apiFilterHandlerCheckForCommandError(serverPm: { [key: string]: string }) {\n    if (!serverPm[InternalContract.ParameterId.ParameterError]) {\n      return;\n    }\n    if (serverPm[InternalContract.ParameterId.InvalidFieldCaption]) {\n      throw new TableauError(SharedErrorCodes.InvalidFilterFieldName, serverPm[InternalContract.ParameterId.InvalidFieldCaption]);\n    }\n    if (serverPm[InternalContract.ParameterId.InvalidValues]) {\n      throw new TableauError(SharedErrorCodes.InvalidFilterFieldValue, serverPm[InternalContract.ParameterId.InvalidValues]);\n    }\n    if (serverPm[InternalContract.ParameterId.InvalidAggFieldName]) {\n      throw new TableauError(SharedErrorCodes.InvalidAggregationFieldName, serverPm[InternalContract.ParameterId.InvalidAggFieldName]);\n    }\n    throw new TableauError(SharedErrorCodes.ServerError, 'Server Error');\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, IncludeDataValuesOption } from '@tableau/api-external-contract-js';\nimport {\n  ApiShowDataTableFormat,\n  DataTable as DataTableInternalContract,\n  DataTableReader as DataTableReaderInternalContract,\n  ExecuteParameters,\n  HighlightedMarksTable,\n  ParameterId,\n  SelectedMarksTable,\n  UnderlyingDataTable,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport { v4 as uuidv4 } from 'uuid';\nimport { TableauError } from '../../../ApiShared';\nimport { ExternalToInternalEnumMappings } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { Column, DataTable, MarkInfo } from '../../Models/GetDataModels';\nimport { DataTableReader } from '../../Models/GetDataTableReaderModels';\nimport { DataValueFactory } from '../../Utils/DataValueFactory';\nimport { GetDataService, GetDataType } from '../GetDataService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class GetDataServiceImpl extends ServiceImplBase implements GetDataService {\n  // The extension/embedding instance uses the same cache for all DataTableReaders.\n  private viewDataTableCacheId: string = uuidv4();\n\n  public get serviceName(): string {\n    return ServiceNames.GetData;\n  }\n\n  public getMaxRowLimit(): number {\n    return 10000;\n  }\n\n  public getViewDataTableCacheId(): string {\n    return this.viewDataTableCacheId;\n  }\n\n  private getLimitedMaxRows(requestedRows: number, rowCountLimit: number): number {\n    return requestedRows > 0 && requestedRows < rowCountLimit ? requestedRows : rowCountLimit;\n  }\n\n  public getUnderlyingDataAsync(\n    visualId: VisualId,\n    getType: GetDataType,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTable> {\n    // Create all of our parameters\n    const summaryData = getType === GetDataType.Summary;\n    const functionName = summaryData ? 'getSummaryDataAsync' : 'getUnderlyingDataAsync';\n    const verb = summaryData ? VerbId.GetDataSummaryData : VerbId.GetUnderlyingData;\n    const requestMaxRows = verb === VerbId.GetUnderlyingData ? this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1) : maxRows;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: functionName,\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.IgnoreAliases] = ignoreAliases;\n    parameters[ParameterId.IgnoreSelection] = ignoreSelection;\n    parameters[ParameterId.IncludeAllColumns] = includeAllColumns;\n    parameters[ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById);\n    parameters[ParameterId.MaxRows] = requestMaxRows;\n    parameters[ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption);\n\n    return this.execute(verb, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, responseData.isSummary);\n    });\n  }\n\n  public getSummaryDataReaderAsync(\n    visualId: VisualId,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTableReader> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getSummaryDataReaderAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.PageRowCount]: pageRowCount,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.IgnoreSelection]: ignoreSelection,\n      [ParameterId.IncludeAllColumns]: includeAllColumns,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetDataSummaryDataReader, parameters).then<DataTableReader>((response) => {\n      const responseData = response.result as DataTableReaderInternalContract;\n\n      return new DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, this._registryId);\n    });\n  }\n\n  public getSummaryColumnsInfoAsync(visualId: VisualId): Promise<Array<Contract.Column>> {\n    // Create all the parameters for GetDataType of Summary with 1 row, and only native values\n    // Then return just the columns\n    const verb = VerbId.GetDataSummaryData;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getSummaryColumnsInfoAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.IgnoreAliases]: true,\n      [ParameterId.IgnoreSelection]: true,\n      [ParameterId.IncludeAllColumns]: true,\n      [ParameterId.MaxRows]: 1,\n      [ParameterId.ShowDataTableFormat]: ApiShowDataTableFormat.NativeValuesOnly,\n    };\n\n    return this.execute(verb, parameters).then<Array<Contract.Column>>((response) => {\n      const underlyingDataTable = response.result as UnderlyingDataTable;\n      const dataTable = underlyingDataTable.data;\n      const columns = dataTable.headers.map((h) => new Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index));\n      return columns;\n    });\n  }\n\n  public getSelectedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getSelectedMarksAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetSelectedMarks, parameters).then<Contract.MarksCollection>((response) => {\n      const responseData = response.result as SelectedMarksTable;\n      return {\n        data: responseData.data.map((table) => this.processResultsTable(table, true)),\n      };\n    });\n  }\n\n  public getHighlightedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getHighlightedMarksAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetHighlightedMarks, parameters).then<Contract.MarksCollection>((response) => {\n      const responseData = response.result as HighlightedMarksTable;\n      return {\n        data: responseData.data.map((table) => this.processResultsTable(table, true)),\n      };\n    });\n  }\n\n  public getDataSourceDataAsync(\n    dataSourceId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getDataSourceDataAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.MaxRows]: this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1),\n      [ParameterId.ColumnsToInclude]: this.verifyIncludeColumnArray(columnsToInclude),\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetDataSourceData, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, false);\n    });\n  }\n\n  public getLogicalTableDataAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getLogicalTableDataAsync',\n      [ParameterId.ColumnsToInclude]: columnsToInclude,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.DataSourceId]: datasourceId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.MaxRows]: this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetLogicalTableData, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, false);\n    });\n  }\n\n  public getLogicalTableDataReaderAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTableReader> {\n    pageRowCount = this.getLimitedMaxRows(pageRowCount, this.getMaxRowLimit());\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getLogicalTableDataReaderAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.DataSourceId]: datasourceId,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.PageRowCount]: pageRowCount,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetLogicalTableDataReader, parameters).then<DataTableReader>((response) => {\n      const responseData = response.result as DataTableReaderInternalContract;\n\n      return new DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, this._registryId);\n    });\n  }\n\n  public getUnderlyingTableDataAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getUnderlyingTableDataAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.IgnoreSelection]: ignoreSelection,\n      [ParameterId.IncludeAllColumns]: includeAllColumns,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.MaxRows]: this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetUnderlyingTableData, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, false);\n    });\n  }\n\n  public getUnderlyingTableDataReaderAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader> {\n    pageRowCount = this.getLimitedMaxRows(pageRowCount, this.getMaxRowLimit());\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getUnderlyingTableDataReaderAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.IgnoreSelection]: ignoreSelection,\n      [ParameterId.IncludeAllColumns]: includeAllColumns,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n      [ParameterId.PageRowCount]: pageRowCount,\n    };\n\n    return this.execute(VerbId.GetUnderlyingTableDataReader, parameters).then<DataTableReader>((response) => {\n      const responseData = response.result as DataTableReaderInternalContract;\n\n      return new DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, this._registryId);\n    });\n  }\n\n  private static summaryTableId = '';\n\n  public getPageAsync(tableId: string, pageNumber: number, pageSize: number): Promise<Contract.DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getPageAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.ViewDataTableId]: tableId,\n      [ParameterId.DataRowIndex]: pageNumber * pageSize,\n    };\n\n    return this.execute(VerbId.GetDataTableReaderPage, parameters).then<DataTable>((response) => {\n      const responseData = response.result as DataTableInternalContract;\n      return this.processResultsPage(responseData, tableId === GetDataServiceImpl.summaryTableId ? true : false);\n    });\n  }\n\n  public releaseAsync(tableId: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'release',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.ViewDataTableId]: tableId,\n    };\n\n    return this.execute(VerbId.ReleaseDataTableReader, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  private verifyIncludeColumnArray(columns: Array<string>): Array<string> {\n    // columns must be a valid array\n    if (!Array.isArray(columns)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'columnsToInclude and columnsToIncludeById must be valid arrays');\n    }\n\n    // Remove any duplicates from the input array\n    const columnsAsSet: Set<string> = new Set(columns);\n    return Array.from(columnsAsSet);\n  }\n\n  protected processResultsTable(responseData: DataTableInternalContract, isSummary: boolean): DataTable {\n    const headers = responseData.headers.map((h) => new Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index));\n\n    // TODO This should be controlled by a flag indicating whether this api will respond marks info or not\n    let marks;\n    if (responseData.marks) {\n      marks = responseData.marks.map((h) => new MarkInfo(h.type, h.color, h.tupleId));\n    }\n\n    // Limit+1 is our sentinal that underlying data contains more rows than user is allowed to fetch.\n    // Remove the last element so we always return MaxRowLimit\n    const isTotalRowCountLimited = isSummary === false && responseData.dataTable.length === this.getMaxRowLimit() + 1;\n    if (isTotalRowCountLimited) {\n      responseData.dataTable.length -= 1;\n    }\n\n    const table = responseData.dataTable.map((row) => {\n      return row.map((cell, index) => {\n        return DataValueFactory.MakeTableDataValue(cell, headers[index].dataType);\n      });\n    });\n\n    if (marks) {\n      return new DataTable(table, headers, table.length, isTotalRowCountLimited, isSummary, marks);\n    }\n    return new DataTable(table, headers, table.length, isTotalRowCountLimited, isSummary);\n  }\n\n  protected processResultsPage(responseData: DataTableInternalContract, isSummary: boolean): DataTable {\n    const headers = responseData.headers.map((h) => new Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index));\n\n    let marks;\n    if (responseData.marks) {\n      marks = responseData.marks.map((h) => new MarkInfo(h.type, h.color, h.tupleId));\n    }\n\n    const table = responseData.dataTable.map((row) => {\n      return row.map((cell, index) => {\n        return DataValueFactory.MakeTableDataValue(cell, headers[index].dataType);\n      });\n    });\n\n    if (marks) {\n      return new DataTable(table, headers, table.length, false, isSummary, marks);\n    }\n    return new DataTable(table, headers, table.length, false, isSummary);\n  }\n}\n","import { NotificationService } from '../NotificationService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { NotificationServiceImplBase } from './NotificationServiceImplBase';\n\nexport class NotificationServiceImpl extends NotificationServiceImplBase implements NotificationService {\n  public get serviceName(): string {\n    return ServiceNames.Notification;\n  }\n}\n","import { InternalApiDispatcher, Model, Notification, NotificationId } from '@tableau/api-internal-contract-js';\nimport { UnregisterFn } from '../NotificationService';\n\nexport class Registration {\n  public constructor(private _filterFn: (notificationModel: Model) => boolean, private _callbackFn: (notificationModel: Model) => void) {\n    // Nothing Here\n  }\n\n  public onNotification(notificationModel: Model): void {\n    if (this._filterFn(notificationModel)) {\n      this._callbackFn(notificationModel);\n    }\n  }\n}\n\nexport class NotificationServiceImplBase {\n  private _handlers: { [notificationId: string]: Array<Registration> };\n\n  public constructor(private dispatcher: InternalApiDispatcher) {\n    this._handlers = {};\n    this.dispatcher.registerNotificationHandler(this.onNotification.bind(this));\n  }\n\n  public registerHandler(id: NotificationId, filterFn: (model: Model) => boolean, handler: (model: Model) => void): UnregisterFn {\n    const handlers = this._handlers[id] || new Array<Registration>();\n    const registration = new Registration(filterFn, handler);\n    handlers.push(registration);\n    this._handlers[id] = handlers;\n    return () => this.removeRegistration(id, registration);\n  }\n\n  private hasHandlersForNotificationType(id: NotificationId): boolean {\n    // eslint-disable-next-line no-prototype-builtins\n    return this._handlers.hasOwnProperty(id);\n  }\n\n  private onNotification(notification: Notification): void {\n    if (!this.hasHandlersForNotificationType(notification.notificationId)) {\n      return;\n    }\n\n    // Go through and check for all the handlers of this particular notification\n    this._handlers[notification.notificationId].forEach((h) => h.onNotification(notification.data));\n  }\n\n  private removeRegistration(id: NotificationId, registration: Registration): void {\n    if (!this.hasHandlersForNotificationType(id)) {\n      return;\n    }\n\n    this._handlers[id] = this._handlers[id].filter((reg) => reg !== registration);\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, Model, ParameterId, ParameterInfo, SheetPath, VerbId } from '@tableau/api-internal-contract-js';\nimport { ParameterImpl } from '../../Impl/ParameterImpl';\nimport { TableauError } from '../../TableauError';\nimport { ParametersService } from '../ParametersService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ParametersServiceImpl extends ServiceImplBase implements ParametersService {\n  public get serviceName(): string {\n    return ServiceNames.Parameters;\n  }\n\n  public getParametersForSheetAsync(sheetPath: SheetPath): Promise<Array<ParameterImpl>> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'getParametersForSheetAsync',\n      [ParameterId.SheetPath]: sheetPath,\n    };\n\n    return this.getParametersAsync(parameters);\n  }\n\n  public getAllParametersAsync(): Promise<Array<ParameterImpl>> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'getParametersForSheetAsync',\n    };\n\n    return this.getParametersAsync(parameters);\n  }\n\n  private getParametersAsync(inputParameters: ExecuteParameters): Promise<Array<ParameterImpl>> {\n    return this.execute(VerbId.GetParametersForSheet, inputParameters).then((response) => {\n      const result = response.result as Array<ParameterInfo>;\n      return result.map((parameterInfo) => {\n        return new ParameterImpl(parameterInfo, this._registryId);\n      });\n    });\n  }\n\n  public changeParameterValueAsync(fieldName: string, newValue: string): Promise<ParameterInfo> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'changeParameterValueAsync',\n      [ParameterId.ParameterFieldName]: fieldName,\n      [ParameterId.ParameterValue]: newValue,\n    };\n\n    return this.execute(VerbId.ChangeParameterValue, parameters).then((response) => {\n      const result = response.result as ParameterInfo;\n      return result;\n    });\n  }\n\n  public findParameterByNameAsync(name: string): Promise<ParameterImpl | undefined> {\n    return this.findParameterAsync(name, undefined);\n  }\n\n  public findParameterByGlobalFieldNameAsync(fieldName: string): Promise<ParameterImpl | undefined> {\n    return this.findParameterAsync(undefined, fieldName);\n  }\n\n  private findParameterAsync(name: string | undefined, fieldName: string | undefined): Promise<ParameterImpl | undefined> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'findParameterAsync',\n    };\n    if (name !== undefined) {\n      parameters[ParameterId.ParameterCaption] = name;\n    } else if (fieldName !== undefined) {\n      parameters[ParameterId.ParameterFieldName] = fieldName;\n    } else {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'name or fieldName must be provided to find parameter');\n    }\n\n    return this.execute(VerbId.FindParameter, parameters).then((response) => {\n      const instanceOfParameterInfo = (object: Model): object is ParameterInfo => {\n        return 'fieldName' in object;\n      };\n\n      // We need to check to see if we got a valid response back again\n      if (instanceOfParameterInfo(response.result)) {\n        const result = response.result;\n        return new ParameterImpl(result, this._registryId);\n      } else {\n        return undefined;\n      }\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  ExecuteParameters,\n  ParameterId,\n  QuantitativeIncludedValues,\n  SelectionUpdateType as SelectionUpdateTypeInternal,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport {\n  DimensionSelectionModel,\n  HierarchicalSelectionModel,\n  HoverTupleInteractionModel,\n  RangeSelectionModel,\n  SelectTuplesInteractionModel,\n  SelectionModelsContainer,\n  TupleSelectionModel,\n  ValueSelectionModel,\n} from '../../Models/SelectionModels';\nimport { TableauError } from '../../TableauError';\nimport { Param } from '../../Utils/Param';\nimport { SelectionService } from '../SelectionService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class SelectionServiceImpl extends ServiceImplBase implements SelectionService {\n  public get serviceName(): string {\n    return ServiceNames.Selection;\n  }\n\n  /**\n   * Method to clear all the selected marks for the given worksheet.\n   *\n   * @param visualId\n   */\n  public clearSelectedMarksAsync(visualId: VisualId): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'clearSelectedMarksAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.ClearSelectedMarks, parameters).then<void>((response) => {\n      return; // Expecting an empty model and hence the void response.\n    });\n  }\n\n  /**\n   * Method to select marks for the given worksheet.\n   *\n   * @param visualId\n   * @param selectionCriteria\n   * @param selectionUpdateType\n   */\n  public selectMarksByValueAsync(\n    visualId: VisualId,\n    selectionCriterias: Array<Contract.SelectionCriteria>,\n    selectionUpdateType: Contract.SelectionUpdateType,\n  ): Promise<void> {\n    if (selectionCriterias.length === 0) {\n      throw new TableauError(Contract.ErrorCodes.InvalidParameter, 'Selection criteria missing for selecting marks by value');\n    }\n\n    const selectionType: string = this.validateSelectionUpdateType(selectionUpdateType);\n    const selectionModelContainer: SelectionModelsContainer = this.parseSelectionMarks(selectionCriterias);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'selectMarksByValueAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.SelectionUpdateType]: selectionType,\n    };\n\n    if (selectionModelContainer.hierModelArr && selectionModelContainer.hierModelArr.length) {\n      parameters[ParameterId.HierValSelectionModels] = selectionModelContainer.hierModelArr;\n    }\n    if (selectionModelContainer.quantModelArr && selectionModelContainer.quantModelArr.length) {\n      parameters[ParameterId.QuantRangeSelectionModels] = selectionModelContainer.quantModelArr;\n    }\n    if (selectionModelContainer.dimModelArr && selectionModelContainer.dimModelArr.length) {\n      parameters[ParameterId.DimValSelectionModels] = selectionModelContainer.dimModelArr;\n    }\n\n    return this.execute(VerbId.SelectByValue, parameters).then<void>((response) => {\n      this.apiFilterHandlerCheckForCommandError(response.result as { [key: string]: string });\n      return;\n    });\n  }\n\n  /**\n   * Method to execute hover actions and render tooltip for a given tuple representing a mark in the visualization.\n   * If the tooltip parameter is included it will show the tooltip on hover. If not, no tooltip is shown.\n   *\n   * @param visualId\n   * @param hoveredTuple\n   * @param tooltip\n   * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error\n   */\n  public hoverTupleAsync(\n    visualId: VisualId,\n    hoveredTuple?: number,\n    tooltip?: Contract.TooltipContext | null,\n    allowHoverActions?: boolean,\n  ): Promise<void> {\n    let interactionModel = new HoverTupleInteractionModel(\n      visualId,\n      this.ensureTupleIDIsNonNegative(hoveredTuple),\n      tooltip,\n      allowHoverActions,\n    );\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'hoverTupleAsync',\n      [ParameterId.HoverTupleInteraction]: interactionModel,\n    };\n\n    return this.execute(VerbId.RaiseHoverTupleNotification, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  /**\n   * Method to modify selection, execute select actions and render tooltip for a given list of tuples representing a mark or marks in the visualization.\n   * If the tooltip parameter is included it will show the tooltip on select. If not, no tooltip is shown.\n   *\n   * @param visualId\n   * @param selectedTuples\n   * @param selectOption\n   * @param tooltip\n   * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error\n   */\n  public selectTuplesAsync(\n    visualId: VisualId,\n    selectedTuples: Array<number>,\n    selectOption: Contract.SelectOptions,\n    tooltip?: Contract.TooltipContext,\n  ): Promise<void> {\n    let interactionModel = new SelectTuplesInteractionModel(visualId, selectedTuples, selectOption, tooltip);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'selectTuplesAsync',\n      [ParameterId.SelectTuplesInteraction]: interactionModel,\n    };\n\n    return this.execute(VerbId.RaiseSelectTuplesNotification, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  private apiFilterHandlerCheckForCommandError(serverPm: { [key: string]: string }) {\n    if (!serverPm[ParameterId.ParameterError]) {\n      return;\n    }\n    if (serverPm[ParameterId.InvalidFields]) {\n      throw new TableauError(Contract.SharedErrorCodes.InvalidSelectionFieldName, serverPm[ParameterId.InvalidFields]);\n    }\n    if (serverPm[ParameterId.InvalidValues]) {\n      throw new TableauError(Contract.SharedErrorCodes.InvalidSelectionValue, serverPm[ParameterId.InvalidValues]);\n    }\n    if (serverPm[ParameterId.InvalidDates]) {\n      throw new TableauError(Contract.SharedErrorCodes.InvalidSelectionDate, serverPm[ParameterId.InvalidDates]);\n    }\n  }\n\n  /**\n   * Method to select marks for the given worksheet.\n   *\n   * @param visualId\n   * @param MarkInfo\n   * @param selectionUpdateType\n   */\n  public selectMarksByIdAsync(\n    visualId: VisualId,\n    marks: Array<Contract.MarkInfo>,\n    selectionUpdateType: Contract.SelectionUpdateType,\n  ): Promise<void> {\n    if (marks.length === 0) {\n      throw new TableauError(Contract.ErrorCodes.InvalidParameter, 'Marks info missing for selecting marks by Id');\n    }\n\n    const selectionType: string = this.validateSelectionUpdateType(selectionUpdateType);\n    const selectionModelContainer: SelectionModelsContainer = this.parseSelectionIds(marks);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'selectMarksByIdAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.SelectionUpdateType]: selectionType,\n      [ParameterId.Selection]: selectionModelContainer.selection,\n    };\n    return this.execute(VerbId.SelectByValue, parameters).then<void>((response) => {\n      // Expecting an empty model and hence the void response.\n      return;\n      // TODO Investigate the error response with multiple output params and throw error accordingly.\n    });\n  }\n\n  /**\n   * Method to prepare the pres models for selection by MarksInfo\n   * @param marks\n   */\n  private parseSelectionIds(marks: Array<Contract.MarkInfo>): SelectionModelsContainer {\n    const ids: Array<string> = [];\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n    for (let i = 0; i < marks.length; i++) {\n      const tupleId: number | undefined = marks[i].tupleId;\n      if (tupleId !== undefined && tupleId !== null) {\n        // If tuple id is provided use that instead of pair\n        ids.push(tupleId.toString()); // collect the tuple ids\n      } else {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'tupleId parsing error');\n      }\n    }\n    if (ids.length !== 0) {\n      // tuple ids based selection\n      const tupleSelectionModel: TupleSelectionModel = new TupleSelectionModel();\n      tupleSelectionModel.selectionType = 'tuples';\n      tupleSelectionModel.objectIds = ids;\n      selectionModelContainer.selection = tupleSelectionModel;\n    }\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to prepare the pres models for selection by values.\n   *\n   * Supports 3 types for selection:\n   * 1) Hierarchical value based selection\n   * 2) Range value based selection\n   * 3) Dimension value based selection\n   *\n   * @param marks\n   */\n  private parseSelectionMarks(selectionCriterias: Array<Contract.SelectionCriteria>): SelectionModelsContainer {\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n\n    for (let i = 0; i < selectionCriterias.length; i++) {\n      const st = selectionCriterias[i];\n      if (!(st.fieldName && st.value !== undefined && st.value !== null)) {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'Selection Criteria parsing error');\n      }\n\n      const catRegex = new RegExp('([[A-Za-z0-9]+]).*', 'g');\n      const rangeOption = st.value as Contract.RangeValue;\n      if (catRegex.test(st.fieldName)) {\n        // Hierarchical value selection\n        const hierModel: HierarchicalSelectionModel = this.addToParamsList(st.fieldName, st.value) as HierarchicalSelectionModel;\n        selectionModelContainer.hierModelArr.push(hierModel);\n      } else if (rangeOption.min !== undefined && rangeOption.max !== undefined) {\n        // Range value selection\n        const quantModel: RangeSelectionModel = this.addToRangeParamsList(st.fieldName, rangeOption);\n        selectionModelContainer.quantModelArr.push(quantModel);\n      } else {\n        // Dimension value selection\n        const dimModel: DimensionSelectionModel = this.addToParamsList(st.fieldName, st.value) as DimensionSelectionModel;\n        selectionModelContainer.dimModelArr.push(dimModel);\n      }\n    }\n\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to transform the key value pair into value based pres model object.\n   *\n   * @param valueSelectionModel\n   * @param fieldName\n   * @param value\n   */\n  private addToParamsList(fieldName: string, value: Contract.CategoricalValue | Contract.RangeValue): ValueSelectionModel {\n    const valueSelectionModel: ValueSelectionModel = new ValueSelectionModel();\n    const markValues: Array<string> = [];\n\n    if (value instanceof Array) {\n      const valueArr: Array<string> = value;\n      for (let i = 0; i < valueArr.length; i++) {\n        markValues.push(Param.serializeParameterValue(valueArr[i]));\n      }\n    } else {\n      markValues.push(Param.serializeParameterValue(value));\n    }\n\n    valueSelectionModel.qualifiedFieldCaption = fieldName;\n    valueSelectionModel.selectValues = markValues;\n    return valueSelectionModel;\n  }\n\n  /**\n   * Method to transform the key value pair into range based selection pres model.\n   *\n   * TODO: Need to handle the parsing of date type values.\n   *\n   * @param valueSelectionModel\n   * @param fieldName\n   * @param value\n   */\n  private addToRangeParamsList(fieldName: string, value: Contract.RangeValue): RangeSelectionModel {\n    const rangeSelectionModel: RangeSelectionModel = new RangeSelectionModel();\n    rangeSelectionModel.qualifiedFieldCaption = fieldName;\n    if (value.max !== undefined && value.max !== null) {\n      rangeSelectionModel.maxValue = Param.serializeParameterValue(value.max);\n    }\n    if (value.min !== undefined && value.min !== null) {\n      rangeSelectionModel.minValue = Param.serializeParameterValue(value.min);\n    }\n    rangeSelectionModel.included = this.validateNullOptionType(value.nullOption);\n    return rangeSelectionModel;\n  }\n\n  /**\n   * Method to validate the selection update type.\n   *\n   * @param selectionUpdateType\n   */\n  private validateSelectionUpdateType(selectionUpdateType: Contract.SelectionUpdateType): string {\n    if (selectionUpdateType === Contract.SelectionUpdateType.Replace) {\n      return SelectionUpdateTypeInternal.Replace;\n    } else if (selectionUpdateType === Contract.SelectionUpdateType.Add) {\n      return SelectionUpdateTypeInternal.Add;\n    } else if (selectionUpdateType === Contract.SelectionUpdateType.Remove) {\n      return SelectionUpdateTypeInternal.Remove;\n    }\n    return SelectionUpdateTypeInternal.Replace;\n  }\n\n  /**\n   * Method to validate the include type for range selection.\n   *\n   * @param nullOption\n   */\n  private validateNullOptionType(nullOption: Contract.FilterNullOption | undefined): string {\n    if (nullOption) {\n      if (nullOption === Contract.FilterNullOption.NullValues) {\n        return QuantitativeIncludedValues.IncludeNull;\n      } else if (nullOption === Contract.FilterNullOption.NonNullValues) {\n        return QuantitativeIncludedValues.IncludeNonNull;\n      } else if (nullOption === Contract.FilterNullOption.AllValues) {\n        return QuantitativeIncludedValues.IncludeAll;\n      }\n    }\n\n    return QuantitativeIncludedValues.IncludeAll;\n  }\n\n  private ensureTupleIDIsNonNegative(tupleId?: number): number {\n    if (tupleId && tupleId > 0) {\n      return tupleId;\n    }\n\n    // 0 will not refer to a valid tuple (since tuple ids are 1-based),\n    // but can be used for clearing the current hover or selection\n    return 0;\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ExecuteResponse, InternalApiDispatcher, InternalTableauError, VerbId } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../../EnumMappings/InternalToExternalEnumMappings';\nimport { TableauError } from '../../TableauError';\nimport { ShouldThrow } from '../../Utils/EnumConverter';\n\n/**\n * Each ServceImpl should extend this base class for the sake of\n * proper error handling.  This base handles the conversion\n * from internal errors to external errors that we throw to developers\n */\nexport class ServiceImplBase {\n  public constructor(private _dispatcher: InternalApiDispatcher, protected _registryId: number) {}\n\n  protected execute(verb: VerbId, params: ExecuteParameters): Promise<ExecuteResponse> {\n    return this._dispatcher.execute(verb, params).catch((error) => {\n      // Any internal error that comes from the dispatcher should be converted\n      // to an external error using the enum mapper for error codes.\n      const internalError = error as InternalTableauError;\n      const externalErrorCode: ErrorCodes = InternalToExternalEnumMappings.errorCode.convert(internalError.errorCode, ShouldThrow.No);\n      throw new TableauError(externalErrorCode, internalError.message);\n    });\n  }\n}\n","import { SheetSize } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { SizeService } from '../SizeService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class SizeServiceImpl extends ServiceImplBase implements SizeService {\n  public get serviceName(): string {\n    return ServiceNames.Size;\n  }\n\n  changeSizeAsync(name: string, newSize: SheetSize): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'changeSizeAsync',\n      [ParameterId.SheetName]: name,\n      [ParameterId.MinHeight]: newSize.minSize?.height || 0,\n      [ParameterId.MinWidth]: newSize.minSize?.width || 0,\n      [ParameterId.MaxHeight]: newSize.maxSize?.height || 0,\n      [ParameterId.MaxWidth]: newSize.maxSize?.width || 0,\n    };\n\n    return this.execute(VerbId.SetSheetSize, parameters).then<void>((_response) => {\n      return;\n    });\n  }\n}\n","import { ExecuteParameters, ParameterId, StoryPointModel, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { StoryActivationService } from '../StoryActivationService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class StoryActivationServiceImpl extends ServiceImplBase implements StoryActivationService {\n  public get serviceName(): string {\n    return ServiceNames.StoryActivation;\n  }\n\n  activateNextStoryPointAsync(): Promise<void> {\n    const verb = VerbId.ActivateNextStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activateNextStoryPointAsync',\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  activatePreviousStoryPointAsync(): Promise<void> {\n    const verb = VerbId.ActivatePreviousStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activatePreviousStoryPointAsync',\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  activateStoryPointAsync(index: number): Promise<void> {\n    const verb = VerbId.ActivateStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activateStoryPointAsync',\n    };\n    parameters[ParameterId.StoryPointIndex] = index;\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  revertStoryPointAsync(index: number): Promise<StoryPointModel> {\n    const verb = VerbId.RevertStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'revertStoryPointAsync',\n    };\n    parameters[ParameterId.StoryPointIndex] = index;\n\n    return this.execute(verb, parameters).then<StoryPointModel>((response) => {\n      return response.result as StoryPointModel;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ParameterId, VerbId, VisualId, VisualSpecification } from '@tableau/api-internal-contract-js';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { VisualModelService } from '../VisualModelService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class VisualModelServiceImpl extends ServiceImplBase implements VisualModelService {\n  public get serviceName(): string {\n    return ServiceNames.VisualModel;\n  }\n\n  public getVisualSpecificationAsync(visualId: VisualId): Promise<Contract.VisualSpecification> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getVisualSpecificationAsync',\n      [ParameterId.WorksheetName]: visualId.worksheet,\n    };\n\n    return this.execute(VerbId.GetVisualSpecification, parameters).then<Contract.VisualSpecification>((response) => {\n      const result = response.result as VisualSpecification;\n      return result;\n    });\n  }\n}\n","import { CustomViewModel, ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { CustomViewImpl } from '../../Impl/CustomViewImpl';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { VizService } from '../VizService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class VizServiceImpl extends ServiceImplBase implements VizService {\n  public get serviceName(): string {\n    return ServiceNames.Viz;\n  }\n\n  public createVizImageAsync(inputSpec: object): Promise<string> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'createVizImageAsync',\n      [ParameterId.VizAPIInputJson]: JSON.stringify(inputSpec),\n    };\n\n    return this.execute(VerbId.VizAPI, parameters).then((response) => {\n      const result = response.result as string;\n      return result;\n    });\n  }\n\n  public activateSheetAsync(name: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activateSheetAsync',\n      [ParameterId.SwitchToSheetName]: name,\n    };\n\n    return this.execute(VerbId.ActivateSheet, parameters).then(() => {\n      return;\n    });\n  }\n\n  public getCustomViewsAsync(): Promise<Array<CustomViewImpl>> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getCustomViewsAsync',\n    };\n\n    return this.execute(VerbId.GetCustomViews, parameters).then<Array<CustomViewImpl>>((response) => {\n      const customViews = response.result as Array<CustomViewModel>;\n      return customViews.map((customView: CustomViewModel) => {\n        return new CustomViewImpl(customView, this._registryId);\n      });\n    });\n  }\n\n  public showCustomViewAsync(customViewName?: string | null): Promise<CustomViewImpl | undefined> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'showCustomViewAsync',\n      [ParameterId.CustomViewName]: customViewName || '', // a falsey value means \"show original view\"\n    };\n\n    return this.execute(VerbId.ShowCustomView, parameters).then<CustomViewImpl | undefined>((response) => {\n      const customView = response.result as CustomViewModel;\n      return customView?.luid ? new CustomViewImpl(customView, this._registryId) : undefined;\n    });\n  }\n\n  public removeCustomViewAsync(customViewName: string): Promise<CustomViewImpl> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'removeCustomViewAsync',\n      [ParameterId.CustomViewName]: customViewName,\n    };\n\n    return this.execute(VerbId.RemoveCustomView, parameters).then<CustomViewImpl>((response) => {\n      const customView = response.result as CustomViewModel;\n      return new CustomViewImpl(customView, this._registryId);\n    });\n  }\n\n  public saveCustomViewAsync(customViewName: string): Promise<CustomViewImpl> {\n    // CustomViewIsDefault is a required parameter, but our API has not been updated to allow it to be specified yet.\n    // We should add a 'default' parameter to the interface.\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'saveCustomViewAsync',\n      [ParameterId.CustomViewName]: customViewName,\n      [ParameterId.CustomViewIsDefault]: false,\n    };\n\n    return this.execute(VerbId.SaveWorkbookAsCustomView, parameters).then<CustomViewImpl>((response) => {\n      const customView = response.result as CustomViewModel;\n      return new CustomViewImpl(customView, this._registryId);\n    });\n  }\n\n  public setActiveCustomViewAsDefaultAsync(): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'setActiveCustomViewAsDefaultAsync',\n    };\n\n    return this.execute(VerbId.SetActiveCustomViewAsDefault, parameters).then(() => {\n      return;\n    });\n  }\n\n  public saveAsync(customView: CustomViewImpl): Promise<CustomViewImpl> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'saveAsync',\n      [ParameterId.CustomViewLuid]: customView.luid,\n      [ParameterId.CustomViewName]: customView.name,\n      [ParameterId.CustomViewIsDefault]: customView.isDefault,\n      [ParameterId.CustomViewIsPublic]: customView.shared,\n    };\n\n    return this.execute(VerbId.UpdateCustomView, parameters).then<CustomViewImpl>((response) => {\n      const customView = response.result as CustomViewModel;\n      return new CustomViewImpl(customView, this._registryId);\n    });\n  }\n\n  public getCurrentSrcAsync(): Promise<string> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getCurrentSrcAsync',\n    };\n\n    return this.execute(VerbId.GetCurrentSrc, parameters).then((response) => response.result as string);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardObjectVisibilityType } from '@tableau/api-external-contract-js';\nimport { ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ExternalToInternalEnumMappings as ExternalEnumConverter } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { DashboardObjectImpl } from '../../Impl/DashboardObjectImpl';\nimport { ErrorHelpers } from '../../Utils/ErrorHelpers';\nimport { Param } from '../../Utils/Param';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ZoneService } from '../ZoneService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ZoneServiceImpl extends ServiceImplBase implements ZoneService {\n  public get serviceName(): string {\n    return ServiceNames.Zone;\n  }\n\n  public setVisibilityAsync(\n    dashboard: string,\n    dashboardZoneMap: Map<number, DashboardObjectImpl>,\n    zoneVisibilityMap: Contract.ZoneVisibilityMap,\n  ): Promise<void> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'setVisibilityAsync',\n      [ParameterId.Dashboard]: dashboard,\n      [ParameterId.ZoneIdsVisibilityMap]: {},\n    };\n\n    // zoneVisibilityMap can be either an object or a Map - convert it to a Map\n    const parameterAsMap = Param.convertParameterToMap(zoneVisibilityMap, 'zoneVisibilityMap');\n\n    parameterAsMap.forEach((value, key) => {\n      ErrorHelpers.verifyZoneIsValid(dashboardZoneMap, Number.parseInt(key, 10));\n      ErrorHelpers.verifyEnumValue<DashboardObjectVisibilityType>(value, DashboardObjectVisibilityType, 'DashboardObjectVisibilityType');\n      parameters[ParameterId.ZoneIdsVisibilityMap][key] = ExternalEnumConverter.setVisibilityType.convert(value);\n    });\n\n    return this.execute(VerbId.SetZoneVisibility, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public moveAndResizeAsync(\n    dashboard: string,\n    dashboardZoneMap: Map<number, DashboardObjectImpl>,\n    dashboardObjectPositionAndSizeUpdateArray: Contract.DashboardObjectPositionAndSizeUpdateArray,\n  ): Promise<void> {\n    const parameters = {\n      [ParameterId.Dashboard]: dashboard,\n      [ParameterId.DashboardObjectPositionAndSizeUpdateList]: dashboardObjectPositionAndSizeUpdateArray,\n    };\n\n    dashboardObjectPositionAndSizeUpdateArray.forEach((dashboardObject: Contract.DashboardObjectPositionAndSizeUpdate) => {\n      ErrorHelpers.verifyZoneIsValidAndFloating(dashboardZoneMap, dashboardObject.dashboardObjectID);\n      ErrorHelpers.verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate(dashboardObject);\n    });\n\n    return this.execute(VerbId.MoveAndResizeZones, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableInfo } from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of a table summary.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class TableSummary implements Contract.TableSummary {\n  public constructor(private _tableInfo: TableInfo) {}\n\n  public get name(): string {\n    return this._tableInfo.name;\n  }\n\n  public get id(): string {\n    return this._tableInfo.id;\n  }\n\n  public get connectionId(): string {\n    return this._tableInfo.connectionId;\n  }\n\n  public get customSQL(): string | undefined {\n    return this._tableInfo.customSQL;\n  }\n}\n","import { EmbeddingErrorCodes, ErrorCodes, SharedErrorCodes } from '@tableau/api-external-contract-js';\n\n/**\n * Custom error class that extends the default JavaScript Error object.\n * This allows us to provide a field with a specific error code\n * so that developers can more easily programmatically respond\n * to error scenarios.\n */\nexport class TableauError extends Error {\n  public constructor(private _errorCode: ErrorCodes | EmbeddingErrorCodes | SharedErrorCodes, message: string) {\n    super(`${_errorCode}: ${message}`);\n\n    /*tslint:disable-next-line */\n    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    // Error inheritance does not work propertly when compiling to ES5, this is a workaround to force\n    // the proto chain to be built correctly.  See the github link above for details.\n    Object.setPrototypeOf(this, TableauError.prototype);\n  }\n\n  public get errorCode(): ErrorCodes | EmbeddingErrorCodes | SharedErrorCodes {\n    return this._errorCode;\n  }\n}\n","import * as InternalContract from '@tableau/api-internal-contract-js';\nimport { DataValue } from '../Models/GetDataModels';\n\n/**\n * In version 2 of the interface, we should collapse value into nativeValue, and do all this work over\n * in the platform.\n */\nexport class DataValueFactory {\n  public static MakeParameterDataValue(internalDataValue: InternalContract.DataValue, dataType: InternalContract.DataType): DataValue {\n    // Parameter values are all strings, convert from string to value\n    return new DataValue(\n      internalDataValue.value,\n      InternalContract.DataTypeConverter.convertStringValueToNativeValue(internalDataValue.value, dataType),\n      internalDataValue.formattedValue,\n    );\n  }\n\n  public static MakeFilterDataValue(internalDataValue: InternalContract.DataValue): DataValue {\n    // Filters already have native type in value, just use that for nativeValue also\n    return new DataValue(internalDataValue.value, internalDataValue.value, internalDataValue.formattedValue);\n  }\n\n  public static MakeTableDataValue(internalDataValue: InternalContract.DataValue, dataType: InternalContract.DataType): DataValue {\n    // DataTables contain boolean | number | string | date as string | '%null%\n    // convertValueToNativeValue converts dates as string to dates, and any special to null\n    // (boolean, numbers, strings are passed through)\n    // Because of IncludeDataValuesOption - we can have undefined values, which are different than any special\n    return new DataValue(\n      internalDataValue.value,\n      internalDataValue.value !== undefined\n        ? InternalContract.DataTypeConverter.convertValueToNativeValue(internalDataValue.value, dataType)\n        : undefined,\n      internalDataValue.formattedValue,\n    );\n  }\n}\n","/**\n * A Promise wrapper class allowing for resolving/rejecting the Promise outside the context of its constructor.\n *\n * @export\n * @class Deferred\n * @template TResolve The type used to resolve the promise.\n * @template TReject The type used to reject the promise. Defaults to any.\n * @link https://stackoverflow.com/a/34637436\n */\nexport class Deferred<TResolve, TReject = any> {\n  private _promise: Promise<TResolve>;\n  private _resolve: (response: TResolve | PromiseLike<TResolve>) => void;\n  private _reject: (reason?: TReject) => void;\n\n  /**\n   * Creates an instance of Deferred.\n   */\n  constructor() {\n    this._promise = new Promise<TResolve>((resolve, reject) => {\n      this._resolve = resolve;\n      this._reject = reject;\n    });\n  }\n\n  /**\n   * Gets the Promise.\n   *\n   * @readonly\n   * @type {Promise<TResolve>}\n   */\n  get promise(): Promise<TResolve> {\n    return this._promise;\n  }\n\n  /**\n   * Resolves the wrapped Promise.\n   *\n   * @param {(TResolve | PromiseLike<TResolve>)} response The argument to be resolved by the Promise.\n   * @returns {*}  {void}\n   */\n  resolve(response: TResolve | PromiseLike<TResolve>): void {\n    if (!this._resolve) {\n      return;\n    }\n\n    this._resolve(response);\n  }\n\n  /**\n   *\n   *\n   * @param {TReject} [reason] The reason why the Promise rejected.\n   * @returns {*}  {void}\n   */\n  reject(reason?: TReject): void {\n    if (!this._reject) {\n      return;\n    }\n\n    this._reject(reason);\n  }\n}\n\nexport const UnregisterTimeoutInMilliseconds = 30000;\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * This class converts from a source enum value to destination enum\n * value given a mapping from source to destination when constructed.\n *\n * Note: This exact same class is defined in api-core.  Given its small\n * nature, it is not worth having in a separate project to share this between\n * api-core and api-shared.  If more utility functionality is added that is used by api-core\n * and api-shared but has no other dependecies, a utiltity project might be merited,\n * and this class could be moved.\n */\nexport class EnumConverter<TSourceType extends string, TDestinationType> {\n  public constructor(private _mappings: { [enumVal: string]: TDestinationType }, private _defaultVal?: TDestinationType) {}\n\n  public convert(enumVal: TSourceType, throwIfMissing: ShouldThrow = ShouldThrow.Yes): TDestinationType {\n    if (this._mappings.hasOwnProperty(enumVal)) {\n      return this._mappings[enumVal as string];\n    }\n\n    if (this._defaultVal !== undefined && throwIfMissing !== ShouldThrow.Yes) {\n      return this._defaultVal;\n    }\n\n    throw new TableauError(ErrorCodes.InternalError, `Enum Mapping not found for: ${enumVal}`);\n  }\n}\n\nexport enum ShouldThrow {\n  Yes = 'yes',\n  No = 'no',\n}\n","import {\n  DashboardObjectPositionAndSizeUpdate,\n  ExportDataOptions,\n  ExportPDFOptions as ExternalExportPDFOptions,\n  ExportScenariosForPDFAndPowerPoint,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  SharedErrorCodes,\n} from '@tableau/api-external-contract-js';\nimport { DashboardObjectImpl } from '../Impl/DashboardObjectImpl';\nimport { TableauError } from '../TableauError';\nimport { Param } from './Param';\n\ninterface EnumLike {\n  toString(): string;\n}\n\n/**\n * This class is used to construct common errors throughout the external\n * projects (api-shared, extensions-api, etc.).  It has some duplication with\n * the ErrorHelpers class in api-core, but is separate due to the need to throw\n * an external TableauError vs. an InternalTableauError.\n */\nexport class ErrorHelpers {\n  /**\n   * Throws with code InternalError.\n   *\n   * @param apiName name of api that was called.\n   */\n  public static apiNotImplemented(apiName: string): TableauError {\n    return new TableauError(SharedErrorCodes.InternalError, `${apiName} API not yet implemented.`);\n  }\n\n  /**\n   * Throws an internal error if argument is null or undefined.\n   *\n   * @param argumentValue value to verify\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyInternalValue(argumentValue: any, argumentName: string) {\n    if (argumentValue === null || argumentValue === undefined) {\n      throw new TableauError(SharedErrorCodes.InternalError, `${argumentValue} is invalid value for: ${argumentName}`);\n    }\n  }\n\n  /**\n   * Throws an InvalidParameter error if argument is null or undefined.\n   *\n   * @param argumentValue value to verify\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyParameter(argumentValue: any, argumentName: string) {\n    if (argumentValue === null || argumentValue === undefined) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${argumentValue} is invalid value for parameter: ${argumentName}`);\n    }\n  }\n\n  /**\n   * Throws an InvalidParameter error if argument is not the specified type.\n   * For objects, it just tests that it is an object\n   *\n   * @param argumentValue value to verify\n   * @param expectedType expected result of typeof\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyParameterType(argumentValue: any, expectedType: string, argumentName: string) {\n    if (typeof argumentValue !== expectedType) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${argumentValue} has invalid type for parameter: ${argumentName}.`);\n    }\n  }\n\n  /**\n   * Throws an InvalidParameter error if argument is empty string, null or undefined.\n   *\n   * @param argumentValue value to verify\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyStringParameter(argumentValue: string, argumentName: string) {\n    if (argumentValue === null || argumentValue === undefined || argumentValue === '') {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${argumentValue} is invalid value for paramter: ${argumentName}`);\n    }\n  }\n\n  /**\n   * Verifies passed value is a valid value for that enum.\n   * Throws an InvalidParameter error if the enum value is not valid.\n   *\n   * String enums are {string : string} dictionaries which are not reverse mappable\n   * This is an ugly workaround\n   *\n   * @param enumValue value to verify\n   * @param enumType enum to verify against\n   * @param enumName enum name for clear error message\n   */\n  /*tslint:disable-next-line */\n  public static verifyEnumValue<EnumType extends EnumLike>(enumValue: EnumType, enumType: any, enumName: string) {\n    let isValid = false;\n    Object.keys(enumType).forEach((enumKey) => {\n      if (enumType[enumKey] === enumValue.toString()) {\n        isValid = true;\n      }\n    });\n\n    if (!isValid) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${enumValue} is invalid value for enum: ${enumName}.`);\n    }\n  }\n\n  /**\n   * Verifies passed value is between [min, max) ... min <= value < max\n   * Throws an InvalidParameter error if the value is not valid.\n   *\n   *\n   * @param value value to verify\n   * @param min   value must be >= min\n   * @param max   value must be < max\n   */\n  /*tslint:disable-next-line */\n  public static verifyRange(value: number, min: number, max: number) {\n    let isValid = min <= value && value < max;\n\n    if (!isValid) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${value} is invalid value for range: [${min}..${max})`);\n    }\n  }\n\n  /**\n   * Verifies the params min and max for applying range filter.\n   * Throws with error code InvalidParameter if range is invalid.\n   *\n   * @param min range min\n   * @param max range max\n   */\n  /*tslint:disable-next-line */\n  public static verifyRangeParamType(min: any, max: any): void {\n    if (!min && !max) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, at least one of min or max is required.');\n    }\n\n    if (min && !Param.isTypeNumber(min) && !Param.isTypeDate(min)) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        'Unexpected invalid param value, only Date and number are allowed for parameter min.',\n      );\n    }\n\n    if (max && !Param.isTypeNumber(max) && !Param.isTypeDate(max)) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        'Unexpected invalid param value, only Date and number are allowed for parameter max.',\n      );\n    }\n\n    if (min && max && typeof min !== typeof max) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        'Unexpected invalid param value, parameters min and max should be of the same type.',\n      );\n    }\n  }\n\n  /**\n   * Verifies that the zoneId is present in the current dashboard.\n   * Throws with error code InvalidParameter if either condition is false.\n   *\n   * @param dashboardZoneMap A map of zoneId's to the corresponding dashboard object.\n   * @param zoneID ZoneId to be validated\n   */\n  public static verifyZoneIsValid(dashboardZoneMap: Map<number, DashboardObjectImpl>, zoneID: number): void {\n    if (dashboardZoneMap.has(zoneID)) {\n      return;\n    }\n\n    throw new TableauError(\n      SharedErrorCodes.InvalidParameter,\n      `Unexpected invalid param value, Dashboard Object Id: ${zoneID} is not present in dashboard.`,\n    );\n  }\n\n  /**\n   * Verifies that the zone is present and floating in the current dashboard.\n   * Throws with error code InvalidParameter if either condition is false.\n   *\n   * @param dashboardZoneMap A map of zoneId's to the corresponding dashboard object.\n   * @param zoneID ZoneId to be validated\n   */\n  public static verifyZoneIsValidAndFloating(dashboardZoneMap: Map<number, DashboardObjectImpl>, zoneID: number): void {\n    if (dashboardZoneMap.has(zoneID) && dashboardZoneMap.get(zoneID)!.isFloating) {\n      return;\n    }\n\n    throw new TableauError(\n      SharedErrorCodes.InvalidParameter,\n      `Unexpected invalid param value, Dashboard Object Id: ${zoneID} is not present or is a fixed zone in the dashboard.`,\n    );\n  }\n\n  /**\n   * Verifies that width and height are > 0 for each DashboardObjectPositionAndSizeUpdate object.\n   * Throws with error code InvalidParameter if either condition is false.\n   *\n   * @param dashboardObjectPositionAndSizeUpdate DashboardObjectPositionAndSizeUpdate object for which width and height will be validated\n   */\n  public static verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate(\n    dashboardObjectPositionAndSizeUpdate: DashboardObjectPositionAndSizeUpdate,\n  ): void {\n    if (dashboardObjectPositionAndSizeUpdate.width < 0 || dashboardObjectPositionAndSizeUpdate.height < 0) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        `Unexpected invalid param value for dashboard object ID ${dashboardObjectPositionAndSizeUpdate.dashboardObjectID}:` +\n          ` negative widths and heights are not allowed.`,\n      );\n    }\n  }\n\n  /**\n   * Verifies is the given sheet name is in the list of sheets names allowed for exporting.\n   * Throws with error code InvalidParameter if the condition above is false.\n   *\n   * @param exportableSheetNames A list of sheet names allowed for exporting\n   * @param sheetName the name of the sheet selected for export\n   */\n  public static verifySheetName(exportableSheetNames: Array<string>, sheetName: string) {\n    if (!exportableSheetNames.includes(sheetName)) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidSelectionSheet,\n        'sheetName parameter must belong to a worksheet within the current view',\n      );\n    }\n  }\n\n  /**\n   * Verifies the ExportDataOptions object\n   * Throws with error code InvalidParameter if the parameter is not of ExportDataOptions type.\n   *\n   * @param options The ExportDataOptions object used to configure the output CSV file for exportDataAsync.\n   */\n  public static verifyExportDataOptions(options: ExportDataOptions): void {\n    if (\n      (!Param.isNullOrUndefined(options.ignoreAliases) && !Param.isTypeBool(options.ignoreAliases)) ||\n      (!Param.isNullOrUndefined(options.columnsToIncludeById) && !Array.isArray(options.columnsToIncludeById))\n    )\n      throw new TableauError(SharedErrorCodes.InvalidParameter, 'options paramater must be of type ExportDataOptions');\n  }\n\n  /**\n   * Verifies if the sheet names are included in any of the export scenarios.\n   * Throws with error code InvalidParameter if the parameter is not an array.\n   * Throws with error code InvalidSelectionSheet if there are array entries that dont exist or if there is mixing between sheets from the dashboard and sheet from the workbook.\n   *\n   * @param sheetNames List of sheet names selected for exporting.\n   * @param exportScenarios an object containing the current sheet name, exportable sheets from the dashboard, and exportable sheets from the workbook.\n   */\n  public static verifySheetNamesForPDFAndPPT(sheetNames: Array<string>, exportScenarios: ExportScenariosForPDFAndPowerPoint): void {\n    if (!Array.isArray(sheetNames)) throw new TableauError(SharedErrorCodes.InvalidParameter, 'sheetNames parameter must be an array');\n    if (sheetNames.length === 0) throw new TableauError(SharedErrorCodes.InternalError, 'sheetNames should not be empty');\n\n    const isIncludedInDashboard = sheetNames.every((sheetName: string) =>\n      exportScenarios.exportableSheetNamesFromDashboard.includes(sheetName),\n    );\n    if (isIncludedInDashboard) {\n      return;\n    }\n    const isIncludedInWorkbook = sheetNames.every((sheetName: string) =>\n      exportScenarios.exportableSheetNamesFromWorkbook.includes(sheetName),\n    );\n    if (isIncludedInWorkbook) {\n      return;\n    }\n    const isCurrentSheet = sheetNames.length === 1 && sheetNames[0] === exportScenarios.currentSheetName;\n    if (isCurrentSheet) {\n      return;\n    }\n\n    // Export requirement: all sheet names must be included in the list of exportable sheets in the dashboard or\n    // all sheet names must be included in the list of exportable sheets in the workbook, or the sheet name is the current sheet\n    throw new TableauError(\n      SharedErrorCodes.InvalidSelectionSheet,\n      'sheetNames parameter must have all its entries be exportable sheet names from the dashboard or all its entries be exportable sheet names from the workbook',\n    );\n  }\n\n  /**\n   * Verifies the external ExportPDFOptions object's properties.\n   * Throws with error code InvalidParameter if the parameter is not of external ExportPDFOptions type.\n   *\n   * @param options The external user-facing ExportPDFOptions object used to configure the output PDF file for exportPDFAsync.\n   */\n  public static verifyExportPDFOptions(options: ExternalExportPDFOptions) {\n    try {\n      this.verifyEnumValue<PrintOrientation>(options.orientation, PrintOrientation, 'PrintOrientation');\n      this.verifyEnumValue<PrintPageSize>(options.pageSize, PrintPageSize, 'PrintPageSize');\n      this.verifyEnumValue<PrintScaling>(options.scaling, PrintScaling, 'PrintScaling');\n    } catch {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, 'options parameter must be of type ExportPDFOptions');\n    }\n  }\n}\n","import {\n  ExportLayoutOptions,\n  ExportPDFOptions as InternalExportPDFOptions,\n  FitPages,\n  PageOrientation,\n  PageScalingOption,\n  PageSizeOption,\n  ScaleMode,\n  ScalingSelection,\n} from '@tableau/api-internal-contract-js';\nimport {\n  ExportDataOptions,\n  ExportPDFOptions as ExternalExportPDFOptions,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  SharedErrorCodes,\n} from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * Helper methods for Export APIs.\n *\n * @class ExportHelpers\n */\nexport class ExportHelpers {\n  public static DefaultDataOptions: ExportDataOptions = {\n    ignoreAliases: false,\n    columnsToIncludeById: [],\n  };\n\n  public static DefaultPDFOptions: ExternalExportPDFOptions = {\n    scaling: PrintScaling.Automatic,\n    pageSize: PrintPageSize.Letter,\n    orientation: PrintOrientation.Portrait,\n  };\n\n  private static DefaultLayoutOptions: ExportLayoutOptions = {\n    imageHeight: 0,\n    imageWidth: 0,\n    pageFitHorizontal: 1,\n    pageFitVertical: 1,\n    pageOrientationOption: PageOrientation.Portrait,\n    pageScaleMode: ScaleMode.ScaleAuto,\n    pageScalePercent: 100,\n    pageSizeOption: PageSizeOption.Letter,\n  };\n\n  /**\n   * Modifies the internal ExportPDFOptions' properties based on the given PDF export configuration.\n   * This method will construct the internal ExportPDFOptions identically to how the 'Export PDF' dialog constructs the ExportPdfOptionsPresModel.\n   * See the handleExportClick method in @browser-clients/export-pdf-options-dialog for reference.\n   *\n   * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n   * @param externalExportPdfOptions The external ExportPDFOptions user-facing object passed to exportPDFAsync.\n   * @param sheetNames The list of sheets selected for export.\n   */\n  public static updateInternalExportPDFOptions(\n    internalExportPdfOptions: InternalExportPDFOptions,\n    externalExportPdfOptions: ExternalExportPDFOptions,\n    sheetNames: Array<string>,\n  ): void {\n    internalExportPdfOptions.currentSheet = sheetNames[0];\n    this.updateExportLayoutOptions(internalExportPdfOptions, externalExportPdfOptions);\n    this.updateSheetOptions(internalExportPdfOptions, sheetNames);\n  }\n\n  /**\n   * Helper method for updateInternalExportPDFOptions.\n   * Modifies the exportLayoutOptions property of the internal ExportPDFOptions based on the external ExportPDFOptions.\n   * See the getExportLayoutOptions method in @browser-clients/export-pdf-options-dialog for reference.\n   *\n   * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n   * @param externalExportPdfOptions The external ExportPDFOptions user-facing object passed to exportPDFAsync.\n   */\n  public static updateExportLayoutOptions(\n    internalExportPdfOptions: InternalExportPDFOptions,\n    externalExportPdfOptions: ExternalExportPDFOptions,\n  ): void {\n    const exportLayoutOptions = internalExportPdfOptions.exportLayoutOptions;\n\n    // setting the image height and width properties to their default values\n    exportLayoutOptions.imageHeight = this.DefaultLayoutOptions.imageHeight;\n    exportLayoutOptions.imageWidth = this.DefaultLayoutOptions.imageWidth;\n\n    //  setting the orientation value for the exportLayoutOptions\n    switch (externalExportPdfOptions.orientation) {\n      case PrintOrientation.Landscape:\n        exportLayoutOptions.pageOrientationOption = PageOrientation.Landscape;\n        break;\n      case PrintOrientation.Portrait:\n        exportLayoutOptions.pageOrientationOption = PageOrientation.Portrait;\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'invalid orientation for ExportPDFOption');\n    }\n\n    // setting the page size value for the exportLayoutOptions\n    switch (externalExportPdfOptions.pageSize) {\n      case PrintPageSize.A3:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.A3;\n        break;\n      case PrintPageSize.A4:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.A4;\n        break;\n      case PrintPageSize.A5:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.A5;\n        break;\n      case PrintPageSize.B4:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.B4;\n        break;\n      case PrintPageSize.B5:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.B5;\n        break;\n      case PrintPageSize.Executive:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Executive;\n        break;\n      case PrintPageSize.Folio:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Folio;\n        break;\n      case PrintPageSize.Ledger:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Ledger;\n        break;\n      case PrintPageSize.Legal:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Legal;\n        break;\n      case PrintPageSize.Letter:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Letter;\n        break;\n      case PrintPageSize.Note:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Note;\n        break;\n      case PrintPageSize.Quarto:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Quarto;\n        break;\n      case PrintPageSize.Statement:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Statement;\n        break;\n      case PrintPageSize.Tabloid:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Tabloid;\n        break;\n      case PrintPageSize.Unspecified:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Unspecified;\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'invalid pageSize for ExportPDFOption');\n    }\n\n    // setting the scaling values for the exportLayoutOptions\n    switch (externalExportPdfOptions.scaling) {\n      case PrintScaling.AtMost1PageHigh:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitOneHigh);\n        break;\n      case PrintScaling.AtMost1PageWide:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitOneWide);\n        break;\n      case PrintScaling.AtMost2PagesHigh:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitTwoHigh);\n        break;\n      case PrintScaling.AtMost2PagesWide:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitTwoWide);\n        break;\n      case PrintScaling.Automatic:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePctAuto);\n        break;\n      case PrintScaling.Perc100:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct100);\n        break;\n      case PrintScaling.Perc200:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct200);\n        break;\n      case PrintScaling.Perc25:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct25);\n        break;\n      case PrintScaling.Perc400:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct400);\n        break;\n      case PrintScaling.Perc50:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct50);\n        break;\n      case PrintScaling.Perc60:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct60);\n        break;\n      case PrintScaling.Perc75:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct75);\n        break;\n      case PrintScaling.Perc80:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct80);\n        break;\n      case PrintScaling.Perc90:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct90);\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'invalid scaling for ExportPDFOption');\n    }\n  }\n\n  /**\n   * Helper method for updateInternalExportPDFOptions.\n   * Modifies the sheetOptions property of the internal ExportPDFOptions based on the sheets selected for export.\n   * See the handleExportClick method in @browser-clients/export-pdf-options-dialog for reference.\n   *\n   * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n   * @param sheetNames The list of sheets selected for export.\n   */\n  public static updateSheetOptions(internalExportPdfOptions: InternalExportPDFOptions, sheetNames: Array<string>): void {\n    const { exportLayoutOptions, sheetOptions } = internalExportPdfOptions;\n    // updating the export layouts options for each sheet and selecting sheet for export if included in list\n    for (const sheetOption of sheetOptions) {\n      sheetOption.exportLayoutOptions = exportLayoutOptions;\n      sheetOption.isSelected = sheetNames.includes(sheetOption.sheet);\n    }\n  }\n\n  /**\n   * Helper method for updateExportLayoutOptons.\n   * This method is a spoof of the getFitAndScaleValues method used in @browser-clients/export-pdf-options to set the exportLayoutOptions' scaling properties.\n   * In the future, this file should be refactored to import the method directly from @browser-clients/export-pdf-options.\n   *\n   * @param scalingSelection string used for setting the exportLayoutOptions based on the PrintScaling property from the ExternalExportPDFOptions.\n   * @param exportLayoutOptions the ExportLayoutOptions used by the internal ExportPDFOptions pres model.\n   */\n  public static setFitAndScaleValues(exportLayoutOptions: ExportLayoutOptions, scalingSelection: ScalingSelection): void {\n    let { pageFitHorizontal, pageFitVertical, pageScaleMode, pageScalePercent } = this.DefaultLayoutOptions;\n\n    const fitMatch = this.fitRegex.exec(scalingSelection);\n    const percentMatch = this.pctRegex.exec(scalingSelection);\n\n    if (fitMatch) {\n      [pageFitHorizontal, pageFitVertical] = fitMatch.slice(1).map((value) => Number(value));\n      pageScaleMode = ScaleMode.ScaleFitPages;\n    } else if (percentMatch) {\n      [pageScalePercent] = percentMatch.slice(1).map((value) => Number(value));\n      pageScaleMode = ScaleMode.ScalePercentage;\n    }\n\n    // getFitAndScaleValues returns the properties below, but instead this method will set them.\n    exportLayoutOptions.pageFitHorizontal = pageFitHorizontal;\n    exportLayoutOptions.pageFitVertical = pageFitVertical;\n    exportLayoutOptions.pageScaleMode = pageScaleMode;\n    exportLayoutOptions.pageScalePercent = pageScalePercent;\n  }\n\n  private static fitRegex = new RegExp('fit([0-9]+)x([0-9]+)');\n  private static pctRegex = new RegExp('pct([0-9]+)');\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from './ErrorHelpers';\n\nexport class Param {\n  /**\n   * serializes the date into the format that the server expects.\n   * @param date the date to serialize\n   */\n  public static serializeDateForPlatform(date: Date): string {\n    const year: number = date.getUTCFullYear();\n    const month: number = date.getUTCMonth() + 1;\n    const day: number = date.getUTCDate();\n    const hh: number = date.getUTCHours();\n    const mm: number = date.getUTCMinutes();\n    const sec: number = date.getUTCSeconds();\n    return `${year}-${month}-${day} ${hh}:${mm}:${sec}`;\n  }\n\n  public static serializeBooleanForPlatform(bool: boolean): string {\n    return bool ? 'true' : 'false';\n  }\n\n  public static serializeNumberForPlatform(num: number): string {\n    return num.toString(10);\n  }\n\n  /**\n   * Verifies the input is a number\n   */\n  /* tslint:disable-next-line:no-any */\n  public static isTypeNumber(input: any): boolean {\n    return typeof input === 'number' || input instanceof Number;\n  }\n\n  /**\n   * Verifies the input is a Date\n   */\n  /* tslint:disable-next-line:no-any */\n  public static isTypeDate(input: any): boolean {\n    return input instanceof Date;\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static isTypeString(input: any): boolean {\n    return typeof input === 'string' || input instanceof String;\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static isTypeBool(input: any): boolean {\n    return typeof input === 'boolean' || input instanceof Boolean;\n  }\n\n  /**\n   * Determines if the input is null or undefined\n   */\n  /* tslint:disable-next-line:no-any */\n  public static isNullOrUndefined(input: any): boolean {\n    return input === null || input === undefined;\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static serializeParameterValue(value: any): string {\n    if (Param.isTypeNumber(value)) {\n      return Param.serializeNumberForPlatform(value as number);\n    } else if (Param.isTypeDate(value)) {\n      return Param.serializeDateForPlatform(value as Date);\n    } else if (Param.isTypeBool(value)) {\n      return Param.serializeBooleanForPlatform(value as boolean);\n    } else if (Param.isTypeString(value)) {\n      return value;\n    } else {\n      throw new TableauError(ErrorCodes.InternalError, `Unexpected invalid value for: ${value}`);\n    }\n  }\n\n  /**\n   * Verifies that the parameter is already a Map, or converts an object to a Map.\n   * If the parameter is an object, we convert it to a Map using Object.entries.\n   * @throws if the parameter is not an object or Map\n   */\n  // tslint:disable-next-line:no-any\n  public static convertParameterToMap(param: object, paramName: string): Map<any, any> {\n    ErrorHelpers.verifyParameterType(param, 'object', paramName);\n    if (Array.isArray(param)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, `Expecting object or Map for: ${paramName}.`);\n    }\n\n    return param instanceof Map ? param : new Map(Object.entries(param));\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static tryParseNumber(value: any): { parsed?: number; success: boolean } {\n    if (Param.isNullOrUndefined(value)) {\n      return { success: false };\n    }\n\n    if (Param.isTypeNumber(value)) {\n      return { parsed: value as number, success: true };\n    }\n\n    const valueString = value.toString();\n    if (valueString === 'NaN') {\n      // 'NaN' parses as NaN which is indistinguishable from a failed parse.\n      return { parsed: NaN, success: true };\n    }\n\n    const parsed = parseFloat(valueString);\n    if (isNaN(parsed)) {\n      return { success: false };\n    }\n\n    return { parsed, success: true };\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { SheetInfo, SheetType, SizeConstraint } from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../TableauError';\n\nexport class SheetUtils {\n  // This is a direct port from SheetSize.cs - SheetSizeFactory\n  public static getSheetSizeFromSizeConstraints(sizeConstraint: SizeConstraint): Contract.SheetSize {\n    const { minWidth, minHeight, maxWidth, maxHeight } = sizeConstraint;\n\n    if (minHeight === 0 && minWidth === 0) {\n      if (maxHeight === 0 && maxWidth === 0) {\n        return {\n          behavior: Contract.SheetSizeBehavior.Automatic,\n        };\n      }\n\n      return {\n        behavior: Contract.SheetSizeBehavior.AtMost,\n        maxSize: { width: maxWidth, height: maxHeight },\n      };\n    }\n\n    if (maxHeight === 0 && maxWidth === 0) {\n      return {\n        behavior: Contract.SheetSizeBehavior.AtLeast,\n        minSize: { width: minWidth, height: minHeight },\n      };\n    }\n\n    if (maxHeight === minHeight && maxWidth === minWidth && minWidth > 0) {\n      return {\n        behavior: Contract.SheetSizeBehavior.Exactly,\n        minSize: { width: minWidth, height: minHeight },\n        maxSize: { width: minWidth, height: minHeight },\n      };\n    }\n\n    // 'Fit Width' for a DSD layout\n    const isDsdLayout = minWidth === 0 && maxWidth === 0;\n\n    return {\n      behavior: Contract.SheetSizeBehavior.Range,\n      minSize: { width: minWidth, height: minHeight },\n      maxSize: { width: isDsdLayout ? 2147483647 : maxWidth, height: maxHeight },\n    };\n  }\n\n  public static createAutomaticSize(): Contract.SheetSize {\n    let behavior = Contract.SheetSizeBehavior.Automatic;\n    let minSize = { width: 0, height: 0 };\n    let maxSize = { width: 0, height: 0 };\n    return { behavior, minSize, maxSize };\n  }\n\n  public static getPublishedSheetInfoByName(name: string, sheetInfos: Array<SheetInfo>): SheetInfo | undefined {\n    const sheetInfo = sheetInfos.find((sheet) => sheet.name === name);\n    return sheetInfo;\n  }\n\n  public static getSheetTypeEnum(internalSheetType: SheetType): Contract.SheetType {\n    let sheetType: Contract.SheetType;\n    switch (internalSheetType) {\n      case SheetType.Worksheet: {\n        sheetType = Contract.SheetType.Worksheet;\n        break;\n      }\n      case SheetType.Dashboard: {\n        sheetType = Contract.SheetType.Dashboard;\n        break;\n      }\n      case SheetType.Story: {\n        sheetType = Contract.SheetType.Story;\n        break;\n      }\n      default: {\n        throw new TableauError(Contract.SharedErrorCodes.ServerError, 'Invalid SheetType');\n      }\n    }\n    return sheetType;\n  }\n\n  public static isValidSheetSize(sizeObject: Contract.Size | Contract.SheetSize): sizeObject is Contract.SheetSize {\n    return (<Contract.SheetSize>sizeObject).behavior !== undefined;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\nimport { Deferred, UnregisterTimeoutInMilliseconds } from './Deferred';\n\n/**\n * A Deferred wrapper class adding functionality to reject unresponsive promises after timeout\n *\n * this class handles two things:\n\n *    1. Adds timeout logic for deferred\n *    2. It blocks multiple calls from executing at the same time.\n *\n * @export\n * @class ShortLivedDeferred\n * @template TResolve The type used to resolve the promise.\n * @template TReject The type used to reject the promise. Defaults to any.\n *\n */\nexport class ShortLivedDeferred<TResolve, TReject = any> {\n  private _deferred: Deferred<TResolve, TReject> | undefined;\n  private _timeoutId;\n  constructor(private _timeoutInMilliseconds = UnregisterTimeoutInMilliseconds) {}\n\n  public getNewPromiseOrThrowIfBusy(): Promise<TResolve> {\n    if (this._deferred) {\n      throw new TableauError(Contract.SharedErrorCodes.ApiExecutionError, 'This api cannot be executed till previous call is resolved.');\n    }\n    this._deferred = new Deferred();\n\n    this._timeoutId = setTimeout(() => {\n      const error = new TableauError(\n        Contract.SharedErrorCodes.Timeout,\n        `Api failed to complete in ${this._timeoutInMilliseconds / 1000} seconds`,\n      );\n      this.reject(error);\n    }, this._timeoutInMilliseconds);\n\n    return this._deferred.promise;\n  }\n\n  public resolve(response: TResolve | PromiseLike<TResolve>): void {\n    if (this._deferred) {\n      clearTimeout(this._timeoutId);\n      this._deferred.resolve(response);\n      this._deferred = undefined;\n    }\n  }\n\n  public reject(error: any): void {\n    if (this._deferred) {\n      clearTimeout(this._timeoutId);\n      this._deferred.reject(error);\n      this._deferred = undefined;\n    }\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from './TableauError';\nimport { VersionNumberContract } from './VersionNumberContract';\n\n/**\n * Represents the current version of the extensions, embedding\n * and extensions-api-types library\n */\nexport class VersionNumber implements VersionNumberContract {\n  public major: number;\n  public minor: number;\n  public fix: number;\n  public build: number;\n  public isAlpha: boolean;\n\n  // private constructor so everyone uses the singleton instance\n  // build numbers have this form: M.m.f-pre.N\n  public constructor(versionString: string, isAlpha: boolean) {\n    const partStr = versionString.split('-');\n    this.build = this.getBuildNumber(partStr[1]);\n    versionString = partStr[0];\n\n    const parts = versionString.split('.').map((p) => parseInt(p, 10));\n    if (parts.length !== 3) {\n      throw new TableauError(ErrorCodes.InternalError, `Invalid version number: ${versionString}`);\n    }\n\n    this.major = parts[0];\n    this.minor = parts[1];\n    this.fix = parts[2];\n    this.isAlpha = isAlpha;\n  }\n\n  private getBuildNumber(preReleaseString: string): number {\n    const noBuildNumber = -1;\n    if (!preReleaseString) {\n      return noBuildNumber;\n    }\n\n    // The preRelease string has this form: pre.N, but we don't depend on the actual string being 'pre'\n    const partStr = preReleaseString.split('.');\n    return partStr[1] ? parseInt(partStr[1], 10) : noBuildNumber;\n  }\n\n  public get formattedValue(): string {\n    return `${this.major}.${this.minor}.${this.fix}`;\n  }\n\n  public get fullFormattedValue(): string {\n    return `${this.major}.${this.minor}.${this.fix}-pre.${this.build}`;\n  }\n}\n","import {\n  CreateExternalCompatibleVersionConverter,\n  ExecuteParameters,\n  ExecuteResponse,\n  ExternalContractVersionConverter,\n  InternalApiDispatcher,\n  INTERNAL_CONTRACT_VERSION,\n  Notification,\n  NotificationHandler,\n  VerbId,\n  VersionLessThan,\n  VersionNumber,\n} from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of the InternalApiDispatcher which supports upgrading and downgrading the input\n * internal contract to the version that this module is built against\n *\n * @class VersionedExternalApiDispatcher\n * @implements {InternalApiDispatcher}\n */\nexport class VersionedExternalApiDispatcher implements InternalApiDispatcher {\n  private _versionConverter: ExternalContractVersionConverter;\n  private _notificationHandlers: Array<NotificationHandler>;\n\n  /**\n   * Creates a new instance of the VersionedExternalApiDispatcher\n   * We have multiple version converting dispatchers that work together.\n   * If needed, the VersionedExternalApiDispatcher wraps either the InternalApiDispatcher (desktop)\n   * or the CrossFrameDispatcher (server).\n   * The Internal/CrossFrame dispatchers handle an updated platform with an older external library.\n   * (The CrossFrameDispatcher sends messages across the frame, and it is handled by the PresLayerHandler.)\n   * Meanwhile, the VersionedExternalApiDispatcher handles an updated external library with an older platform.\n\n   * @param _apiDelegateDispatcher The delegate that does the actual work.\n   * @param platformVersionNumber The version of the internal contract which the platform module is using.\n   * This number will be used to figure out how to downgrade incoming commands and upgrade the results\n   */\n  public constructor(private _apiDelegateDispatcher: InternalApiDispatcher, platformVersionNumber: VersionNumber) {\n    this._versionConverter = CreateExternalCompatibleVersionConverter(INTERNAL_CONTRACT_VERSION, platformVersionNumber);\n\n    this._notificationHandlers = [];\n    _apiDelegateDispatcher.registerNotificationHandler((notification: Notification): void => {\n      if (this._notificationHandlers.length === 0) {\n        return;\n      }\n      const upgradedNotification = this._versionConverter.upgradeNotification(notification);\n      this._notificationHandlers.forEach((handler) => {\n        handler(upgradedNotification);\n      });\n    });\n  }\n\n  public static needsVersionConverter(platformVersion: VersionNumber): boolean {\n    // If our platform is less than external library version, then we need a converter\n    return VersionLessThan(platformVersion, INTERNAL_CONTRACT_VERSION);\n  }\n\n  public execute(verb: VerbId, parameters: ExecuteParameters): Promise<ExecuteResponse> {\n    try {\n      const downgradeParameters = this._versionConverter.downgradeExecuteCall(verb, parameters);\n      return this._apiDelegateDispatcher.execute(downgradeParameters.verb, downgradeParameters.parameters).then((response) => {\n        const upgradeResponse = this._versionConverter.upgradeExecuteReturn(response, verb, parameters);\n        return upgradeResponse;\n      });\n    } catch (e) {\n      return Promise.reject(e);\n    }\n  }\n\n  public registerNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers.push(handler);\n  }\n\n  public unregisterNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers = this._notificationHandlers.filter((h) => h !== handler);\n  }\n}\n","export { default as v1 } from './v1.js';\nexport { default as v3 } from './v3.js';\nexport { default as v4 } from './v4.js';\nexport { default as v5 } from './v5.js';\nexport { default as NIL } from './nil.js';\nexport { default as version } from './version.js';\nexport { default as validate } from './validate.js';\nexport { default as stringify } from './stringify.js';\nexport { default as parse } from './parse.js';","/*\n * Browser-compatible JavaScript MD5\n *\n * Modification of JavaScript MD5\n * https://github.com/blueimp/JavaScript-MD5\n *\n * Copyright 2011, Sebastian Tschan\n * https://blueimp.net\n *\n * Licensed under the MIT license:\n * https://opensource.org/licenses/MIT\n *\n * Based on\n * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message\n * Digest Algorithm, as defined in RFC 1321.\n * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for more info.\n */\nfunction md5(bytes) {\n  if (typeof bytes === 'string') {\n    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\n\n    bytes = new Uint8Array(msg.length);\n\n    for (var i = 0; i < msg.length; ++i) {\n      bytes[i] = msg.charCodeAt(i);\n    }\n  }\n\n  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));\n}\n/*\n * Convert an array of little-endian words to an array of bytes\n */\n\n\nfunction md5ToHexEncodedArray(input) {\n  var output = [];\n  var length32 = input.length * 32;\n  var hexTab = '0123456789abcdef';\n\n  for (var i = 0; i < length32; i += 8) {\n    var x = input[i >> 5] >>> i % 32 & 0xff;\n    var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);\n    output.push(hex);\n  }\n\n  return output;\n}\n/**\n * Calculate output length with padding and bit length\n */\n\n\nfunction getOutputLength(inputLength8) {\n  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;\n}\n/*\n * Calculate the MD5 of an array of little-endian words, and a bit length.\n */\n\n\nfunction wordsToMd5(x, len) {\n  /* append padding */\n  x[len >> 5] |= 0x80 << len % 32;\n  x[getOutputLength(len) - 1] = len;\n  var a = 1732584193;\n  var b = -271733879;\n  var c = -1732584194;\n  var d = 271733878;\n\n  for (var i = 0; i < x.length; i += 16) {\n    var olda = a;\n    var oldb = b;\n    var oldc = c;\n    var oldd = d;\n    a = md5ff(a, b, c, d, x[i], 7, -680876936);\n    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);\n    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);\n    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);\n    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);\n    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);\n    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);\n    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);\n    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);\n    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);\n    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);\n    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);\n    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);\n    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);\n    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);\n    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);\n    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);\n    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);\n    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);\n    b = md5gg(b, c, d, a, x[i], 20, -373897302);\n    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);\n    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);\n    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);\n    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);\n    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);\n    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);\n    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);\n    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);\n    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);\n    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);\n    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);\n    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);\n    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);\n    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);\n    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);\n    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);\n    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);\n    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);\n    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);\n    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);\n    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);\n    d = md5hh(d, a, b, c, x[i], 11, -358537222);\n    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);\n    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);\n    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);\n    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);\n    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);\n    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);\n    a = md5ii(a, b, c, d, x[i], 6, -198630844);\n    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);\n    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);\n    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);\n    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);\n    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);\n    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);\n    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);\n    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);\n    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);\n    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);\n    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);\n    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);\n    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);\n    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);\n    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);\n    a = safeAdd(a, olda);\n    b = safeAdd(b, oldb);\n    c = safeAdd(c, oldc);\n    d = safeAdd(d, oldd);\n  }\n\n  return [a, b, c, d];\n}\n/*\n * Convert an array bytes to an array of little-endian words\n * Characters >255 have their high-byte silently ignored.\n */\n\n\nfunction bytesToWords(input) {\n  if (input.length === 0) {\n    return [];\n  }\n\n  var length8 = input.length * 8;\n  var output = new Uint32Array(getOutputLength(length8));\n\n  for (var i = 0; i < length8; i += 8) {\n    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;\n  }\n\n  return output;\n}\n/*\n * Add integers, wrapping at 2^32. This uses 16-bit operations internally\n * to work around bugs in some JS interpreters.\n */\n\n\nfunction safeAdd(x, y) {\n  var lsw = (x & 0xffff) + (y & 0xffff);\n  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n  return msw << 16 | lsw & 0xffff;\n}\n/*\n * Bitwise rotate a 32-bit number to the left.\n */\n\n\nfunction bitRotateLeft(num, cnt) {\n  return num << cnt | num >>> 32 - cnt;\n}\n/*\n * These functions implement the four basic operations the algorithm uses.\n */\n\n\nfunction md5cmn(q, a, b, x, s, t) {\n  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);\n}\n\nfunction md5ff(a, b, c, d, x, s, t) {\n  return md5cmn(b & c | ~b & d, a, b, x, s, t);\n}\n\nfunction md5gg(a, b, c, d, x, s, t) {\n  return md5cmn(b & d | c & ~d, a, b, x, s, t);\n}\n\nfunction md5hh(a, b, c, d, x, s, t) {\n  return md5cmn(b ^ c ^ d, a, b, x, s, t);\n}\n\nfunction md5ii(a, b, c, d, x, s, t) {\n  return md5cmn(c ^ (b | ~d), a, b, x, s, t);\n}\n\nexport default md5;","export default '00000000-0000-0000-0000-000000000000';","import validate from './validate.js';\n\nfunction parse(uuid) {\n  if (!validate(uuid)) {\n    throw TypeError('Invalid UUID');\n  }\n\n  var v;\n  var arr = new Uint8Array(16); // Parse ########-....-....-....-............\n\n  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;\n  arr[1] = v >>> 16 & 0xff;\n  arr[2] = v >>> 8 & 0xff;\n  arr[3] = v & 0xff; // Parse ........-####-....-....-............\n\n  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;\n  arr[5] = v & 0xff; // Parse ........-....-####-....-............\n\n  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;\n  arr[7] = v & 0xff; // Parse ........-....-....-####-............\n\n  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;\n  arr[9] = v & 0xff; // Parse ........-....-....-....-############\n  // (Use \"/\" to avoid 32-bit truncation when bit-shifting high-order bytes)\n\n  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;\n  arr[11] = v / 0x100000000 & 0xff;\n  arr[12] = v >>> 24 & 0xff;\n  arr[13] = v >>> 16 & 0xff;\n  arr[14] = v >>> 8 & 0xff;\n  arr[15] = v & 0xff;\n  return arr;\n}\n\nexport default parse;","export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nvar getRandomValues;\nvar rnds8 = new Uint8Array(16);\nexport default function rng() {\n  // lazy load so that environments that need to polyfill have a chance to do so\n  if (!getRandomValues) {\n    // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation. Also,\n    // find the complete implementation of crypto (msCrypto) on IE11.\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\n\n    if (!getRandomValues) {\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n    }\n  }\n\n  return getRandomValues(rnds8);\n}","// Adapted from Chris Veness' SHA1 code at\n// http://www.movable-type.co.uk/scripts/sha1.html\nfunction f(s, x, y, z) {\n  switch (s) {\n    case 0:\n      return x & y ^ ~x & z;\n\n    case 1:\n      return x ^ y ^ z;\n\n    case 2:\n      return x & y ^ x & z ^ y & z;\n\n    case 3:\n      return x ^ y ^ z;\n  }\n}\n\nfunction ROTL(x, n) {\n  return x << n | x >>> 32 - n;\n}\n\nfunction sha1(bytes) {\n  var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];\n  var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];\n\n  if (typeof bytes === 'string') {\n    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\n\n    bytes = [];\n\n    for (var i = 0; i < msg.length; ++i) {\n      bytes.push(msg.charCodeAt(i));\n    }\n  } else if (!Array.isArray(bytes)) {\n    // Convert Array-like to Array\n    bytes = Array.prototype.slice.call(bytes);\n  }\n\n  bytes.push(0x80);\n  var l = bytes.length / 4 + 2;\n  var N = Math.ceil(l / 16);\n  var M = new Array(N);\n\n  for (var _i = 0; _i < N; ++_i) {\n    var arr = new Uint32Array(16);\n\n    for (var j = 0; j < 16; ++j) {\n      arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];\n    }\n\n    M[_i] = arr;\n  }\n\n  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);\n  M[N - 1][14] = Math.floor(M[N - 1][14]);\n  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;\n\n  for (var _i2 = 0; _i2 < N; ++_i2) {\n    var W = new Uint32Array(80);\n\n    for (var t = 0; t < 16; ++t) {\n      W[t] = M[_i2][t];\n    }\n\n    for (var _t = 16; _t < 80; ++_t) {\n      W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);\n    }\n\n    var a = H[0];\n    var b = H[1];\n    var c = H[2];\n    var d = H[3];\n    var e = H[4];\n\n    for (var _t2 = 0; _t2 < 80; ++_t2) {\n      var s = Math.floor(_t2 / 20);\n      var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;\n      e = d;\n      d = c;\n      c = ROTL(b, 30) >>> 0;\n      b = a;\n      a = T;\n    }\n\n    H[0] = H[0] + a >>> 0;\n    H[1] = H[1] + b >>> 0;\n    H[2] = H[2] + c >>> 0;\n    H[3] = H[3] + d >>> 0;\n    H[4] = H[4] + e >>> 0;\n  }\n\n  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];\n}\n\nexport default sha1;","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nvar byteToHex = [];\n\nfor (var i = 0; i < 256; ++i) {\n  byteToHex.push((i + 0x100).toString(16).substr(1));\n}\n\nfunction stringify(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  // Note: Be careful editing this code!  It's been tuned for performance\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one\n  // of the following:\n  // - One or more input array values don't map to a hex octet (leading to\n  // \"undefined\" in the uuid)\n  // - Invalid input values for the RFC `version` or `variant` fields\n\n  if (!validate(uuid)) {\n    throw TypeError('Stringified UUID is invalid');\n  }\n\n  return uuid;\n}\n\nexport default stringify;","import rng from './rng.js';\nimport stringify from './stringify.js'; // **`v1()` - Generate time-based UUID**\n//\n// Inspired by https://github.com/LiosK/UUID.js\n// and http://docs.python.org/library/uuid.html\n\nvar _nodeId;\n\nvar _clockseq; // Previous uuid creation time\n\n\nvar _lastMSecs = 0;\nvar _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details\n\nfunction v1(options, buf, offset) {\n  var i = buf && offset || 0;\n  var b = buf || new Array(16);\n  options = options || {};\n  var node = options.node || _nodeId;\n  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not\n  // specified.  We do this lazily to minimize issues related to insufficient\n  // system entropy.  See #189\n\n  if (node == null || clockseq == null) {\n    var seedBytes = options.random || (options.rng || rng)();\n\n    if (node == null) {\n      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\n      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];\n    }\n\n    if (clockseq == null) {\n      // Per 4.2.2, randomize (14 bit) clockseq\n      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;\n    }\n  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,\n  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so\n  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\n  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\n\n\n  var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock\n  // cycle to simulate higher resolution clock\n\n  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)\n\n  var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression\n\n  if (dt < 0 && options.clockseq === undefined) {\n    clockseq = clockseq + 1 & 0x3fff;\n  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\n  // time interval\n\n\n  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\n    nsecs = 0;\n  } // Per 4.2.1.2 Throw error if too many uuids are requested\n\n\n  if (nsecs >= 10000) {\n    throw new Error(\"uuid.v1(): Can't create more than 10M uuids/sec\");\n  }\n\n  _lastMSecs = msecs;\n  _lastNSecs = nsecs;\n  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\n\n  msecs += 12219292800000; // `time_low`\n\n  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\n  b[i++] = tl >>> 24 & 0xff;\n  b[i++] = tl >>> 16 & 0xff;\n  b[i++] = tl >>> 8 & 0xff;\n  b[i++] = tl & 0xff; // `time_mid`\n\n  var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;\n  b[i++] = tmh >>> 8 & 0xff;\n  b[i++] = tmh & 0xff; // `time_high_and_version`\n\n  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\n\n  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\n\n  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`\n\n  b[i++] = clockseq & 0xff; // `node`\n\n  for (var n = 0; n < 6; ++n) {\n    b[i + n] = node[n];\n  }\n\n  return buf || stringify(b);\n}\n\nexport default v1;","import v35 from './v35.js';\nimport md5 from './md5.js';\nvar v3 = v35('v3', 0x30, md5);\nexport default v3;","import stringify from './stringify.js';\nimport parse from './parse.js';\n\nfunction stringToBytes(str) {\n  str = unescape(encodeURIComponent(str)); // UTF8 escape\n\n  var bytes = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    bytes.push(str.charCodeAt(i));\n  }\n\n  return bytes;\n}\n\nexport var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';\nexport var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';\nexport default function (name, version, hashfunc) {\n  function generateUUID(value, namespace, buf, offset) {\n    if (typeof value === 'string') {\n      value = stringToBytes(value);\n    }\n\n    if (typeof namespace === 'string') {\n      namespace = parse(namespace);\n    }\n\n    if (namespace.length !== 16) {\n      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');\n    } // Compute hash of namespace and value, Per 4.3\n    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =\n    // hashfunc([...namespace, ... value])`\n\n\n    var bytes = new Uint8Array(16 + value.length);\n    bytes.set(namespace);\n    bytes.set(value, namespace.length);\n    bytes = hashfunc(bytes);\n    bytes[6] = bytes[6] & 0x0f | version;\n    bytes[8] = bytes[8] & 0x3f | 0x80;\n\n    if (buf) {\n      offset = offset || 0;\n\n      for (var i = 0; i < 16; ++i) {\n        buf[offset + i] = bytes[i];\n      }\n\n      return buf;\n    }\n\n    return stringify(bytes);\n  } // Function#name is not settable on some platforms (#270)\n\n\n  try {\n    generateUUID.name = name; // eslint-disable-next-line no-empty\n  } catch (err) {} // For CommonJS default export support\n\n\n  generateUUID.DNS = DNS;\n  generateUUID.URL = URL;\n  return generateUUID;\n}","import rng from './rng.js';\nimport stringify from './stringify.js';\n\nfunction v4(options, buf, offset) {\n  options = options || {};\n  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n  rnds[6] = rnds[6] & 0x0f | 0x40;\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n  if (buf) {\n    offset = offset || 0;\n\n    for (var i = 0; i < 16; ++i) {\n      buf[offset + i] = rnds[i];\n    }\n\n    return buf;\n  }\n\n  return stringify(rnds);\n}\n\nexport default v4;","import v35 from './v35.js';\nimport sha1 from './sha1.js';\nvar v5 = v35('v5', 0x50, sha1);\nexport default v5;","import REGEX from './regex.js';\n\nfunction validate(uuid) {\n  return typeof uuid === 'string' && REGEX.test(uuid);\n}\n\nexport default validate;","import validate from './validate.js';\n\nfunction version(uuid) {\n  if (!validate(uuid)) {\n    throw TypeError('Invalid UUID');\n  }\n\n  return parseInt(uuid.substr(14, 1), 16);\n}\n\nexport default version;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\n\n// The following polyfills are needed for IE11\n\nimport { ApiVersion } from '@tableau/api-shared-js';\nimport 'core-js/es/array/find';\nimport 'core-js/es/array/from';\nimport 'core-js/es/map';\nimport 'core-js/es/number/is-integer';\nimport 'core-js/es/number/is-nan';\nimport 'core-js/es/number/parse-float';\nimport 'core-js/es/number/parse-int';\nimport 'core-js/es/object/assign';\nimport 'core-js/es/object/entries';\nimport 'core-js/es/object/set-prototype-of';\nimport 'core-js/es/promise';\n// Due to the way we configured webpack, we should be exporting things which will be under\n// a global variable called \"tableau\". Export everything we want to be visible under tableau\n// from this file.\nimport { ExtensionsImpl } from './ExtensionsApi/Impl/ExtensionsImpl';\nimport { Extensions } from './ExtensionsApi/Namespaces/Extensions';\n\ndeclare let VERSION_IS_ALPHA: boolean;\nconst isAlpha: boolean = typeof VERSION_IS_ALPHA !== 'undefined' ? VERSION_IS_ALPHA : false;\n\ndeclare let API_VERSION_NUMBER: string;\nApiVersion.SetVersionNumber(typeof API_VERSION_NUMBER !== 'undefined' ? API_VERSION_NUMBER : '0.0.0', isAlpha);\n\nconst extensionImpl = new ExtensionsImpl();\nexport const extensions = new Extensions(extensionImpl);\n\n// Export Enums\n// These show up under the tableau object. I.e. tableau.ExtensionContext.Server\nexport {\n  AnalyticsObjectType,\n  AnnotationType,\n  ClassNameKey,\n  ColumnType,\n  DashboardLayoutChange,\n  DashboardObjectType,\n  DashboardObjectVisibilityType,\n  DataType,\n  DateRangeType,\n  DialogStyle,\n  EncodingType,\n  ErrorCodes,\n  ExtensionContext,\n  ExtensionMode,\n  FieldAggregationType,\n  FieldRoleType,\n  FilterDomainType,\n  FilterNullOption,\n  FilterType,\n  FilterUpdateType,\n  HierarchicalLevelSelectionState,\n  IncludeDataValuesOption,\n  MarkType,\n  ParameterValueType,\n  PeriodType,\n  QuickTableCalcType,\n  RelativeDateFilterOptions,\n  ReplaySpeedType,\n  SelectOptions,\n  SelectionUpdateType,\n  SheetType,\n  SortDirection,\n  TableauEventType,\n  TrendLineModelType,\n  VizImageEncodingType,\n  VizImagePaletteType,\n  VizImageSizeSettingAlignmentType,\n  VizImageSizeSettingType,\n  VizImageSortDirectionType,\n  ZoneVisibilityType,\n} from '@tableau/api-external-contract-js';\n"],"names":[],"sourceRoot":""} \ No newline at end of file diff --git a/lib/tableau.extensions.1.12.0.min.js b/lib/tableau.extensions.1.12.0.min.js new file mode 100644 index 00000000..fd2bda4a --- /dev/null +++ b/lib/tableau.extensions.1.12.0.min.js @@ -0,0 +1,2 @@ +(()=>{var e={3e3:(e,t,r)=>{r(5092);var n=r(7880);e.exports=n("Array","find")},8315:(e,t,r)=>{r(8504),r(5684);var n=r(340);e.exports=n.Array.from},80:(e,t,r)=>{r(3924),r(472),r(7912),r(8504);var n=r(340);e.exports=n.Map},5668:(e,t,r)=>{r(1300);var n=r(340);e.exports=n.Number.isInteger},5816:(e,t,r)=>{r(3656);var n=r(340);e.exports=n.Number.isNaN},3680:(e,t,r)=>{r(6544);var n=r(340);e.exports=n.Number.parseFloat},9308:(e,t,r)=>{r(7972);var n=r(340);e.exports=n.Number.parseInt},8824:(e,t,r)=>{r(6368);var n=r(340);e.exports=n.Object.assign},8512:(e,t,r)=>{r(8292);var n=r(340);e.exports=n.Object.entries},9232:(e,t,r)=>{r(920);var n=r(340);e.exports=n.Object.setPrototypeOf},9336:(e,t,r)=>{r(6140),r(3924),r(7912),r(7448),r(3936),r(5428),r(1517),r(8504);var n=r(340);e.exports=n.Promise},1381:(e,t,r)=>{var n=r(1600),i=r(984),o=r(1532),a=n.TypeError;e.exports=function(e){if(i(e))return e;throw a(o(e)+" is not a function")}},6372:(e,t,r)=>{var n=r(1600),i=r(5220),o=r(1532),a=n.TypeError;e.exports=function(e){if(i(e))return e;throw a(o(e)+" is not a constructor")}},4040:(e,t,r)=>{var n=r(1600),i=r(984),o=n.String,a=n.TypeError;e.exports=function(e){if("object"==typeof e||i(e))return e;throw a("Can't set "+o(e)+" as a prototype")}},5868:(e,t,r)=>{var n=r(3668),i=r(124),o=r(7072),a=n("unscopables"),s=Array.prototype;null==s[a]&&o.f(s,a,{configurable:!0,value:i(null)}),e.exports=function(e){s[a][e]=!0}},2932:(e,t,r)=>{var n=r(1600),i=r(2408),o=n.TypeError;e.exports=function(e,t){if(i(t,e))return e;throw o("Incorrect invocation")}},3736:(e,t,r)=>{var n=r(1600),i=r(9952),o=n.String,a=n.TypeError;e.exports=function(e){if(i(e))return e;throw a(o(e)+" is not an object")}},8208:(e,t,r)=>{"use strict";var n=r(1600),i=r(5616),o=r(3032),a=r(3848),s=r(3140),u=r(4064),l=r(5220),c=r(9183),p=r(4135),d=r(4944),f=r(8132),y=n.Array;e.exports=function(e){var t=a(e),r=l(this),n=arguments.length,h=n>1?arguments[1]:void 0,m=void 0!==h;m&&(h=i(h,n>2?arguments[2]:void 0));var g,v,b,I,S,_,T=f(t),P=0;if(!T||this==y&&u(T))for(g=c(t),v=r?new this(g):y(g);g>P;P++)_=m?h(t[P],P):t[P],p(v,P,_);else for(S=(I=d(t,T)).next,v=r?new this:[];!(b=o(S,I)).done;P++)_=m?s(I,h,[b.value,P],!0):b.value,p(v,P,_);return v.length=P,v}},6024:(e,t,r)=>{var n=r(3068),i=r(7920),o=r(9183),a=function(e){return function(t,r,a){var s,u=n(t),l=o(u),c=i(a,l);if(e&&r!=r){for(;l>c;)if((s=u[c++])!=s)return!0}else for(;l>c;c++)if((e||c in u)&&u[c]===r)return e||c||0;return!e&&-1}};e.exports={includes:a(!0),indexOf:a(!1)}},9560:(e,t,r)=>{var n=r(5616),i=r(604),o=r(3188),a=r(3848),s=r(9183),u=r(1220),l=i([].push),c=function(e){var t=1==e,r=2==e,i=3==e,c=4==e,p=6==e,d=7==e,f=5==e||p;return function(y,h,m,g){for(var v,b,I=a(y),S=o(I),_=n(h,m),T=s(S),P=0,A=g||u,E=t?A(y,T):r||d?A(y,0):void 0;T>P;P++)if((f||P in S)&&(b=_(v=S[P],P,I),e))if(t)E[P]=b;else if(b)switch(e){case 3:return!0;case 5:return v;case 6:return P;case 2:l(E,v)}else switch(e){case 4:return!1;case 7:l(E,v)}return p?-1:i||c?c:E}};e.exports={forEach:c(0),map:c(1),filter:c(2),some:c(3),every:c(4),find:c(5),findIndex:c(6),filterReject:c(7)}},6100:(e,t,r)=>{var n=r(604);e.exports=n([].slice)},4096:(e,t,r)=>{var n=r(1600),i=r(5240),o=r(5220),a=r(9952),s=r(3668)("species"),u=n.Array;e.exports=function(e){var t;return i(e)&&(t=e.constructor,(o(t)&&(t===u||i(t.prototype))||a(t)&&null===(t=t[s]))&&(t=void 0)),void 0===t?u:t}},1220:(e,t,r)=>{var n=r(4096);e.exports=function(e,t){return new(n(e))(0===t?0:t)}},3140:(e,t,r)=>{var n=r(3736),i=r(1792);e.exports=function(e,t,r,o){try{return o?t(n(r)[0],r[1]):t(r)}catch(t){i(e,"throw",t)}}},6344:(e,t,r)=>{var n=r(3668)("iterator"),i=!1;try{var o=0,a={next:function(){return{done:!!o++}},return:function(){i=!0}};a[n]=function(){return this},Array.from(a,(function(){throw 2}))}catch(e){}e.exports=function(e,t){if(!t&&!i)return!1;var r=!1;try{var o={};o[n]=function(){return{next:function(){return{done:r=!0}}}},e(o)}catch(e){}return r}},4108:(e,t,r)=>{var n=r(604),i=n({}.toString),o=n("".slice);e.exports=function(e){return o(i(e),8,-1)}},1248:(e,t,r)=>{var n=r(1600),i=r(7796),o=r(984),a=r(4108),s=r(3668)("toStringTag"),u=n.Object,l="Arguments"==a(function(){return arguments}());e.exports=i?a:function(e){var t,r,n;return void 0===e?"Undefined":null===e?"Null":"string"==typeof(r=function(e,t){try{return e[t]}catch(e){}}(t=u(e),s))?r:l?a(t):"Object"==(n=a(t))&&o(t.callee)?"Arguments":n}},5032:(e,t,r)=>{var n=r(604),i=r(6100),o=n("".replace),a=n("".split),s=n([].join),u=String(Error("zxcasd").stack),l=/\n\s*at [^:]*:[^\n]*/,c=l.test(u),p=/@[^\n]*\n/.test(u)&&!/zxcasd/.test(u);e.exports=function(e,t){if("string"!=typeof e)return e;if(c)for(;t--;)e=o(e,l,"");else if(p)return s(i(a(e,"\n"),t),"\n");return e}},9920:(e,t,r)=>{"use strict";var n=r(7072).f,i=r(124),o=r(7431),a=r(5616),s=r(2932),u=r(9928),l=r(2648),c=r(9688),p=r(2828),d=r(8756).fastKey,f=r(7932),y=f.set,h=f.getterFor;e.exports={getConstructor:function(e,t,r,l){var c=e((function(e,n){s(e,f),y(e,{type:t,index:i(null),first:void 0,last:void 0,size:0}),p||(e.size=0),null!=n&&u(n,e[l],{that:e,AS_ENTRIES:r})})),f=c.prototype,m=h(t),g=function(e,t,r){var n,i,o=m(e),a=v(e,t);return a?a.value=r:(o.last=a={index:i=d(t,!0),key:t,value:r,previous:n=o.last,next:void 0,removed:!1},o.first||(o.first=a),n&&(n.next=a),p?o.size++:e.size++,"F"!==i&&(o.index[i]=a)),e},v=function(e,t){var r,n=m(e),i=d(t);if("F"!==i)return n.index[i];for(r=n.first;r;r=r.next)if(r.key==t)return r};return o(f,{clear:function(){for(var e=m(this),t=e.index,r=e.first;r;)r.removed=!0,r.previous&&(r.previous=r.previous.next=void 0),delete t[r.index],r=r.next;e.first=e.last=void 0,p?e.size=0:this.size=0},delete:function(e){var t=this,r=m(t),n=v(t,e);if(n){var i=n.next,o=n.previous;delete r.index[n.index],n.removed=!0,o&&(o.next=i),i&&(i.previous=o),r.first==n&&(r.first=i),r.last==n&&(r.last=o),p?r.size--:t.size--}return!!n},forEach:function(e){for(var t,r=m(this),n=a(e,arguments.length>1?arguments[1]:void 0);t=t?t.next:r.first;)for(n(t.value,t.key,this);t&&t.removed;)t=t.previous},has:function(e){return!!v(this,e)}}),o(f,r?{get:function(e){var t=v(this,e);return t&&t.value},set:function(e,t){return g(this,0===e?0:e,t)}}:{add:function(e){return g(this,e=0===e?0:e,e)}}),p&&n(f,"size",{get:function(){return m(this).size}}),c},setStrong:function(e,t,r){var n=t+" Iterator",i=h(t),o=h(n);l(e,t,(function(e,t){y(this,{type:n,target:e,state:i(e),kind:t,last:void 0})}),(function(){for(var e=o(this),t=e.kind,r=e.last;r&&r.removed;)r=r.previous;return e.target&&(e.last=r=r?r.next:e.state.first)?"keys"==t?{value:r.key,done:!1}:"values"==t?{value:r.value,done:!1}:{value:[r.key,r.value],done:!1}:(e.target=void 0,{value:void 0,done:!0})}),r?"entries":"values",!r,!0),c(t)}}},6064:(e,t,r)=>{"use strict";var n=r(7248),i=r(1600),o=r(604),a=r(4232),s=r(5028),u=r(8756),l=r(9928),c=r(2932),p=r(984),d=r(9952),f=r(7004),y=r(6344),h=r(9540),m=r(7692);e.exports=function(e,t,r){var g=-1!==e.indexOf("Map"),v=-1!==e.indexOf("Weak"),b=g?"set":"add",I=i[e],S=I&&I.prototype,_=I,T={},P=function(e){var t=o(S[e]);s(S,e,"add"==e?function(e){return t(this,0===e?0:e),this}:"delete"==e?function(e){return!(v&&!d(e))&&t(this,0===e?0:e)}:"get"==e?function(e){return v&&!d(e)?void 0:t(this,0===e?0:e)}:"has"==e?function(e){return!(v&&!d(e))&&t(this,0===e?0:e)}:function(e,r){return t(this,0===e?0:e,r),this})};if(a(e,!p(I)||!(v||S.forEach&&!f((function(){(new I).entries().next()})))))_=r.getConstructor(t,e,g,b),u.enable();else if(a(e,!0)){var A=new _,E=A[b](v?{}:-0,1)!=A,w=f((function(){A.has(1)})),O=y((function(e){new I(e)})),D=!v&&f((function(){for(var e=new I,t=5;t--;)e[b](t,t);return!e.has(-0)}));O||((_=t((function(e,t){c(e,S);var r=m(new I,e,_);return null!=t&&l(t,r[b],{that:r,AS_ENTRIES:g}),r}))).prototype=S,S.constructor=_),(w||D)&&(P("delete"),P("has"),g&&P("get")),(D||E)&&P(b),v&&S.clear&&delete S.clear}return T[e]=_,n({global:!0,forced:_!=I},T),h(_,e),v||r.setStrong(_,e,g),_}},4640:(e,t,r)=>{var n=r(9180),i=r(4092),o=r(2920),a=r(7072);e.exports=function(e,t){for(var r=i(t),s=a.f,u=o.f,l=0;l{var n=r(7004);e.exports=!n((function(){function e(){}return e.prototype.constructor=null,Object.getPrototypeOf(new e)!==e.prototype}))},9292:(e,t,r)=>{"use strict";var n=r(804).IteratorPrototype,i=r(124),o=r(364),a=r(9540),s=r(2204),u=function(){return this};e.exports=function(e,t,r){var l=t+" Iterator";return e.prototype=i(n,{next:o(1,r)}),a(e,l,!1,!0),s[l]=u,e}},4768:(e,t,r)=>{var n=r(2828),i=r(7072),o=r(364);e.exports=n?function(e,t,r){return i.f(e,t,o(1,r))}:function(e,t,r){return e[t]=r,e}},364:e=>{e.exports=function(e,t){return{enumerable:!(1&e),configurable:!(2&e),writable:!(4&e),value:t}}},4135:(e,t,r)=>{"use strict";var n=r(4061),i=r(7072),o=r(364);e.exports=function(e,t,r){var a=n(t);a in e?i.f(e,a,o(0,r)):e[a]=r}},2648:(e,t,r)=>{"use strict";var n=r(7248),i=r(3032),o=r(7408),a=r(8492),s=r(984),u=r(9292),l=r(6232),c=r(3440),p=r(9540),d=r(4768),f=r(5028),y=r(3668),h=r(2204),m=r(804),g=a.PROPER,v=a.CONFIGURABLE,b=m.IteratorPrototype,I=m.BUGGY_SAFARI_ITERATORS,S=y("iterator"),_="keys",T="values",P="entries",A=function(){return this};e.exports=function(e,t,r,a,y,m,E){u(r,t,a);var w,O,D,x=function(e){if(e===y&&k)return k;if(!I&&e in N)return N[e];switch(e){case _:case T:case P:return function(){return new r(this,e)}}return function(){return new r(this)}},F=t+" Iterator",C=!1,N=e.prototype,M=N[S]||N["@@iterator"]||y&&N[y],k=!I&&M||x(y),R="Array"==t&&N.entries||M;if(R&&(w=l(R.call(new e)))!==Object.prototype&&w.next&&(o||l(w)===b||(c?c(w,b):s(w[S])||f(w,S,A)),p(w,F,!0,!0),o&&(h[F]=A)),g&&y==T&&M&&M.name!==T&&(!o&&v?d(N,"name",T):(C=!0,k=function(){return i(M,this)})),y)if(O={values:x(T),keys:m?k:x(_),entries:x(P)},E)for(D in O)(I||C||!(D in N))&&f(N,D,O[D]);else n({target:t,proto:!0,forced:I||C},O);return o&&!E||N[S]===k||f(N,S,k,{name:y}),h[t]=k,O}},2828:(e,t,r)=>{var n=r(7004);e.exports=!n((function(){return 7!=Object.defineProperty({},1,{get:function(){return 7}})[1]}))},7300:(e,t,r)=>{var n=r(1600),i=r(9952),o=n.document,a=i(o)&&i(o.createElement);e.exports=function(e){return a?o.createElement(e):{}}},4532:e=>{e.exports="object"==typeof window},264:(e,t,r)=>{var n=r(5316),i=r(1600);e.exports=/ipad|iphone|ipod/i.test(n)&&void 0!==i.Pebble},1588:(e,t,r)=>{var n=r(5316);e.exports=/(?:ipad|iphone|ipod).*applewebkit/i.test(n)},3640:(e,t,r)=>{var n=r(4108),i=r(1600);e.exports="process"==n(i.process)},7888:(e,t,r)=>{var n=r(5316);e.exports=/web0s(?!.*chrome)/i.test(n)},5316:(e,t,r)=>{var n=r(6532);e.exports=n("navigator","userAgent")||""},2592:(e,t,r)=>{var n,i,o=r(1600),a=r(5316),s=o.process,u=o.Deno,l=s&&s.versions||u&&u.version,c=l&&l.v8;c&&(i=(n=c.split("."))[0]>0&&n[0]<4?1:+(n[0]+n[1])),!i&&a&&(!(n=a.match(/Edge\/(\d+)/))||n[1]>=74)&&(n=a.match(/Chrome\/(\d+)/))&&(i=+n[1]),e.exports=i},7880:(e,t,r)=>{var n=r(1600),i=r(604);e.exports=function(e,t){return i(n[e].prototype[t])}},8675:e=>{e.exports=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"]},4464:(e,t,r)=>{var n=r(7004),i=r(364);e.exports=!n((function(){var e=Error("a");return!("stack"in e)||(Object.defineProperty(e,"stack",i(1,7)),7!==e.stack)}))},7248:(e,t,r)=>{var n=r(1600),i=r(2920).f,o=r(4768),a=r(5028),s=r(2984),u=r(4640),l=r(4232);e.exports=function(e,t){var r,c,p,d,f,y=e.target,h=e.global,m=e.stat;if(r=h?n:m?n[y]||s(y,{}):(n[y]||{}).prototype)for(c in t){if(d=t[c],p=e.noTargetGet?(f=i(r,c))&&f.value:r[c],!l(h?c:y+(m?".":"#")+c,e.forced)&&void 0!==p){if(typeof d==typeof p)continue;u(d,p)}(e.sham||p&&p.sham)&&o(d,"sham",!0),a(r,c,d,e)}}},7004:e=>{e.exports=function(e){try{return!!e()}catch(e){return!0}}},1748:(e,t,r)=>{var n=r(7004);e.exports=!n((function(){return Object.isExtensible(Object.preventExtensions({}))}))},9756:e=>{var t=Function.prototype,r=t.apply,n=t.bind,i=t.call;e.exports="object"==typeof Reflect&&Reflect.apply||(n?i.bind(r):function(){return i.apply(r,arguments)})},5616:(e,t,r)=>{var n=r(604),i=r(1381),o=n(n.bind);e.exports=function(e,t){return i(e),void 0===t?e:o?o(e,t):function(){return e.apply(t,arguments)}}},3032:e=>{var t=Function.prototype.call;e.exports=t.bind?t.bind(t):function(){return t.apply(t,arguments)}},8492:(e,t,r)=>{var n=r(2828),i=r(9180),o=Function.prototype,a=n&&Object.getOwnPropertyDescriptor,s=i(o,"name"),u=s&&"something"===function(){}.name,l=s&&(!n||n&&a(o,"name").configurable);e.exports={EXISTS:s,PROPER:u,CONFIGURABLE:l}},604:e=>{var t=Function.prototype,r=t.bind,n=t.call,i=r&&r.bind(n);e.exports=r?function(e){return e&&i(n,e)}:function(e){return e&&function(){return n.apply(e,arguments)}}},6532:(e,t,r)=>{var n=r(1600),i=r(984);e.exports=function(e,t){return arguments.length<2?(r=n[e],i(r)?r:void 0):n[e]&&n[e][t];var r}},8132:(e,t,r)=>{var n=r(1248),i=r(8808),o=r(2204),a=r(3668)("iterator");e.exports=function(e){if(null!=e)return i(e,a)||i(e,"@@iterator")||o[n(e)]}},4944:(e,t,r)=>{var n=r(1600),i=r(3032),o=r(1381),a=r(3736),s=r(1532),u=r(8132),l=n.TypeError;e.exports=function(e,t){var r=arguments.length<2?u(e):t;if(o(r))return a(i(r,e));throw l(s(e)+" is not iterable")}},8808:(e,t,r)=>{var n=r(1381);e.exports=function(e,t){var r=e[t];return null==r?void 0:n(r)}},1600:(e,t,r)=>{var n=function(e){return e&&e.Math==Math&&e};e.exports=n("object"==typeof globalThis&&globalThis)||n("object"==typeof window&&window)||n("object"==typeof self&&self)||n("object"==typeof r.g&&r.g)||function(){return this}()||Function("return this")()},9180:(e,t,r)=>{var n=r(604),i=r(3848),o=n({}.hasOwnProperty);e.exports=Object.hasOwn||function(e,t){return o(i(e),t)}},6632:e=>{e.exports={}},5651:(e,t,r)=>{var n=r(1600);e.exports=function(e,t){var r=n.console;r&&r.error&&(1==arguments.length?r.error(e):r.error(e,t))}},2960:(e,t,r)=>{var n=r(6532);e.exports=n("document","documentElement")},2339:(e,t,r)=>{var n=r(2828),i=r(7004),o=r(7300);e.exports=!n&&!i((function(){return 7!=Object.defineProperty(o("div"),"a",{get:function(){return 7}}).a}))},3188:(e,t,r)=>{var n=r(1600),i=r(604),o=r(7004),a=r(4108),s=n.Object,u=i("".split);e.exports=o((function(){return!s("z").propertyIsEnumerable(0)}))?function(e){return"String"==a(e)?u(e,""):s(e)}:s},7692:(e,t,r)=>{var n=r(984),i=r(9952),o=r(3440);e.exports=function(e,t,r){var a,s;return o&&n(a=t.constructor)&&a!==r&&i(s=a.prototype)&&s!==r.prototype&&o(e,s),e}},1727:(e,t,r)=>{var n=r(604),i=r(984),o=r(6376),a=n(Function.toString);i(o.inspectSource)||(o.inspectSource=function(e){return a(e)}),e.exports=o.inspectSource},7660:(e,t,r)=>{var n=r(9952),i=r(4768);e.exports=function(e,t){n(t)&&"cause"in t&&i(e,"cause",t.cause)}},8756:(e,t,r)=>{var n=r(7248),i=r(604),o=r(6632),a=r(9952),s=r(9180),u=r(7072).f,l=r(4880),c=r(7316),p=r(6536),d=r(1748),f=!1,y=p("meta"),h=0,m=Object.isExtensible||function(){return!0},g=function(e){u(e,y,{value:{objectID:"O"+h++,weakData:{}}})},v=e.exports={enable:function(){v.enable=function(){},f=!0;var e=l.f,t=i([].splice),r={};r[y]=1,e(r).length&&(l.f=function(r){for(var n=e(r),i=0,o=n.length;i{var n,i,o,a=r(8736),s=r(1600),u=r(604),l=r(9952),c=r(4768),p=r(9180),d=r(6376),f=r(280),y=r(6632),h="Object already initialized",m=s.TypeError,g=s.WeakMap;if(a||d.state){var v=d.state||(d.state=new g),b=u(v.get),I=u(v.has),S=u(v.set);n=function(e,t){if(I(v,e))throw new m(h);return t.facade=e,S(v,e,t),t},i=function(e){return b(v,e)||{}},o=function(e){return I(v,e)}}else{var _=f("state");y[_]=!0,n=function(e,t){if(p(e,_))throw new m(h);return t.facade=e,c(e,_,t),t},i=function(e){return p(e,_)?e[_]:{}},o=function(e){return p(e,_)}}e.exports={set:n,get:i,has:o,enforce:function(e){return o(e)?i(e):n(e,{})},getterFor:function(e){return function(t){var r;if(!l(t)||(r=i(t)).type!==e)throw m("Incompatible receiver, "+e+" required");return r}}}},4064:(e,t,r)=>{var n=r(3668),i=r(2204),o=n("iterator"),a=Array.prototype;e.exports=function(e){return void 0!==e&&(i.Array===e||a[o]===e)}},5240:(e,t,r)=>{var n=r(4108);e.exports=Array.isArray||function(e){return"Array"==n(e)}},984:e=>{e.exports=function(e){return"function"==typeof e}},5220:(e,t,r)=>{var n=r(604),i=r(7004),o=r(984),a=r(1248),s=r(6532),u=r(1727),l=function(){},c=[],p=s("Reflect","construct"),d=/^\s*(?:class|function)\b/,f=n(d.exec),y=!d.exec(l),h=function(e){if(!o(e))return!1;try{return p(l,c,e),!0}catch(e){return!1}};e.exports=!p||i((function(){var e;return h(h.call)||!h(Object)||!h((function(){e=!0}))||e}))?function(e){if(!o(e))return!1;switch(a(e)){case"AsyncFunction":case"GeneratorFunction":case"AsyncGeneratorFunction":return!1}return y||!!f(d,u(e))}:h},4232:(e,t,r)=>{var n=r(7004),i=r(984),o=/#|\.prototype\./,a=function(e,t){var r=u[s(e)];return r==c||r!=l&&(i(t)?n(t):!!t)},s=a.normalize=function(e){return String(e).replace(o,".").toLowerCase()},u=a.data={},l=a.NATIVE="N",c=a.POLYFILL="P";e.exports=a},992:(e,t,r)=>{var n=r(9952),i=Math.floor;e.exports=Number.isInteger||function(e){return!n(e)&&isFinite(e)&&i(e)===e}},9952:(e,t,r)=>{var n=r(984);e.exports=function(e){return"object"==typeof e?null!==e:n(e)}},7408:e=>{e.exports=!1},1836:(e,t,r)=>{var n=r(1600),i=r(6532),o=r(984),a=r(2408),s=r(7216),u=n.Object;e.exports=s?function(e){return"symbol"==typeof e}:function(e){var t=i("Symbol");return o(t)&&a(t.prototype,u(e))}},9928:(e,t,r)=>{var n=r(1600),i=r(5616),o=r(3032),a=r(3736),s=r(1532),u=r(4064),l=r(9183),c=r(2408),p=r(4944),d=r(8132),f=r(1792),y=n.TypeError,h=function(e,t){this.stopped=e,this.result=t},m=h.prototype;e.exports=function(e,t,r){var n,g,v,b,I,S,_,T=r&&r.that,P=!(!r||!r.AS_ENTRIES),A=!(!r||!r.IS_ITERATOR),E=!(!r||!r.INTERRUPTED),w=i(t,T),O=function(e){return n&&f(n,"normal",e),new h(!0,e)},D=function(e){return P?(a(e),E?w(e[0],e[1],O):w(e[0],e[1])):E?w(e,O):w(e)};if(A)n=e;else{if(!(g=d(e)))throw y(s(e)+" is not iterable");if(u(g)){for(v=0,b=l(e);b>v;v++)if((I=D(e[v]))&&c(m,I))return I;return new h(!1)}n=p(e,g)}for(S=n.next;!(_=o(S,n)).done;){try{I=D(_.value)}catch(e){f(n,"throw",e)}if("object"==typeof I&&I&&c(m,I))return I}return new h(!1)}},1792:(e,t,r)=>{var n=r(3032),i=r(3736),o=r(8808);e.exports=function(e,t,r){var a,s;i(e);try{if(!(a=o(e,"return"))){if("throw"===t)throw r;return r}a=n(a,e)}catch(e){s=!0,a=e}if("throw"===t)throw r;if(s)throw a;return i(a),r}},804:(e,t,r)=>{"use strict";var n,i,o,a=r(7004),s=r(984),u=r(124),l=r(6232),c=r(5028),p=r(3668),d=r(7408),f=p("iterator"),y=!1;[].keys&&("next"in(o=[].keys())?(i=l(l(o)))!==Object.prototype&&(n=i):y=!0),null==n||a((function(){var e={};return n[f].call(e)!==e}))?n={}:d&&(n=u(n)),s(n[f])||c(n,f,(function(){return this})),e.exports={IteratorPrototype:n,BUGGY_SAFARI_ITERATORS:y}},2204:e=>{e.exports={}},9183:(e,t,r)=>{var n=r(1868);e.exports=function(e){return n(e.length)}},3104:(e,t,r)=>{var n,i,o,a,s,u,l,c,p=r(1600),d=r(5616),f=r(2920).f,y=r(5952).set,h=r(1588),m=r(264),g=r(7888),v=r(3640),b=p.MutationObserver||p.WebKitMutationObserver,I=p.document,S=p.process,_=p.Promise,T=f(p,"queueMicrotask"),P=T&&T.value;P||(n=function(){var e,t;for(v&&(e=S.domain)&&e.exit();i;){t=i.fn,i=i.next;try{t()}catch(e){throw i?a():o=void 0,e}}o=void 0,e&&e.enter()},h||v||g||!b||!I?!m&&_&&_.resolve?((l=_.resolve(void 0)).constructor=_,c=d(l.then,l),a=function(){c(n)}):v?a=function(){S.nextTick(n)}:(y=d(y,p),a=function(){y(n)}):(s=!0,u=I.createTextNode(""),new b(n).observe(u,{characterData:!0}),a=function(){u.data=s=!s})),e.exports=P||function(e){var t={fn:e,next:void 0};o&&(o.next=t),i||(i=t,a()),o=t}},3459:(e,t,r)=>{var n=r(1600);e.exports=n.Promise},3880:(e,t,r)=>{var n=r(2592),i=r(7004);e.exports=!!Object.getOwnPropertySymbols&&!i((function(){var e=Symbol();return!String(e)||!(Object(e)instanceof Symbol)||!Symbol.sham&&n&&n<41}))},8736:(e,t,r)=>{var n=r(1600),i=r(984),o=r(1727),a=n.WeakMap;e.exports=i(a)&&/native code/.test(o(a))},8071:(e,t,r)=>{"use strict";var n=r(1381),i=function(e){var t,r;this.promise=new e((function(e,n){if(void 0!==t||void 0!==r)throw TypeError("Bad Promise constructor");t=e,r=n})),this.resolve=n(t),this.reject=n(r)};e.exports.f=function(e){return new i(e)}},5744:(e,t,r)=>{var n=r(748);e.exports=function(e,t){return void 0===e?arguments.length<2?"":t:n(e)}},6016:(e,t,r)=>{var n=r(1600),i=r(7004),o=r(604),a=r(748),s=r(1688).trim,u=r(5320),l=o("".charAt),c=n.parseFloat,p=n.Symbol,d=p&&p.iterator,f=1/c(u+"-0")!=-1/0||d&&!i((function(){c(Object(d))}));e.exports=f?function(e){var t=s(a(e)),r=c(t);return 0===r&&"-"==l(t,0)?-0:r}:c},6556:(e,t,r)=>{var n=r(1600),i=r(7004),o=r(604),a=r(748),s=r(1688).trim,u=r(5320),l=n.parseInt,c=n.Symbol,p=c&&c.iterator,d=/^[+-]?0x/i,f=o(d.exec),y=8!==l(u+"08")||22!==l(u+"0x16")||p&&!i((function(){l(Object(p))}));e.exports=y?function(e,t){var r=s(a(e));return l(r,t>>>0||(f(d,r)?16:10))}:l},6984:(e,t,r)=>{"use strict";var n=r(2828),i=r(604),o=r(3032),a=r(7004),s=r(9880),u=r(2128),l=r(5988),c=r(3848),p=r(3188),d=Object.assign,f=Object.defineProperty,y=i([].concat);e.exports=!d||a((function(){if(n&&1!==d({b:1},d(f({},"a",{enumerable:!0,get:function(){f(this,"b",{value:3,enumerable:!1})}}),{b:2})).b)return!0;var e={},t={},r=Symbol(),i="abcdefghijklmnopqrst";return e[r]=7,i.split("").forEach((function(e){t[e]=e})),7!=d({},e)[r]||s(d({},t)).join("")!=i}))?function(e,t){for(var r=c(e),i=arguments.length,a=1,d=u.f,f=l.f;i>a;)for(var h,m=p(arguments[a++]),g=d?y(s(m),d(m)):s(m),v=g.length,b=0;v>b;)h=g[b++],n&&!o(f,m,h)||(r[h]=m[h]);return r}:d},124:(e,t,r)=>{var n,i=r(3736),o=r(1904),a=r(8675),s=r(6632),u=r(2960),l=r(7300),c=r(280),p="prototype",d="script",f=c("IE_PROTO"),y=function(){},h=function(e){return"<"+d+">"+e+""},m=function(e){e.write(h("")),e.close();var t=e.parentWindow.Object;return e=null,t},g=function(){try{n=new ActiveXObject("htmlfile")}catch(e){}var e,t,r;g="undefined"!=typeof document?document.domain&&n?m(n):(t=l("iframe"),r="java"+d+":",t.style.display="none",u.appendChild(t),t.src=String(r),(e=t.contentWindow.document).open(),e.write(h("document.F=Object")),e.close(),e.F):m(n);for(var i=a.length;i--;)delete g[p][a[i]];return g()};s[f]=!0,e.exports=Object.create||function(e,t){var r;return null!==e?(y[p]=i(e),r=new y,y[p]=null,r[f]=e):r=g(),void 0===t?r:o(r,t)}},1904:(e,t,r)=>{var n=r(2828),i=r(7072),o=r(3736),a=r(3068),s=r(9880);e.exports=n?Object.defineProperties:function(e,t){o(e);for(var r,n=a(t),u=s(t),l=u.length,c=0;l>c;)i.f(e,r=u[c++],n[r]);return e}},7072:(e,t,r)=>{var n=r(1600),i=r(2828),o=r(2339),a=r(3736),s=r(4061),u=n.TypeError,l=Object.defineProperty;t.f=i?l:function(e,t,r){if(a(e),t=s(t),a(r),o)try{return l(e,t,r)}catch(e){}if("get"in r||"set"in r)throw u("Accessors not supported");return"value"in r&&(e[t]=r.value),e}},2920:(e,t,r)=>{var n=r(2828),i=r(3032),o=r(5988),a=r(364),s=r(3068),u=r(4061),l=r(9180),c=r(2339),p=Object.getOwnPropertyDescriptor;t.f=n?p:function(e,t){if(e=s(e),t=u(t),c)try{return p(e,t)}catch(e){}if(l(e,t))return a(!i(o.f,e,t),e[t])}},7316:(e,t,r)=>{var n=r(4108),i=r(3068),o=r(4880).f,a=r(6100),s="object"==typeof window&&window&&Object.getOwnPropertyNames?Object.getOwnPropertyNames(window):[];e.exports.f=function(e){return s&&"Window"==n(e)?function(e){try{return o(e)}catch(e){return a(s)}}(e):o(i(e))}},4880:(e,t,r)=>{var n=r(9912),i=r(8675).concat("length","prototype");t.f=Object.getOwnPropertyNames||function(e){return n(e,i)}},2128:(e,t)=>{t.f=Object.getOwnPropertySymbols},6232:(e,t,r)=>{var n=r(1600),i=r(9180),o=r(984),a=r(3848),s=r(280),u=r(1040),l=s("IE_PROTO"),c=n.Object,p=c.prototype;e.exports=u?c.getPrototypeOf:function(e){var t=a(e);if(i(t,l))return t[l];var r=t.constructor;return o(r)&&t instanceof r?r.prototype:t instanceof c?p:null}},2408:(e,t,r)=>{var n=r(604);e.exports=n({}.isPrototypeOf)},9912:(e,t,r)=>{var n=r(604),i=r(9180),o=r(3068),a=r(6024).indexOf,s=r(6632),u=n([].push);e.exports=function(e,t){var r,n=o(e),l=0,c=[];for(r in n)!i(s,r)&&i(n,r)&&u(c,r);for(;t.length>l;)i(n,r=t[l++])&&(~a(c,r)||u(c,r));return c}},9880:(e,t,r)=>{var n=r(9912),i=r(8675);e.exports=Object.keys||function(e){return n(e,i)}},5988:(e,t)=>{"use strict";var r={}.propertyIsEnumerable,n=Object.getOwnPropertyDescriptor,i=n&&!r.call({1:2},1);t.f=i?function(e){var t=n(this,e);return!!t&&t.enumerable}:r},3440:(e,t,r)=>{var n=r(604),i=r(3736),o=r(4040);e.exports=Object.setPrototypeOf||("__proto__"in{}?function(){var e,t=!1,r={};try{(e=n(Object.getOwnPropertyDescriptor(Object.prototype,"__proto__").set))(r,[]),t=r instanceof Array}catch(e){}return function(r,n){return i(r),o(n),t?e(r,n):r.__proto__=n,r}}():void 0)},5556:(e,t,r)=>{var n=r(2828),i=r(604),o=r(9880),a=r(3068),s=i(r(5988).f),u=i([].push),l=function(e){return function(t){for(var r,i=a(t),l=o(i),c=l.length,p=0,d=[];c>p;)r=l[p++],n&&!s(i,r)||u(d,e?[r,i[r]]:i[r]);return d}};e.exports={entries:l(!0),values:l(!1)}},2816:(e,t,r)=>{"use strict";var n=r(7796),i=r(1248);e.exports=n?{}.toString:function(){return"[object "+i(this)+"]"}},7540:(e,t,r)=>{var n=r(1600),i=r(3032),o=r(984),a=r(9952),s=n.TypeError;e.exports=function(e,t){var r,n;if("string"===t&&o(r=e.toString)&&!a(n=i(r,e)))return n;if(o(r=e.valueOf)&&!a(n=i(r,e)))return n;if("string"!==t&&o(r=e.toString)&&!a(n=i(r,e)))return n;throw s("Can't convert object to primitive value")}},4092:(e,t,r)=>{var n=r(6532),i=r(604),o=r(4880),a=r(2128),s=r(3736),u=i([].concat);e.exports=n("Reflect","ownKeys")||function(e){var t=o.f(s(e)),r=a.f;return r?u(t,r(e)):t}},340:(e,t,r)=>{var n=r(1600);e.exports=n},2699:e=>{e.exports=function(e){try{return{error:!1,value:e()}}catch(e){return{error:!0,value:e}}}},9467:(e,t,r)=>{var n=r(3736),i=r(9952),o=r(8071);e.exports=function(e,t){if(n(e),i(t)&&t.constructor===e)return t;var r=o.f(e);return(0,r.resolve)(t),r.promise}},7431:(e,t,r)=>{var n=r(5028);e.exports=function(e,t,r){for(var i in t)n(e,i,t[i],r);return e}},5028:(e,t,r)=>{var n=r(1600),i=r(984),o=r(9180),a=r(4768),s=r(2984),u=r(1727),l=r(7932),c=r(8492).CONFIGURABLE,p=l.get,d=l.enforce,f=String(String).split("String");(e.exports=function(e,t,r,u){var l,p=!!u&&!!u.unsafe,y=!!u&&!!u.enumerable,h=!!u&&!!u.noTargetGet,m=u&&void 0!==u.name?u.name:t;i(r)&&("Symbol("===String(m).slice(0,7)&&(m="["+String(m).replace(/^Symbol\(([^)]*)\)/,"$1")+"]"),(!o(r,"name")||c&&r.name!==m)&&a(r,"name",m),(l=d(r)).source||(l.source=f.join("string"==typeof m?m:""))),e!==n?(p?!h&&e[t]&&(y=!0):delete e[t],y?e[t]=r:a(e,t,r)):y?e[t]=r:s(t,r)})(Function.prototype,"toString",(function(){return i(this)&&p(this).source||u(this)}))},1840:(e,t,r)=>{var n=r(1600).TypeError;e.exports=function(e){if(null==e)throw n("Can't call method on "+e);return e}},2984:(e,t,r)=>{var n=r(1600),i=Object.defineProperty;e.exports=function(e,t){try{i(n,e,{value:t,configurable:!0,writable:!0})}catch(r){n[e]=t}return t}},9688:(e,t,r)=>{"use strict";var n=r(6532),i=r(7072),o=r(3668),a=r(2828),s=o("species");e.exports=function(e){var t=n(e),r=i.f;a&&t&&!t[s]&&r(t,s,{configurable:!0,get:function(){return this}})}},9540:(e,t,r)=>{var n=r(7072).f,i=r(9180),o=r(3668)("toStringTag");e.exports=function(e,t,r){e&&!i(e=r?e:e.prototype,o)&&n(e,o,{configurable:!0,value:t})}},280:(e,t,r)=>{var n=r(4624),i=r(6536),o=n("keys");e.exports=function(e){return o[e]||(o[e]=i(e))}},6376:(e,t,r)=>{var n=r(1600),i=r(2984),o="__core-js_shared__",a=n[o]||i(o,{});e.exports=a},4624:(e,t,r)=>{var n=r(7408),i=r(6376);(e.exports=function(e,t){return i[e]||(i[e]=void 0!==t?t:{})})("versions",[]).push({version:"3.19.0",mode:n?"pure":"global",copyright:"© 2021 Denis Pushkarev (zloirock.ru)"})},7171:(e,t,r)=>{var n=r(3736),i=r(6372),o=r(3668)("species");e.exports=function(e,t){var r,a=n(e).constructor;return void 0===a||null==(r=n(a)[o])?t:i(r)}},5160:(e,t,r)=>{var n=r(604),i=r(9824),o=r(748),a=r(1840),s=n("".charAt),u=n("".charCodeAt),l=n("".slice),c=function(e){return function(t,r){var n,c,p=o(a(t)),d=i(r),f=p.length;return d<0||d>=f?e?"":void 0:(n=u(p,d))<55296||n>56319||d+1===f||(c=u(p,d+1))<56320||c>57343?e?s(p,d):n:e?l(p,d,d+2):c-56320+(n-55296<<10)+65536}};e.exports={codeAt:c(!1),charAt:c(!0)}},1688:(e,t,r)=>{var n=r(604),i=r(1840),o=r(748),a=r(5320),s=n("".replace),u="["+a+"]",l=RegExp("^"+u+u+"*"),c=RegExp(u+u+"*$"),p=function(e){return function(t){var r=o(i(t));return 1&e&&(r=s(r,l,"")),2&e&&(r=s(r,c,"")),r}};e.exports={start:p(1),end:p(2),trim:p(3)}},5952:(e,t,r)=>{var n,i,o,a,s=r(1600),u=r(9756),l=r(5616),c=r(984),p=r(9180),d=r(7004),f=r(2960),y=r(6100),h=r(7300),m=r(1588),g=r(3640),v=s.setImmediate,b=s.clearImmediate,I=s.process,S=s.Dispatch,_=s.Function,T=s.MessageChannel,P=s.String,A=0,E={},w="onreadystatechange";try{n=s.location}catch(e){}var O=function(e){if(p(E,e)){var t=E[e];delete E[e],t()}},D=function(e){return function(){O(e)}},x=function(e){O(e.data)},F=function(e){s.postMessage(P(e),n.protocol+"//"+n.host)};v&&b||(v=function(e){var t=y(arguments,1);return E[++A]=function(){u(c(e)?e:_(e),void 0,t)},i(A),A},b=function(e){delete E[e]},g?i=function(e){I.nextTick(D(e))}:S&&S.now?i=function(e){S.now(D(e))}:T&&!m?(a=(o=new T).port2,o.port1.onmessage=x,i=l(a.postMessage,a)):s.addEventListener&&c(s.postMessage)&&!s.importScripts&&n&&"file:"!==n.protocol&&!d(F)?(i=F,s.addEventListener("message",x,!1)):i=w in h("script")?function(e){f.appendChild(h("script"))[w]=function(){f.removeChild(this),O(e)}}:function(e){setTimeout(D(e),0)}),e.exports={set:v,clear:b}},7920:(e,t,r)=>{var n=r(9824),i=Math.max,o=Math.min;e.exports=function(e,t){var r=n(e);return r<0?i(r+t,0):o(r,t)}},3068:(e,t,r)=>{var n=r(3188),i=r(1840);e.exports=function(e){return n(i(e))}},9824:e=>{var t=Math.ceil,r=Math.floor;e.exports=function(e){var n=+e;return n!=n||0===n?0:(n>0?r:t)(n)}},1868:(e,t,r)=>{var n=r(9824),i=Math.min;e.exports=function(e){return e>0?i(n(e),9007199254740991):0}},3848:(e,t,r)=>{var n=r(1600),i=r(1840),o=n.Object;e.exports=function(e){return o(i(e))}},2312:(e,t,r)=>{var n=r(1600),i=r(3032),o=r(9952),a=r(1836),s=r(8808),u=r(7540),l=r(3668),c=n.TypeError,p=l("toPrimitive");e.exports=function(e,t){if(!o(e)||a(e))return e;var r,n=s(e,p);if(n){if(void 0===t&&(t="default"),r=i(n,e,t),!o(r)||a(r))return r;throw c("Can't convert object to primitive value")}return void 0===t&&(t="number"),u(e,t)}},4061:(e,t,r)=>{var n=r(2312),i=r(1836);e.exports=function(e){var t=n(e,"string");return i(t)?t:t+""}},7796:(e,t,r)=>{var n={};n[r(3668)("toStringTag")]="z",e.exports="[object z]"===String(n)},748:(e,t,r)=>{var n=r(1600),i=r(1248),o=n.String;e.exports=function(e){if("Symbol"===i(e))throw TypeError("Cannot convert a Symbol value to a string");return o(e)}},1532:(e,t,r)=>{var n=r(1600).String;e.exports=function(e){try{return n(e)}catch(e){return"Object"}}},6536:(e,t,r)=>{var n=r(604),i=0,o=Math.random(),a=n(1..toString);e.exports=function(e){return"Symbol("+(void 0===e?"":e)+")_"+a(++i+o,36)}},7216:(e,t,r)=>{var n=r(3880);e.exports=n&&!Symbol.sham&&"symbol"==typeof Symbol.iterator},3668:(e,t,r)=>{var n=r(1600),i=r(4624),o=r(9180),a=r(6536),s=r(3880),u=r(7216),l=i("wks"),c=n.Symbol,p=c&&c.for,d=u?c:c&&c.withoutSetter||a;e.exports=function(e){if(!o(l,e)||!s&&"string"!=typeof l[e]){var t="Symbol."+e;s&&o(c,e)?l[e]=c[e]:l[e]=u&&p?p(t):d(t)}return l[e]}},5320:e=>{e.exports="\t\n\v\f\r                　\u2028\u2029\ufeff"},6140:(e,t,r)=>{"use strict";var n=r(7248),i=r(1600),o=r(2408),a=r(6232),s=r(3440),u=r(4640),l=r(124),c=r(4768),p=r(364),d=r(5032),f=r(7660),y=r(9928),h=r(5744),m=r(4464),g=i.Error,v=[].push,b=function(e,t){var r=o(I,this)?this:l(I),n=arguments.length>2?arguments[2]:void 0;s&&(r=s(new g(void 0),a(r))),c(r,"message",h(t,"")),m&&c(r,"stack",d(r.stack,1)),f(r,n);var i=[];return y(e,v,{that:i}),c(r,"errors",i),r};s?s(b,g):u(b,g);var I=b.prototype=l(g.prototype,{constructor:p(1,b),message:p(1,""),name:p(1,"AggregateError")});n({global:!0},{AggregateError:b})},5092:(e,t,r)=>{"use strict";var n=r(7248),i=r(9560).find,o=r(5868),a="find",s=!0;a in[]&&Array(1)[a]((function(){s=!1})),n({target:"Array",proto:!0,forced:s},{find:function(e){return i(this,e,arguments.length>1?arguments[1]:void 0)}}),o(a)},5684:(e,t,r)=>{var n=r(7248),i=r(8208);n({target:"Array",stat:!0,forced:!r(6344)((function(e){Array.from(e)}))},{from:i})},3924:(e,t,r)=>{"use strict";var n=r(3068),i=r(5868),o=r(2204),a=r(7932),s=r(2648),u="Array Iterator",l=a.set,c=a.getterFor(u);e.exports=s(Array,"Array",(function(e,t){l(this,{type:u,target:n(e),index:0,kind:t})}),(function(){var e=c(this),t=e.target,r=e.kind,n=e.index++;return!t||n>=t.length?(e.target=void 0,{value:void 0,done:!0}):"keys"==r?{value:n,done:!1}:"values"==r?{value:t[n],done:!1}:{value:[n,t[n]],done:!1}}),"values"),o.Arguments=o.Array,i("keys"),i("values"),i("entries")},472:(e,t,r)=>{"use strict";r(6064)("Map",(function(e){return function(){return e(this,arguments.length?arguments[0]:void 0)}}),r(9920))},1300:(e,t,r)=>{r(7248)({target:"Number",stat:!0},{isInteger:r(992)})},3656:(e,t,r)=>{r(7248)({target:"Number",stat:!0},{isNaN:function(e){return e!=e}})},6544:(e,t,r)=>{var n=r(7248),i=r(6016);n({target:"Number",stat:!0,forced:Number.parseFloat!=i},{parseFloat:i})},7972:(e,t,r)=>{var n=r(7248),i=r(6556);n({target:"Number",stat:!0,forced:Number.parseInt!=i},{parseInt:i})},6368:(e,t,r)=>{var n=r(7248),i=r(6984);n({target:"Object",stat:!0,forced:Object.assign!==i},{assign:i})},8292:(e,t,r)=>{var n=r(7248),i=r(5556).entries;n({target:"Object",stat:!0},{entries:function(e){return i(e)}})},920:(e,t,r)=>{r(7248)({target:"Object",stat:!0},{setPrototypeOf:r(3440)})},7912:(e,t,r)=>{var n=r(7796),i=r(5028),o=r(2816);n||i(Object.prototype,"toString",o,{unsafe:!0})},3936:(e,t,r)=>{"use strict";var n=r(7248),i=r(3032),o=r(1381),a=r(8071),s=r(2699),u=r(9928);n({target:"Promise",stat:!0},{allSettled:function(e){var t=this,r=a.f(t),n=r.resolve,l=r.reject,c=s((function(){var r=o(t.resolve),a=[],s=0,l=1;u(e,(function(e){var o=s++,u=!1;l++,i(r,t,e).then((function(e){u||(u=!0,a[o]={status:"fulfilled",value:e},--l||n(a))}),(function(e){u||(u=!0,a[o]={status:"rejected",reason:e},--l||n(a))}))})),--l||n(a)}));return c.error&&l(c.value),r.promise}})},5428:(e,t,r)=>{"use strict";var n=r(7248),i=r(1381),o=r(6532),a=r(3032),s=r(8071),u=r(2699),l=r(9928),c="No one promise resolved";n({target:"Promise",stat:!0},{any:function(e){var t=this,r=o("AggregateError"),n=s.f(t),p=n.resolve,d=n.reject,f=u((function(){var n=i(t.resolve),o=[],s=0,u=1,f=!1;l(e,(function(e){var i=s++,l=!1;u++,a(n,t,e).then((function(e){l||f||(f=!0,p(e))}),(function(e){l||f||(l=!0,o[i]=e,--u||d(new r(o,c)))}))})),--u||d(new r(o,c))}));return f.error&&d(f.value),n.promise}})},1517:(e,t,r)=>{"use strict";var n=r(7248),i=r(7408),o=r(3459),a=r(7004),s=r(6532),u=r(984),l=r(7171),c=r(9467),p=r(5028);if(n({target:"Promise",proto:!0,real:!0,forced:!!o&&a((function(){o.prototype.finally.call({then:function(){}},(function(){}))}))},{finally:function(e){var t=l(this,s("Promise")),r=u(e);return this.then(r?function(r){return c(t,e()).then((function(){return r}))}:e,r?function(r){return c(t,e()).then((function(){throw r}))}:e)}}),!i&&u(o)){var d=s("Promise").prototype.finally;o.prototype.finally!==d&&p(o.prototype,"finally",d,{unsafe:!0})}},7448:(e,t,r)=>{"use strict";var n,i,o,a,s=r(7248),u=r(7408),l=r(1600),c=r(6532),p=r(3032),d=r(3459),f=r(5028),y=r(7431),h=r(3440),m=r(9540),g=r(9688),v=r(1381),b=r(984),I=r(9952),S=r(2932),_=r(1727),T=r(9928),P=r(6344),A=r(7171),E=r(5952).set,w=r(3104),O=r(9467),D=r(5651),x=r(8071),F=r(2699),C=r(7932),N=r(4232),M=r(3668),k=r(4532),R=r(3640),V=r(2592),j=M("species"),z="Promise",L=C.get,U=C.set,B=C.getterFor(z),H=d&&d.prototype,W=d,G=H,Y=l.TypeError,q=l.document,K=l.process,Q=x.f,Z=Q,X=!!(q&&q.createEvent&&l.dispatchEvent),J=b(l.PromiseRejectionEvent),$="unhandledrejection",ee=!1,te=N(z,(function(){var e=_(W),t=e!==String(W);if(!t&&66===V)return!0;if(u&&!G.finally)return!0;if(V>=51&&/native code/.test(e))return!1;var r=new W((function(e){e(1)})),n=function(e){e((function(){}),(function(){}))};return(r.constructor={})[j]=n,!(ee=r.then((function(){}))instanceof n)||!t&&k&&!J})),re=te||!P((function(e){W.all(e).catch((function(){}))})),ne=function(e){var t;return!(!I(e)||!b(t=e.then))&&t},ie=function(e,t){if(!e.notified){e.notified=!0;var r=e.reactions;w((function(){for(var n=e.value,i=1==e.state,o=0;r.length>o;){var a,s,u,l=r[o++],c=i?l.ok:l.fail,d=l.resolve,f=l.reject,y=l.domain;try{c?(i||(2===e.rejection&&ue(e),e.rejection=1),!0===c?a=n:(y&&y.enter(),a=c(n),y&&(y.exit(),u=!0)),a===l.promise?f(Y("Promise-chain cycle")):(s=ne(a))?p(s,a,d,f):d(a)):f(n)}catch(e){y&&!u&&y.exit(),f(e)}}e.reactions=[],e.notified=!1,t&&!e.rejection&&ae(e)}))}},oe=function(e,t,r){var n,i;X?((n=q.createEvent("Event")).promise=t,n.reason=r,n.initEvent(e,!1,!0),l.dispatchEvent(n)):n={promise:t,reason:r},!J&&(i=l["on"+e])?i(n):e===$&&D("Unhandled promise rejection",r)},ae=function(e){p(E,l,(function(){var t,r=e.facade,n=e.value;if(se(e)&&(t=F((function(){R?K.emit("unhandledRejection",n,r):oe($,r,n)})),e.rejection=R||se(e)?2:1,t.error))throw t.value}))},se=function(e){return 1!==e.rejection&&!e.parent},ue=function(e){p(E,l,(function(){var t=e.facade;R?K.emit("rejectionHandled",t):oe("rejectionhandled",t,e.value)}))},le=function(e,t,r){return function(n){e(t,n,r)}},ce=function(e,t,r){e.done||(e.done=!0,r&&(e=r),e.value=t,e.state=2,ie(e,!0))},pe=function(e,t,r){if(!e.done){e.done=!0,r&&(e=r);try{if(e.facade===t)throw Y("Promise can't be resolved itself");var n=ne(t);n?w((function(){var r={done:!1};try{p(n,t,le(pe,r,e),le(ce,r,e))}catch(t){ce(r,t,e)}})):(e.value=t,e.state=1,ie(e,!1))}catch(t){ce({done:!1},t,e)}}};if(te&&(G=(W=function(e){S(this,G),v(e),p(n,this);var t=L(this);try{e(le(pe,t),le(ce,t))}catch(e){ce(t,e)}}).prototype,(n=function(e){U(this,{type:z,done:!1,notified:!1,parent:!1,reactions:[],rejection:!1,state:0,value:void 0})}).prototype=y(G,{then:function(e,t){var r=B(this),n=r.reactions,i=Q(A(this,W));return i.ok=!b(e)||e,i.fail=b(t)&&t,i.domain=R?K.domain:void 0,r.parent=!0,n[n.length]=i,0!=r.state&&ie(r,!1),i.promise},catch:function(e){return this.then(void 0,e)}}),i=function(){var e=new n,t=L(e);this.promise=e,this.resolve=le(pe,t),this.reject=le(ce,t)},x.f=Q=function(e){return e===W||e===o?new i(e):Z(e)},!u&&b(d)&&H!==Object.prototype)){a=H.then,ee||(f(H,"then",(function(e,t){var r=this;return new W((function(e,t){p(a,r,e,t)})).then(e,t)}),{unsafe:!0}),f(H,"catch",G.catch,{unsafe:!0}));try{delete H.constructor}catch(e){}h&&h(H,G)}s({global:!0,wrap:!0,forced:te},{Promise:W}),m(W,z,!1,!0),g(z),o=c(z),s({target:z,stat:!0,forced:te},{reject:function(e){var t=Q(this);return p(t.reject,void 0,e),t.promise}}),s({target:z,stat:!0,forced:u||te},{resolve:function(e){return O(u&&this===o?W:this,e)}}),s({target:z,stat:!0,forced:re},{all:function(e){var t=this,r=Q(t),n=r.resolve,i=r.reject,o=F((function(){var r=v(t.resolve),o=[],a=0,s=1;T(e,(function(e){var u=a++,l=!1;s++,p(r,t,e).then((function(e){l||(l=!0,o[u]=e,--s||n(o))}),i)})),--s||n(o)}));return o.error&&i(o.value),r.promise},race:function(e){var t=this,r=Q(t),n=r.reject,i=F((function(){var i=v(t.resolve);T(e,(function(e){p(i,t,e).then(r.resolve,n)}))}));return i.error&&n(i.value),r.promise}})},8504:(e,t,r)=>{"use strict";var n=r(5160).charAt,i=r(748),o=r(7932),a=r(2648),s="String Iterator",u=o.set,l=o.getterFor(s);a(String,"String",(function(e){u(this,{type:s,string:i(e),index:0})}),(function(){var e,t=l(this),r=t.string,i=t.index;return i>=r.length?{value:void 0,done:!0}:(e=n(r,i),t.index+=e.length,{value:e,done:!1})}))},1808:e=>{!function(){var t=new RegExp("^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$","i");function r(e){for(var t="",r=0;r{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._type=e}return Object.defineProperty(e.prototype,"type",{get:function(){return this._type},enumerable:!0,configurable:!0}),e}();t.TableauEvent=r},3248:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=function(e){function t(t,r){var n=e.call(this,t)||this;return n._sheet=r,n}return i(t,e),Object.defineProperty(t.prototype,"sheet",{get:function(){return this._sheet},enumerable:!0,configurable:!0}),t}(r(7112).TableauEvent);t.TableauSheetEvent=o},4144:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=function(e){function t(t,r){var n=e.call(this,t,r)||this;return n._worksheet=r,n}return i(t,e),Object.defineProperty(t.prototype,"worksheet",{get:function(){return this._worksheet},enumerable:!0,configurable:!0}),t}(r(3248).TableauSheetEvent);t.TableauWorksheetEvent=o},4164:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=function(e){function t(t){var r=e.call(this,o.TableauEventType.WorkbookFormattingChanged)||this;return r._formatting=t,r}return i(t,e),Object.defineProperty(t.prototype,"formatting",{get:function(){return this._formatting},enumerable:!0,configurable:!0}),t}(r(7112).TableauEvent);t.WorkbookFormattingChangedEvent=a},92:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.BentonSansFontFamilyName="Benton Sans",t.BentonSansLowDPIFontFamilyName="Benton Sans Low-DPI",t.BentonSansBookFontFaceName="Benton Sans Book",t.BentonSansBookItalicFontFaceName="Benton Sans Book Italic",t.BentonSansSemiDemiFontFaceName="Benton Sans SemiDemi",t.BentonSansSemiDemiItalicFontFaceName="Benton Sans SemiDemi Italic",t.BentonSansLightFontFaceName="Benton Sans Light",t.BentonSansMediumFontFaceName="Benton Sans Medium",t.SupportedBentonSansFontFaces=[t.BentonSansBookFontFaceName,t.BentonSansBookItalicFontFaceName,t.BentonSansSemiDemiFontFaceName,t.BentonSansSemiDemiItalicFontFaceName,t.BentonSansLightFontFaceName,t.BentonSansMediumFontFaceName]},8396:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e,t,r,n){this._userId=e,this._siteId=t,this._siteNamespace=r,this._workbookId=n}return Object.defineProperty(e.prototype,"userId",{get:function(){return this._userId},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"siteId",{get:function(){return this._siteId},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"siteNamespace",{get:function(){return this._siteNamespace},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"workbookId",{get:function(){return this._workbookId},enumerable:!0,configurable:!0}),e}();t.ConnectedServer=r},5920:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(5136),a=r(1468),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),t.prototype.getAllDataSourcesAsync=function(){var e=this;return o.ApiServiceRegistry.get(a.ExtensionsRegistryId).getService("data-source-service").getAllDataSourcesAsync().then((function(t){var r=t,n=[];return Object.values(r.dataSources).forEach((function(t){n.push(e.createDataSourceFromInfo(t))})),n}))},t.prototype.createDataSourceFromInfo=function(e){var t=new o.DataSourceImpl(e,a.ExtensionsRegistryId),r=new o.DataSource(t);return t.initializeWithPublicInterfaces(r),r},t}(o.WorkbookImpl);t.ExtensionWorkbookImpl=s},976:function(e,t,r){"use strict";var n=this&&this.__spreadArrays||function(){for(var e=0,t=0,r=arguments.length;t0;)r.deleteRule(r.cssRules.length-1);e.formattingSheets.map((function(e){t.applyFormattingSheetToStyleSheet(e,r)}))}},e.prototype.applyFormattingSheetToStyleSheet=function(e,t){var r="",n=e.cssProperties;n.fontFamily&&(r+="font-family: "+n.fontFamily.toString()+"; "),n.fontSize&&(r+="font-size: "+n.fontSize.toString()+"; "),n.fontWeight&&(r+="font-weight: "+n.fontWeight.toString()+"; "),n.fontStyle&&(r+="font-style: "+n.fontStyle.toString()+"; "),n.textDecoration&&(r+="text-decoration: "+n.textDecoration.toString()+"; "),n.color&&(r+="color: "+n.color+"; ");var i="."+e.classNameKey+" { "+r+" }";t.insertRule(i,t.cssRules.length)},e.prototype.initializeWorkbookFormattingChangedEventCallback=function(e){var t=this;a.ApiServiceRegistry.get(m.ExtensionsRegistryId).getService("notification-service").registerHandler(o.NotificationId.WorkbookFormattingChanged,(function(){return!0}),(function(r){r&&(t.initializeTableauFonts(e,r),t.applyAllFormatting(r))}))},e.prototype.initializeTableauFonts=function(e,t){var r,i=this,a=n(g.SupportedBentonSansFontFaces,S.SupportedTableauFontFaces);if(t.formattingSheets.forEach((function(e){e.cssProperties.fontFamily&&a.push(e.cssProperties.fontFamily)})),a.length>0){var s=((r={})[o.ParameterId.FontNameListItems]=a,r);e.execute(o.VerbId.GetFonts,s).then((function(e){i.loadFonts(e.result)})).catch()}},e.prototype.loadFonts=function(e){var t=this;e.forEach((function(e){S.SupportedTableauFontFaces.includes(e.fontName)?t.loadTableauFonts(e):g.SupportedBentonSansFontFaces.includes(e.fontName)?t.loadBentonSansFonts(e):document.fonts.add(new FontFace(e.fontName,e.fontBinaryInfo))}))},e.prototype.initializeDashboardContent=function(e,t){var r=new a.SheetInfoImpl(e.name,i.SheetType.Dashboard,{width:e.size.w,height:e.size.h},void 0,!0),n=new a.DashboardImpl(r,e.zones,t,m.ExtensionsRegistryId,null,e.activeDashboardObjectId),o=new s.Dashboard(n);return new c.DashboardContent(o)},e.prototype.initializeWorksheetContent=function(e){var t=new a.SheetInfoImpl(e.visualId.worksheet,i.SheetType.Worksheet,{width:e.size.w,height:e.size.h},void 0,!0),r=new a.WorksheetImpl(t,m.ExtensionsRegistryId,e.visualId,null,null),n=new l.Worksheet(r);return new y.WorksheetContent(n)},e.prototype.initializeSettings=function(e){var t=new I.SettingsImpl(e);return new d.Settings(t)},e.prototype.initializeContextMenuCallbacks=function(e){a.ApiServiceRegistry.get(m.ExtensionsRegistryId).getService("notification-service").registerHandler(o.NotificationId.ContextMenuClick,(function(){return!0}),(function(t){if(e){if(!e[t.id])throw new a.TableauError(i.ErrorCodes.InternalError,"Received unexpected context menu Id from event: "+t.id);e[t.id]()}}))},e.prototype.loadTableauFonts=function(e){switch(e.fontName){case S.TableauBookFontFaceName:document.fonts.add(new FontFace(S.TableauBookFontFamilyName,e.fontBinaryInfo,{weight:"normal",style:"normal"}));break;case S.TableauLightFontFaceName:document.fonts.add(new FontFace(S.TableauLightFontFamilyName,e.fontBinaryInfo,{weight:"normal",style:"normal"}));break;case S.TableauRegularFontFaceName:document.fonts.add(new FontFace(S.TableauRegularFontFamilyName,e.fontBinaryInfo,{weight:"normal",style:"normal"}));break;case S.TableauSemiBoldFontFaceName:document.fonts.add(new FontFace(S.TableauSemiboldFontFamilyName,e.fontBinaryInfo,{weight:"normal",style:"normal"})),document.fonts.add(new FontFace(S.TableauRegularFontFamilyName,e.fontBinaryInfo,{weight:"bold",style:"normal"}));break;case S.TableauBoldFontFaceName:document.fonts.add(new FontFace(S.TableauBoldFontFamilyName,e.fontBinaryInfo,{weight:"normal",style:"normal"})),document.fonts.add(new FontFace(S.TableauBoldFontFamilyName,e.fontBinaryInfo,{weight:"bold",style:"normal"})),document.fonts.add(new FontFace(S.TableauMediumFontFamilyName,e.fontBinaryInfo,{weight:"bold",style:"normal"})),document.fonts.add(new FontFace(S.TableauSemiboldFontFamilyName,e.fontBinaryInfo,{weight:"bold",style:"normal"}));break;case S.TableauMediumFontFaceName:document.fonts.add(new FontFace(S.TableauMediumFontFamilyName,e.fontBinaryInfo,{weight:"normal",style:"normal"})),document.fonts.add(new FontFace(S.TableauLightFontFamilyName,e.fontBinaryInfo,{weight:"bold",style:"normal"})),document.fonts.add(new FontFace(S.TableauBookFontFamilyName,e.fontBinaryInfo,{weight:"bold",style:"normal"}));break;default:throw new a.TableauError(i.ErrorCodes.InternalError,"'attempted to load unsupported font: "+e.fontName+".'")}},e.prototype.loadBentonSansFonts=function(e){switch(e.fontName){case g.BentonSansBookFontFaceName:document.fonts.add(new FontFace(g.BentonSansFontFamilyName,e.fontBinaryInfo,{weight:"normal",style:"normal"})),document.fonts.add(new FontFace(g.BentonSansLowDPIFontFamilyName,e.fontBinaryInfo,{weight:"100",style:"normal"}));break;case g.BentonSansLightFontFaceName:document.fonts.add(new FontFace(g.BentonSansFontFamilyName,e.fontBinaryInfo,{weight:"100",style:"normal"}));break;case g.BentonSansMediumFontFaceName:document.fonts.add(new FontFace(g.BentonSansFontFamilyName,e.fontBinaryInfo,{weight:"bold",style:"normal"})),document.fonts.add(new FontFace(g.BentonSansLowDPIFontFamilyName,e.fontBinaryInfo,{weight:"bold",style:"normal"}));break;case g.BentonSansSemiDemiFontFaceName:document.fonts.add(new FontFace(g.BentonSansLowDPIFontFamilyName,e.fontBinaryInfo,{weight:"normal",style:"normal"}));break;case g.BentonSansBookItalicFontFaceName:document.fonts.add(new FontFace(g.BentonSansFontFamilyName,e.fontBinaryInfo,{style:"italic"}));break;case g.BentonSansSemiDemiItalicFontFaceName:document.fonts.add(new FontFace(g.BentonSansLowDPIFontFamilyName,e.fontBinaryInfo,{style:"italic"}));break;default:throw new a.TableauError(i.ErrorCodes.InternalError,"'attempted to load unsupported font: "+e.fontName+".'")}},e}();t.ExtensionsImpl=T},7269:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(3448);!function(e){function t(e){var t;return e&&void 0!==e.isAlpha||window.__warningIssued?(null===(t=e)||void 0===t?void 0:t.isAlpha)&&window.__platformIsOfficialRelease&&window.__tableauDesktopDispatcher.then((function(e){e(n.INTERNAL_CONTRACT_VERSION).execute(n.VerbId.BlockExtension,{}).catch()})).catch():(console.warn("This is a beta version of the Extensions API. Please upgrade to an official release."),window.__warningIssued=!0),window.__tableauDesktopDispatcher}e.getDesktopDispatcherPromise=t,e.hasDesktopApiDispatcherPromise=function(e){return!!t(e)}}(t.LegacyInternalApiDispatcherHolder||(t.LegacyInternalApiDispatcherHolder={}))},5436:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(5136),u=r(7112),l=r(1468),c=function(e){function t(t){var r=e.call(this,o.TableauEventType.SettingsChanged)||this;return r._newSettings=t,r}return i(t,e),Object.defineProperty(t.prototype,"newSettings",{get:function(){return this._newSettings},enumerable:!0,configurable:!0}),t}(u.TableauEvent),p=function(){function e(e){this._saveInProgress=!1,this.initializeSettings(e)}return e.prototype.erase=function(e){s.ErrorHelpers.verifyParameter(e,"key"),this._currentSettings[e]&&(this.verifySettingsAreUnlocked(),delete this._currentSettings[e],this._isModified=!0)},e.prototype.get=function(e){return s.ErrorHelpers.verifyParameter(e,"key"),this._currentSettings[e]},e.prototype.getAll=function(){return Object.assign({},this._currentSettings)},Object.defineProperty(e.prototype,"isModified",{get:function(){return this._isModified},enumerable:!0,configurable:!0}),e.prototype.saveAsync=function(){var e=this;return this.verifySettingsAreUnlocked(),this._isModified?(this._saveInProgress=!0,s.ApiServiceRegistry.get(l.ExtensionsRegistryId).getService("SettingsService").saveSettingsAsync(this._currentSettings).then((function(t){return e._saveInProgress=!1,e._isModified=!1,void 0===e._currentSettings?e._currentSettings=t:Object.assign(e._currentSettings,t),t}),(function(t){return e._saveInProgress=!1,Promise.reject(t)}))):Promise.resolve(this._currentSettings)},e.prototype.set=function(e,t){s.ErrorHelpers.verifyStringParameter(e,"key"),s.ErrorHelpers.verifyParameter(t,"value"),this.verifySettingsAreUnlocked(),this._currentSettings[e]=t,this._isModified=!0},e.prototype.initializeEvents=function(){var e,t=this,r=new Array;try{e=s.ApiServiceRegistry.get(l.ExtensionsRegistryId).getService("notification-service")}catch(e){return r}var n=new s.SingleEventManagerImpl(o.TableauEventType.SettingsChanged);return e.registerHandler(a.NotificationId.SettingsChanged,(function(){return!0}),(function(e){t._currentSettings=e.newSettings,n.triggerEvent((function(){return new c(e.newSettings)}))})),r.push(n),r},e.prototype.initializeSettings=function(e){s.ErrorHelpers.verifyParameter(e,"settingsInfo"),s.ErrorHelpers.verifyParameter(e.settingsValues,"settingsInfo.SettingsValues"),this._currentSettings=e.settingsValues,this._isModified=!1},e.prototype.verifySettingsAreUnlocked=function(){if(this._saveInProgress)throw new s.TableauError(o.ErrorCodes.SettingSaveInProgress,e.ASYNC_SAVE_IN_PROGRESS)},e.ASYNC_SAVE_IN_PROGRESS="Async Save is in progress, updating settings is not allowed.",e}();t.SettingsImpl=p},2200:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.TableauBookFontFamilyName="Tableau Book",t.TableauLightFontFamilyName="Tableau Light",t.TableauRegularFontFamilyName="Tableau Regular",t.TableauMediumFontFamilyName="Tableau Medium",t.TableauSemiboldFontFamilyName="Tableau Semibold",t.TableauBoldFontFamilyName="Tableau Bold",t.TableauBookFontFaceName="Tableau Book",t.TableauBoldFontFaceName="Tableau Bold",t.TableauLightFontFaceName="Tableau Light",t.TableauMediumFontFaceName="Tableau Medium",t.TableauRegularFontFaceName="Tableau Regular",t.TableauSemiBoldFontFaceName="Tableau Semi Bold",t.SupportedTableauFontFaces=[t.TableauBookFontFaceName,t.TableauBoldFontFaceName,t.TableauLightFontFaceName,t.TableauMediumFontFaceName,t.TableauRegularFontFaceName,t.TableauSemiBoldFontFaceName]},1024:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(7419),o=r(3448),a=r(5136),s=r(1468),u=function(){function e(){}return e.prototype.displayDialogAsync=function(e,t,r){var u=a.ApiServiceRegistry.get(s.ExtensionsRegistryId).getService("UIService"),l=a.ApiServiceRegistry.get(s.ExtensionsRegistryId).getService("notification-service");return new Promise((function(s,c){u.displayDialogAsync(e,t||"",r).then((function(){var e=l.registerHandler(o.NotificationId.ExtensionDialogUpdate,(function(){return!0}),(function(t){if(t.isCloseEvent){if(void 0===t.closePayload)throw new a.TableauError(n.ErrorCodes.InternalError,"closePayload is undefined");s(t.closePayload)}else c(new a.TableauError(i.ErrorCodes.DialogClosedByUser,"Extension dialog closed by user."));e()}))})).catch((function(e){c(e)}))}))},e.prototype.closeDialog=function(e){a.ApiServiceRegistry.get(s.ExtensionsRegistryId).getService("UIService").closeDialog(e)},e}();t.UIImpl=u},4252:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(5136),u=r(6416),l=r(4164),c=r(1468),p=r(3192),d=r(6132),f=r(5548),y=function(e){function t(t){var r=e.call(this,t)||this;return r._dashboardImpl=t,t.initializeWithPublicInterfaces(),r.initializeEvents().forEach((function(e){return r.addNewEventType(e)})),r}return i(t,e),Object.defineProperty(t.prototype,"worksheets",{get:function(){return this._dashboardImpl.worksheetsImpl.map((function(e){return new f.Worksheet(e)}))},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"objects",{get:function(){return this._dashboardImpl.objects.map((function(e){return new p.DashboardObject(e)}))},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"activeDashboardObjectId",{get:function(){return this._dashboardImpl.activeDashboardObjectId},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"activeDashboardName",{get:function(){return this._dashboardImpl.activeDashboardName},enumerable:!0,configurable:!0}),t.prototype.setZoneVisibilityAsync=function(e){return this._dashboardImpl.setDashboardObjectVisibilityAsync(e)},t.prototype.setDashboardObjectVisibilityAsync=function(e){return this._dashboardImpl.setDashboardObjectVisibilityAsync(e)},t.prototype.getDashboardObjectById=function(e){var t=this._dashboardImpl.getDashboardObjectById(e);return t&&new p.DashboardObject(t)},t.prototype.initializeEvents=function(){var e,t=this,r=new Array;try{e=s.ApiServiceRegistry.get(c.ExtensionsRegistryId).getService("notification-service")}catch(e){return r}var n=new s.SingleEventManagerImpl(o.TableauEventType.DashboardLayoutChanged);e.registerHandler(a.NotificationId.DashboardLayoutChanged,(function(){return!0}),(function(e){var r=t._dashboardImpl.updateZones(e.zones,e.activeZoneId,e.activeDashboardName);n.triggerEvent((function(){return new u.DashboardLayoutChangedEvent(r)}))})),r.push(n);var i=new s.SingleEventManagerImpl(o.TableauEventType.WorkbookFormattingChanged);return e.registerHandler(a.NotificationId.WorkbookFormattingChanged,(function(){return!0}),(function(e){i.triggerEvent((function(){return new l.WorkbookFormattingChangedEvent(e)}))})),r.push(i),r},t.prototype.moveAndResizeDashboardObjectsAsync=function(e){return this._dashboardImpl.moveAndResizeDashboardObjectsAsync(e)},t.prototype.replayAnimationAsync=function(e){return this._dashboardImpl.replayAnimationAsync(e)},t.prototype.getFiltersAsync=function(){return this._dashboardImpl.getFiltersAsync()},t.prototype.applyFilterAsync=function(e,t,r,n){return this._dashboardImpl.applyFilterAsync(e,t,r,n)},t}(d.Sheet);t.Dashboard=y},3192:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(4252),i=r(5548),o=function(){function e(e){this._dashboardObjectImpl=e}return Object.defineProperty(e.prototype,"dashboard",{get:function(){return new n.Dashboard(this._dashboardObjectImpl.dashboardImpl)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"type",{get:function(){return this._dashboardObjectImpl.type},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return this._dashboardObjectImpl.position},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"size",{get:function(){return this._dashboardObjectImpl.size},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worksheet",{get:function(){if(this._dashboardObjectImpl.worksheetImpl)return new i.Worksheet(this._dashboardObjectImpl.worksheetImpl)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"name",{get:function(){return this._dashboardObjectImpl.name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isFloating",{get:function(){return this._dashboardObjectImpl.isFloating},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isVisible",{get:function(){return this._dashboardObjectImpl.isVisible},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"id",{get:function(){return this._dashboardObjectImpl.id},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"fieldId",{get:function(){return this._dashboardObjectImpl.fieldId},enumerable:!0,configurable:!0}),e}();t.DashboardObject=o},4592:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(5136),u=r(864),l=r(1468),c=function(e){function t(t,r){var n=e.call(this)||this;return n.parameterImpl=t,n.initializeEvents(r).forEach((function(e){return n.addNewEventType(e)})),n}return i(t,e),Object.defineProperty(t.prototype,"name",{get:function(){return this.parameterImpl.name},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"currentValue",{get:function(){return this.parameterImpl.currentValue},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"dataType",{get:function(){return this.parameterImpl.dataType},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"allowableValues",{get:function(){return this.parameterImpl.allowableValues},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"id",{get:function(){return this.parameterImpl.id},enumerable:!0,configurable:!0}),t.prototype.changeValueAsync=function(e){return this.parameterImpl.changeValueAsync(e)},t.prototype.initializeEvents=function(e){var t=this;s.ErrorHelpers.verifyInternalValue(e,"sheet");var r,n=new Array;try{r=s.ApiServiceRegistry.get(l.ExtensionsRegistryId).getService("notification-service")}catch(e){return n}var i=new s.SingleEventManagerImpl(o.TableauEventType.ParameterChanged);return r.registerHandler(a.NotificationId.ParameterChanged,(function(e){return e===t.parameterImpl.id}),(function(t){i.triggerEvent((function(){return new u.ParameterChangedEvent(t,e)}))})),n.push(i),n},t}(s.EventListenerManager);t.Parameter=c},6132:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(5136),s=r(4592),u=function(e){function t(t){var r=e.call(this)||this;return r._sheetImpl=t,r}return i(t,e),Object.defineProperty(t.prototype,"name",{get:function(){return this._sheetImpl.name},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"sheetType",{get:function(){return this._sheetImpl.sheetType},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"size",{get:function(){if(this.isValidSize(this._sheetImpl.size))return this._sheetImpl.size;throw new a.TableauError(o.EmbeddingErrorCodes.ImplementationError,"Size not implemented")},enumerable:!0,configurable:!0}),t.prototype.isValidSize=function(e){var t=e;return void 0!==t.width&&void 0!==t.height},t.prototype.findParameterAsync=function(e){var t=this;return this._sheetImpl.findParameterAsync(e).then((function(e){return new Promise(e?function(r){return r(new s.Parameter(e,t))}:function(e){return e(void 0)})}))},t.prototype.getParametersAsync=function(){var e=this;return this._sheetImpl.getParametersAsync().then((function(t){return t.map((function(t){return new s.Parameter(t,e)}))}))},t}(a.EventListenerManager);t.Sheet=u},9224:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._workbookImpl=e}return e.prototype.getAllDataSourcesAsync=function(){return this._workbookImpl.getAllDataSourcesAsync()},e}();t.Workbook=r},5548:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(7419),s=r(3448),u=r(5136),l=r(1672),c=r(5572),p=r(3464),d=r(1468),f=r(4252),y=function(e){function t(t){var r=e.call(this,t)||this;return r._worksheetImpl=t,r.initializeEvents().forEach((function(e){return r.addNewEventType(e)})),r}return i(t,e),Object.defineProperty(t.prototype,"parentDashboard",{get:function(){if(null==this._worksheetImpl.parentDashboard)throw new u.TableauError(o.SharedErrorCodes.ImplementationError,"Parent dashboard not implemented");return new f.Dashboard(this._worksheetImpl.parentDashboard)},enumerable:!0,configurable:!0}),t.prototype.initializeEvents=function(){var e,t=this,r=new Array;try{e=u.ApiServiceRegistry.get(d.ExtensionsRegistryId).getService("notification-service")}catch(e){return r}var n=new u.SingleEventManagerImpl(a.TableauEventType.MarkSelectionChanged);e.registerHandler(s.NotificationId.SelectedMarksChanged,(function(e){var r=e;return t.visualIdsAreEqual(r,t._worksheetImpl.visualId)}),(function(){return n.triggerEvent((function(){return new c.MarksSelectedEvent(t)}))}));var i=new u.SingleEventManagerImpl(a.TableauEventType.FilterChanged);e.registerHandler(s.NotificationId.FilterChanged,(function(e){var r=e;return t._worksheetImpl.visualId.worksheet===r.visualId.worksheet}),(function(e){i.triggerEvent((function(){return new l.FilterChangedEvent(t,e.fieldName,e.fieldId)}))}));var o=new u.SingleEventManagerImpl(a.TableauEventType.SummaryDataChanged);return e.registerHandler(s.NotificationId.SummaryDataChanged,(function(e){var r=e;return t._worksheetImpl.visualId.worksheet===r.visualId.worksheet}),(function(e){o.triggerEvent((function(){return new p.SummaryDataChangedEvent(t)}))})),r.push(n),r.push(i),r.push(o),r},t.prototype.applyFilterAsync=function(e,t,r,n){return this._worksheetImpl.applyFilterAsync(e,t,r,n)},t.prototype.applyRangeFilterAsync=function(e,t){return this._worksheetImpl.applyRangeFilterAsync(e,t)},t.prototype.applyHierarchicalFilterAsync=function(e,t,r,n){return this._worksheetImpl.applyHierarchicalFilterAsync(e,t,r,n)},t.prototype.applyRelativeDateFilterAsync=function(e,t){return this._worksheetImpl.applyRelativeDateFilterAsync(e,t)},t.prototype.clearFilterAsync=function(e){return this._worksheetImpl.clearFilterAsync(e)},t.prototype.getDataSourcesAsync=function(){return this._worksheetImpl.getDataSourcesAsync()},t.prototype.getFiltersAsync=function(){return this._worksheetImpl.getFiltersAsync()},t.prototype.getSelectedMarksAsync=function(){return this._worksheetImpl.getSelectedMarksAsync()},t.prototype.getHighlightedMarksAsync=function(){return this._worksheetImpl.getHighlightedMarksAsync()},t.prototype.getSummaryDataAsync=function(e){return this._worksheetImpl.getSummaryDataAsync(e)},t.prototype.getSummaryDataReaderAsync=function(e,t){return this._worksheetImpl.getSummaryDataReaderAsync(e,t)},t.prototype.getSummaryColumnsInfoAsync=function(){return this._worksheetImpl.getSummaryColumnsInfoAsync()},t.prototype.getUnderlyingDataAsync=function(e){return console.warn("Worksheet.getUnderlyingDataAsync is deprecated. Please use Worksheet.getUnderlyingTablesAsync and Worksheet.getUnderlyingTableDataAsync"),this._worksheetImpl.getUnderlyingDataAsync(e)},t.prototype.getUnderlyingTablesAsync=function(){return this._worksheetImpl.getUnderlyingTablesAsync()},t.prototype.getUnderlyingTableDataAsync=function(e,t){return this._worksheetImpl.getUnderlyingTableDataAsync(e,t)},t.prototype.getUnderlyingTableDataReaderAsync=function(e,t,r){return this._worksheetImpl.getUnderlyingTableDataReaderAsync(e,t,r)},t.prototype.getVisualSpecificationAsync=function(){return this._worksheetImpl.getVisualSpecificationAsync()},t.prototype.clearSelectedMarksAsync=function(){return this._worksheetImpl.clearSelectedMarksAsync()},t.prototype.selectMarksByIDAsync=function(e,t){return this._worksheetImpl.selectMarksByIdAsync(e,t)},t.prototype.selectMarksByValueAsync=function(e,t){return this._worksheetImpl.selectMarksByValueAsync(e,t)},t.prototype.selectMarksByIdAsync=function(e,t){return this._worksheetImpl.selectMarksByIdAsync(e,t)},t.prototype.annotateMarkAsync=function(e,t){return this._worksheetImpl.annotateMarkAsync(e,t)},t.prototype.getAnnotationsAsync=function(){return this._worksheetImpl.getAnnotationsAsync()},t.prototype.removeAnnotationAsync=function(e){return this._worksheetImpl.removeAnnotationAsync(e)},t.prototype.hoverTupleAsync=function(e,t,r){return void 0===r&&(r=!0),this._worksheetImpl.hoverTupleAsync(e,t,r)},t.prototype.selectTuplesAsync=function(e,t,r){return this._worksheetImpl.selectTuplesAsync(e,t,r)},t.prototype.getTooltipTextAsync=function(e){return this._worksheetImpl.getTooltipTextAsync(e)},t.prototype.leaveMarkNavigationAsync=function(){return this._worksheetImpl.leaveMarkNavigationAsync()},t.prototype.visualIdsAreEqual=function(e,t){return e&&t&&e.worksheet===t.worksheet&&e.dashboard===t.dashboard&&e.storyboard===t.storyboard&&e.storyPointID===t.storyPointID},t}(r(6132).Sheet);t.Worksheet=y},893:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._dashboard=e}return Object.defineProperty(e.prototype,"dashboard",{get:function(){return this._dashboard},enumerable:!0,configurable:!0}),e}();t.DashboardContent=r},520:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(5136),i=r(8396),o=r(8012),a=function(){function e(e){this._apiVersion=n.ApiVersion.Instance&&n.ApiVersion.Instance.formattedValue,this._context=n.InternalToExternalEnumMappings.extensionContext.convert(e.extensionContext),this._formatting=o.WorkbookFormattingEnvUtil.convertToWorkbookFormatting(e.workbookFormatting),this._language=e.extensionLanguage,this._country=e.extensionCountry,this._locale=e.extensionLocale,this._mode=n.InternalToExternalEnumMappings.extensionMode.convert(e.extensionMode),this._operatingSystem=e.operatingSystem,this._tableauVersion=e.tableauVersion,this._uniqueUserId=e.uniqueUserId,e.userId&&(this.connectedServer=new i.ConnectedServer(e.userId,e.siteId,e.siteNamespace,e.workbookId),this.featureFlags=e.featureFlags)}return Object.defineProperty(e.prototype,"apiVersion",{get:function(){return this._apiVersion},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"context",{get:function(){return this._context},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"workbookFormatting",{get:function(){return this._formatting},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"language",{get:function(){return this._language},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"country",{get:function(){return this._country},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"locale",{get:function(){return this._locale},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"mode",{get:function(){return this._mode},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"operatingSystem",{get:function(){return this._operatingSystem},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"tableauVersion",{get:function(){return this._tableauVersion},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"uniqueUserId",{get:function(){return this._uniqueUserId},enumerable:!0,configurable:!0}),e}();t.Environment=a},5408:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this.extensionImpl=e,this.extensionImpl=e}return Object.defineProperty(e.prototype,"dashboardContent",{get:function(){return this.extensionImpl.dashboardContent},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worksheetContent",{get:function(){return this.extensionImpl.worksheetContent},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"environment",{get:function(){return this.extensionImpl.environment},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"settings",{get:function(){return this.extensionImpl.settings},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"ui",{get:function(){return this.extensionImpl.ui},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"workbook",{get:function(){return this.extensionImpl.workbook},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"dashboardObjectId",{get:function(){return this.extensionImpl.extensionZoneId},enumerable:!0,configurable:!0}),e.prototype.initializeAsync=function(e){return this.extensionImpl.initializeAsync(!1,e).then()},e.prototype.initializeDialogAsync=function(){return this.extensionImpl.initializeAsync(!0)},e.prototype.createVizImageAsync=function(e){return this.extensionImpl.createVizImageAsync(e)},e.prototype.setClickThroughAsync=function(e){return this.extensionImpl.setClickThroughAsync(e)},e}();t.Extensions=r},652:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=function(e){function t(t){var r=e.call(this)||this;return r._settingsImpl=t,r._settingsImpl.initializeEvents().forEach((function(e){return r.addNewEventType(e)})),r}return i(t,e),t.prototype.erase=function(e){this._settingsImpl.erase(e)},t.prototype.get=function(e){return this._settingsImpl.get(e)},t.prototype.getAll=function(){return this._settingsImpl.getAll()},Object.defineProperty(t.prototype,"isModified",{get:function(){return this._settingsImpl.isModified},enumerable:!0,configurable:!0}),t.prototype.saveAsync=function(){return this._settingsImpl.saveAsync()},t.prototype.set=function(e,t){this._settingsImpl.set(e,t)},t}(r(5136).EventListenerManager);t.Settings=o},1964:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._impl=e}return e.prototype.displayDialogAsync=function(e,t,r){return this._impl.displayDialogAsync(e,t,r)},e.prototype.closeDialog=function(e){this._impl.closeDialog(e)},e}();t.UI=r},8012:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(5136),i=function(){function e(){}return e.convertToWorkbookFormatting=function(e){return e?{formattingSheets:e.formattingSheets.map((function(e){return{classNameKey:n.InternalToExternalEnumMappings.classNameKey.convert(e.classNameKey),cssProperties:{fontFamily:e.cssProperties.fontFamily,fontSize:e.cssProperties.fontSize,fontWeight:e.cssProperties.fontWeight,fontStyle:e.cssProperties.fontStyle,textDecoration:e.cssProperties.textDecoration,color:e.cssProperties.color}}}))}:void 0},e}();t.WorkbookFormattingEnvUtil=i},7e3:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._worksheet=e}return Object.defineProperty(e.prototype,"worksheet",{get:function(){return this._worksheet},enumerable:!0,configurable:!0}),e}();t.WorksheetContent=r},6336:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(3448),a=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"InitializationService"},enumerable:!0,configurable:!0}),t.prototype.initializeDashboardExtensionsAsync=function(e,t){var r,n=((r={})[o.ParameterId.FunctionName]="initializeDashboardExtensionsAsync",r[o.ParameterId.ExtensionContextMenuIds]=t,r[o.ParameterId.IsExtensionDialog]=e,r);return this.execute(o.VerbId.InitializeExtension,n).then((function(e){return e.result}))},t}(r(5136).ServiceImplBase);t.InitializationServiceImpl=a},5432:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(5136),u=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"SettingsService"},enumerable:!0,configurable:!0}),t.prototype.saveSettingsAsync=function(e){var t,r=((t={})[a.ParameterId.FunctionName]="saveSettingsAsync",t[a.ParameterId.SettingsValues]=e,t);return this.execute(a.VerbId.SaveExtensionSettings,r).then((function(e){var t=e.result;if(!t||!t.settingsValues)throw new s.TableauError(o.ErrorCodes.InternalError,"Unexpected error savings settings.");return t.settingsValues}))},t}(s.ServiceImplBase);t.SettingsServiceImpl=u},752:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(5136),u=o.DialogStyle.Window,l=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"UIService"},enumerable:!0,configurable:!0}),t.prototype.displayDialogAsync=function(e,t,r){var n,i=((n={})[a.ParameterId.FunctionName]="displayDialogAsync",n[a.ParameterId.ExtensionDialogUrl]=e,n[a.ParameterId.ExtensionDialogPayload]=t,n),l=r&&r.height?r.height:400,c=r&&r.width?r.width:600,p=r&&r.dialogStyle?r.dialogStyle:u;if(l<=0||c<=0)throw new s.TableauError(o.ErrorCodes.InvalidParameter,"Size parameters for displayDialogAsync must be positive");return i[a.ParameterId.ExtensionDialogH]=l,i[a.ParameterId.ExtensionDialogW]=c,s.ErrorHelpers.verifyEnumValue(p,o.DialogStyle,"DialogStyle"),i[a.ParameterId.ExtensionDialogStyle]=s.ExternalToInternalEnumMappings.dialogStyles.convert(p),this.execute(a.VerbId.DisplayDialog,i).then((function(e){switch(e.result){case a.ExtensionDialogResult.DialogAlreadyOpen:throw new s.TableauError(o.ErrorCodes.DialogAlreadyOpen,"There already exists an open dialog for this extension.");case a.ExtensionDialogResult.InvalidDomain:throw new s.TableauError(o.ErrorCodes.InvalidDomainDialog,"The url of an extension dialog must match the domain of the parent extension.");default:return}}))},t.prototype.closeDialog=function(e){var t,r=((t={})[a.ParameterId.FunctionName]="closeDialog",t);return e&&(r[a.ParameterId.ExtensionDialogPayload]=e),this.execute(a.VerbId.CloseDialog,r).then((function(){}))},t.prototype.setClickThroughAsync=function(e,t){var r;if(s.ErrorHelpers.verifyParameterType(e,"boolean","clickThroughEnabled"),void 0===t||t<=0)throw new s.TableauError(o.ErrorCodes.InternalError,"Extension Id is invalid.");var n=((r={})[a.ParameterId.ExtensionZoneId]=t,r[a.ParameterId.ClickThroughEnabled]=e,r);return this.execute(a.VerbId.SetClickThrough,n).then((function(){}))},t}(s.ServiceImplBase);t.UIServiceImpl=l},6616:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(5136),i=r(6336),o=r(5432),a=r(752),s=r(1468);t.registerAllExtensionsServices=function(e){n.ApiServiceRegistry.get(s.ExtensionsRegistryId).registerService(new o.SettingsServiceImpl(e,s.ExtensionsRegistryId)),n.ApiServiceRegistry.get(s.ExtensionsRegistryId).registerService(new a.UIServiceImpl(e,s.ExtensionsRegistryId))},t.registerInitializationExtensionsServices=function(e){n.ApiServiceRegistry.get(s.ExtensionsRegistryId).registerService(new i.InitializationServiceImpl(e,s.ExtensionsRegistryId))}},1468:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),t.ExtensionsRegistryId=0},268:(e,t,r)=>{"use strict";function n(e){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r])}Object.defineProperty(t,"__esModule",{value:!0}),n(r(4171));var i=r(3536);t.ApiMenuType=i.ApiMenuType,t.CrosstabFileFormat=i.CrosstabFileFormat,t.DeviceType=i.DeviceType,t.EmbeddingErrorCodes=i.EmbeddingErrorCodes,t.EmbeddingTableauEventType=i.TableauEventType,t.FileFormats=i.FileFormats,t.PrintOrientation=i.PrintOrientation,t.PrintPageSize=i.PrintPageSize,t.PrintScaling=i.PrintScaling,t.PulseLayout=i.PulseLayout,t.SheetSizeBehavior=i.SheetSizeBehavior,t.TableauDialogType=i.TableauDialogType,t.Toolbar=i.Toolbar,n(r(828)),n(r(3432)),n(r(1480)),n(r(5488))},5840:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(4744);t.ErrorCodes=n.ErrorCodes,t.ExtensionContext=n.ExtensionContext,t.ExtensionMode=n.ExtensionMode,t.TableauEventType=n.TableauEventType,t.VizImageEncodingType=n.VizImageEncodingType,t.VizImagePaletteType=n.VizImagePaletteType,t.VizImageSizeSettingAlignmentType=n.VizImageSizeSettingAlignmentType,t.VizImageSizeSettingType=n.VizImageSizeSettingType,t.VizImageSortDirectionType=n.VizImageSortDirectionType,function(e){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r])}(r(5488))},7419:(e,t,r)=>{"use strict";function n(e){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r])}Object.defineProperty(t,"__esModule",{value:!0}),n(r(268)),n(r(5840))},4171:(e,t)=>{"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),(r=t.AskDataAttributes||(t.AskDataAttributes={})).Origin="origin",r.ShowEmbed="show-embed",r.ShowPin="show-pin",r.ShowSave="show-save",r.ShowShare="show-share"},3536:(e,t)=>{"use strict";var r,n,i,o,a,s,u,l,c,p,d,f,y,h;Object.defineProperty(t,"__esModule",{value:!0}),(h=t.CrosstabFileFormat||(t.CrosstabFileFormat={})).CSV="csv",h.Excel="xlsx",(y=t.DeviceType||(t.DeviceType={})).Default="default",y.Desktop="desktop",y.Tablet="tablet",y.Phone="phone",(f=t.EmbeddingErrorCodes||(t.EmbeddingErrorCodes={})).AuthFailed="auth-failed",f.BrowserNotCapable="browser-not-capable",f.DownloadWorkbookNotAllowed="download-workbook-not-allowed",f.FilterCannotBePerformed="filter-cannot-be-performed",f.IndexOutOfRange="index-out-of-range",f.InternalError="internal-error",f.InvalidCustomViewName="invalid-custom-view-name",f.InvalidDateParameter="invalid-date-parameter",f.invalidFilterFieldNameOrValue="invalid-filter-field-name",f.InvalidParameter="invalid-parameter",f.InvalidSize="invalid-size",f.InvalidSheetType="invalid-sheet-type",f.InvalidSizeBehavior="invalid-size-behavior",f.InvalidSizeBehaviorOnWorksheet="invalid-size-behavior-on-worksheet",f.InvalidUrl="invalid-url",f.MissingMaxSize="missing-max-size",f.MissingMinSize="missing-min-size",f.MissingMinMaxSize="missing-min-max-size",f.MissingParameter="missing-parameter",f.MissingRangeNForRelativeDateFilters="missing-range-n-for-relative-date-filters",f.NoUrlForHiddenWorksheet="no-url-for-hidden-worksheet",f.NoUrlOrParentElementNotFound="no-url-or-parent-element-not-found",f.NotActiveSheet="not-active-sheet",f.NullOrEmptyParameter="null-or-empty-parameter",f.SheetNotInWorkbook="sheet-not-in-workbook",f.StaleDataReference="stale-data-reference",f.UnknownAuthError="unknown-auth-error",f.UnsupportedEventName="unsupported-event-name",f.VizAlreadyInManager="viz-already-in-manager",f.ImplementationError="wrong-implementation",f.NotImplemented="not-implemented",f.EventInitializationError="event-initialization-error",f.IncompatibleVersionError="incompatible-version-error",f.UnknownDialogType="unknown-dialog-type",f.FilterMissingOrNotImplemented="filter-missing-not-implemented",f.StoryPointIdMismatch="storypoint-id-mismatch",(d=t.FileFormats||(t.FileFormats={})).PDF="pdf",d.PNG="png",(p=t.PrintOrientation||(t.PrintOrientation={})).Portrait="portrait",p.Landscape="landscape",(c=t.PrintPageSize||(t.PrintPageSize={})).Letter="letter",c.Legal="legal",c.Note="note",c.Folio="folio",c.Tabloid="tabloid",c.Ledger="ledger",c.Statement="statement",c.Executive="executive",c.A3="A3",c.A4="A4",c.A5="A5",c.B4="B4",c.B5="B5",c.Quarto="quarto",c.Unspecified="unspecified",(l=t.PrintScaling||(t.PrintScaling={})).Automatic="automatic",l.Perc25="25%",l.Perc50="50%",l.Perc60="60%",l.Perc75="75%",l.Perc80="80%",l.Perc90="90%",l.Perc100="100%",l.Perc200="200%",l.Perc400="400%",l.AtMost1PageHigh="at-most-1-page-high",l.AtMost2PagesHigh="at-most-2-pages-high",l.AtMost1PageWide="at-most-1-page-wide",l.AtMost2PagesWide="at-most-2-pages-wide",(u=t.RevertVizSelection||(t.RevertVizSelection={})).All="all",u.Axes="axes",u.Filters="filters",u.Sorts="sorts",u.Shelves="shelves",(s=t.ToolbarButtons||(t.ToolbarButtons={})).Alerts="alerts",s.AskData="askData",s.CustomViews="customViews",s.DataDetails="dataDetails",s.Share="share",s.Subscribe="subscribe",(a=t.Toolbar||(t.Toolbar={})).Top="top",a.Bottom="bottom",a.Hidden="hidden",(o=t.SheetSizeBehavior||(t.SheetSizeBehavior={})).Automatic="automatic",o.Exactly="exactly",o.Range="range",o.AtLeast="atleast",o.AtMost="atmost",(i=t.PulseLayout||(t.PulseLayout={})).Default="default",i.Card="card",i.Ban="ban",(n=t.TableauEventType||(t.TableauEventType={})).CustomViewLoaded="customviewloaded",n.CustomViewRemoved="customviewremoved",n.CustomViewSaved="customviewsaved",n.CustomViewSetDefault="customviewsetdefault",n.EditButtonClicked="editbuttonclicked",n.EditInDesktopButtonClicked="editindesktopbuttonclicked",n.FilterChanged="filterchanged",n.FirstVizSizeKnown="firstvizsizeknown",n.FirstInteractive="firstinteractive",n.CustomMarkContextMenuEvent="custommarkcontextmenu",n.MarkSelectionChanged="markselectionchanged",n.ParameterChanged="parameterchanged",n.ToolbarStateChanged="toolbarstatechanged",n.WorkbookReadyToClose="workbookreadytoclose",n.WorkbookPublished="workbookpublished",n.WorkbookPublishedAs="workbookpublishedas",n.UrlAction="urlaction",n.TabSwitched="tabswitched",n.StoryPointSwitched="storypointswitched",n.VizLoadError="vizloaderror",n.IframeSrcUpdated="iframesrcupdated",n.SummaryDataChanged="summarydatachanged",n.ReadyToReceiveAuthToken="readytoreceiveauthtoken",(t.ApiMenuType||(t.ApiMenuType={})).Ubertip="ubertip",(r=t.TableauDialogType||(t.TableauDialogType={})).ExportPDF="export-pdf",r.ExportPowerPoint="export-powerpoint",r.ExportData="export-data",r.ExportCrossTab="export-cross-tab",r.ExportWorkbook="export-workbook",r.Share="share"},828:(e,t)=>{"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),(r=t.PulseAttributes||(t.PulseAttributes={})).DisableExploreFilter="disable-explore-filter",r.Layout="layout"},3432:(e,t)=>{"use strict";var r,n,i,o,a;Object.defineProperty(t,"__esModule",{value:!0}),(a=t.VizSharedAttributes||(t.VizSharedAttributes={})).TouchOptimize="touch-optimize",a.HideEditInDesktopButton="hide-edit-in-desktop-button",a.SuppressDefaultEditBehavior="suppress-default-edit-behavior",a.DisableVersionCheck="disable-version-check",a.OnEditInDesktopButtonClicked="onEditInDesktopButtonClicked",a.OnFirstVizSizeKnown="onFirstVizSizeKnown",a.OnFirstInteractive="onFirstInteractive",(o=t.VizAttributes||(t.VizAttributes={})).DisableUrlActionsPopups="disable-url-actions",o.HideTabs="hide-tabs",o.Toolbar="toolbar",o.InstanceIdToClone="instance-id-to-clone",o.Device="device",o.HideEditButton="hide-edit-button",o.OnEditButtonClicked="onEditButtonClicked",o.OnFilterChanged="onFilterChanged",o.OnCustomMarkContextMenuEvent="onCustomMarkContextMenuEvent",o.OnMarkSelectionChanged="onMarkSelectionChanged",o.OnParameterChanged="onParameterChanged",o.OnToolbarStateChanged="onToolbarStateChanged",o.OnUrlAction="onUrlAction",o.OnTabSwitched="onTabSwitched",o.OnCustomViewLoaded="onCustomViewLoaded",o.OnCustomViewRemoved="onCustomViewRemoved",o.OnCustomViewSaved="onCustomViewSaved",o.OnCustomViewSetDefault="onCustomViewSetDefault",o.OnStoryPointSwitched="onStoryPointSwitched",o.OnSummaryDataChanged="onSummaryDataChanged",o.OnReadyToReceiveAuthToken="onReadyToReceiveAuthToken",(i=t.VizAuthoringAttributes||(t.VizAuthoringAttributes={})).OnWorkbookPublished="onWorkbookPublished",i.OnWorkbookPublishedAs="onWorkbookPublishedAs",i.OnWorkbookReadyToClose="onWorkbookReadyToClose",i.HideCloseButton="hide-close-button",(n=t.VizChildElements||(t.VizChildElements={})).VizFilter="viz-filter",n.VizParameter="viz-parameter",n.CustomParameter="custom-parameter",(r=t.VizChildElementAttributes||(t.VizChildElementAttributes={})).Field="field",r.Value="value",r.Name="name"},1480:(e,t)=>{"use strict";var r,n;Object.defineProperty(t,"__esModule",{value:!0}),(n=t.WebComponentAttributes||(t.WebComponentAttributes={})).Src="src",n.Width="width",n.Height="height",n.Token="token",n.Debug="debug",n.IframeAuth="iframe-auth",n.OnVizLoadError="onvizloaderror",n.ForceTokenSync="force-token-sync",(t.WebComponentChildElements||(t.WebComponentChildElements={})).CustomParameter="custom-parameter",(r=t.WebComponentChildElementAttributes||(t.WebComponentChildElementAttributes={})).Field="field",r.Value="value",r.Name="name"},4744:e=>{"use strict";var t;!function(e){var t,r,n,i,o,a,s,u,l;(l=e.ErrorCodes||(e.ErrorCodes={})).APINotInitialized="api-not-initialized",l.VisibilityError="visibility-error",l.DialogAlreadyOpen="dialog-already-open",l.DialogClosedByUser="dialog-closed-by-user",l.InternalError="internal-error",l.InvalidDomainDialog="invalid-dialog-domain",l.InvalidParameter="invalid-parameter",l.MissingFilter="missing-filter",l.MissingParameter="missing-parameter",l.ServerError="server-error",l.SettingSaveInProgress="setting-save-in-progress",l.UnsupportedEventName="unsupported-event-name",l.UnsupportedMethodForDataSourceType="unsupported-method-for-data-source-type",(u=e.ExtensionContext||(e.ExtensionContext={})).Desktop="desktop",u.Server="server",(s=e.ExtensionMode||(e.ExtensionMode={})).Authoring="authoring",s.Viewing="viewing",(a=e.TableauEventType||(e.TableauEventType={})).FilterChanged="filter-changed",a.MarkSelectionChanged="mark-selection-changed",a.SummaryDataChanged="summary-data-changed",a.ParameterChanged="parameter-changed",a.SettingsChanged="settings-changed",a.DashboardLayoutChanged="dashboard-layout-changed",a.WorkbookFormattingChanged="workbook-formatting-changed",(o=e.VizImageEncodingType||(e.VizImageEncodingType={})).Discrete="discrete",o.Continuous="continuous",(i=e.VizImageSortDirectionType||(e.VizImageSortDirectionType={})).Ascending="ascending",i.Descending="descending",(n=e.VizImagePaletteType||(e.VizImagePaletteType={})).CustomDiverging="custom-diverging",n.CustomSequential="custom-sequential",(r=e.VizImageSizeSettingType||(e.VizImageSizeSettingType={})).Fixed="fixed",r.Manual="manual",(t=e.VizImageSizeSettingAlignmentType||(e.VizImageSizeSettingAlignmentType={})).Right="right",t.Left="left",t.Center="center"}(t||(t={})),e.exports=t},4912:(e,t)=>{"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),(r=t.SharedErrorCodes||(t.SharedErrorCodes={})).CrosstabCreationError="crosstab-creation-error",r.DataCreationError="data-creation-error",r.InvalidAggregationFieldName="invalid-aggregation-field-name",r.InvalidFilterFieldName="invalid-filter-name",r.InvalidFilterFieldValue="invalid-filter-fieldValue",r.InvalidSelectionDate="invalid-selection-date",r.InvalidSelectionFieldName="invalid-selection-fieldName",r.InvalidSelectionValue="invalid-selection-value",r.InvalidSelectionSheet="invalid-selection-sheet",r.InternalError="internal-error",r.InvalidParameter="invalid-parameter",r.PDFCreationError="pdf-creation-error",r.PowerPointCreationError="powerpoint-creation-error",r.NotActiveSheet="not-active-sheet",r.ImplementationError="wrong-implementation",r.ApiExecutionError="api-execution-error",r.ServerError="server-error",r.Timeout="timeout"},808:function(e){"use strict";var t,r=this&&this.__assign||function(){return r=Object.assign||function(e){for(var t,r=1,n=arguments.length;r{"use strict";Object.defineProperty(t,"__esModule",{value:!0}),function(e){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r])}(r(4912));var n=r(808);t.AnalyticsObjectType=n.AnalyticsObjectType,t.AnnotationType=n.AnnotationType,t.ClassNameKey=n.ClassNameKey,t.ColumnType=n.ColumnType,t.DashboardLayoutChange=n.DashboardLayoutChange,t.DashboardObjectType=n.DashboardObjectType,t.DashboardObjectVisibilityType=n.DashboardObjectVisibilityType,t.DataType=n.DataType,t.DateRangeType=n.DateRangeType,t.DialogStyle=n.DialogStyle,t.EncodingType=n.EncodingType,t.FieldAggregationType=n.FieldAggregationType,t.FieldRoleType=n.FieldRoleType,t.FilterDomainType=n.FilterDomainType,t.FilterNullOption=n.FilterNullOption,t.FilterType=n.FilterType,t.FilterUpdateType=n.FilterUpdateType,t.HierarchicalLevelSelectionState=n.HierarchicalLevelSelectionState,t.IncludeDataValuesOption=n.IncludeDataValuesOption,t.MarkType=n.MarkType,t.ParameterValueType=n.ParameterValueType,t.PeriodType=n.PeriodType,t.QuickTableCalcType=n.QuickTableCalcType,t.ReplaySpeedType=n.ReplaySpeedType,t.SelectOptions=n.SelectOptions,t.SelectionUpdateType=n.SelectionUpdateType,t.SheetType=n.SheetType,t.SortDirection=n.SortDirection,t.TrendLineModelType=n.TrendLineModelType,t.ZoneVisibilityType=n.ZoneVisibilityType},3448:(e,t,r)=>{"use strict";function n(e){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r])}Object.defineProperty(t,"__esModule",{value:!0}),r(5668),r(5816),r(8824);var i=r(5892);t.INTERNAL_CONTRACT_VERSION=i,n(r(6716)),n(r(1080)),n(r(5824)),n(r(4547)),n(r(2400)),n(r(2496)),n(r(2472)),n(r(552)),n(r(3256)),n(r(7204)),n(r(3760)),n(r(4528)),n(r(3388)),t.MESSAGING_VERSION={major:1,minor:0,fix:0}},6716:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(1080),i=function(){function e(){}return e.isSpecial=function(e){return e.length>2&&"%"===e[0]&&"%"===e[e.length-1]},e.parseBoolean=function(e){var t=e.toLowerCase();return"true"!==t&&"false"!==t?this.specialValueIndicator:"true"===t},e.parseNumber=function(e){var t=Number(e);return isNaN(t)?this.specialValueIndicator:t},e.parseDate=function(e){var t=new Date(e);return Number.isNaN(t.getTime())?null:t},e.parseDateTime=function(e){var t=e.replace(" ","T").concat("Z"),r=new Date(t);return Number.isNaN(r.getTime())?null:r},e.convertValueAsStringToValue=function(e,t){if(null!=e){if(this.isSpecial(e))return e;switch(t){case n.DataType.Bool:return this.parseBoolean(e);case n.DataType.Int:case n.DataType.Float:return this.parseNumber(e);case n.DataType.Date:return null===this.parseDate(e)?this.specialValueIndicator:e;case n.DataType.DateTime:return null===this.parseDateTime(e)?this.specialValueIndicator:e;case n.DataType.Spatial:case n.DataType.String:default:return e}}},e.convertValueToNativeValue=function(e,t){if(null==e)return null;switch(t){case n.DataType.Bool:case n.DataType.Int:case n.DataType.Float:return"string"==typeof e?null:e;case n.DataType.Date:return this.parseDate(e);case n.DataType.DateTime:return this.parseDateTime(e);case n.DataType.String:return this.isSpecial(e)?null:e;case n.DataType.Spatial:default:return e}},e.convertStringValueToNativeValue=function(e,t){return this.convertValueToNativeValue(this.convertValueAsStringToValue(e,t),t)},e.specialValueIndicator="%null%",e}();t.DataTypeConverter=i},1080:(e,t)=>{"use strict";var r,n,i,o,a,s,u,l,c,p,d,f,y,h,m,g,v,b,I,S,_,T,P,A,E,w,O,D,x,F,C,N,M;Object.defineProperty(t,"__esModule",{value:!0}),(M=t.ExtensionContext||(t.ExtensionContext={})).Desktop="desktop",M.Server="server",M.Unknown="unknown",(N=t.ExtensionMode||(t.ExtensionMode={})).Authoring="authoring",N.Viewing="viewing",N.Unknown="unknown",(C=t.AnnotateEnum||(t.AnnotateEnum={})).Mark="mark",C.Point="point",C.Area="area",(F=t.ColumnType||(t.ColumnType={})).Discrete="discrete",F.Continuous="continuous",F.Unknown="unknown",(x=t.DashboardObjectType||(t.DashboardObjectType={})).Blank="blank",x.Worksheet="worksheet",x.QuickFilter="quick-filter",x.ParameterControl="parameter-control",x.PageFilter="page-filter",x.Legend="legend",x.Title="title",x.Text="text",x.Image="image",x.WebPage="web-page",x.Extension="extension",(D=t.DataType||(t.DataType={})).String="string",D.Int="int",D.Float="float",D.Bool="bool",D.Date="date",D.DateTime="date-time",D.Spatial="spatial",D.Unknown="unknown",(O=t.DialogStyle||(t.DialogStyle={})).Window="window",O.Modal="modal",O.Modeless="modeless",(w=t.EncodedDataType||(t.EncodedDataType={})).Number="number",w.String="string",w.Date="date",w.Boolean="boolean",(E=t.ErrorCodes||(t.ErrorCodes={})).INITIALIZATION_ERROR="initialization-error",E.INTERNAL_ERROR="internal-error",E.MISSING_ENUM_MAPPING="missing-enum-mapping",E.MISSING_PARAMETER="missing-parameter",E.PERMISSION_DENIED="permission-denied",E.PRES_MODEL_PARSING_ERROR="pres-model-parsing-error",E.VERSION_NOT_CONFIGURED="version-not-configured",E.VISIBILITY_ERROR="visibility-error",E.UNKNOWN_VERB_ID="unknown-verb-id",(A=t.FieldAggregationType||(t.FieldAggregationType={})).Sum="sum",A.Avg="avg",A.Min="min",A.Max="max",A.Stdev="stdev",A.Stdevp="stdevp",A.Var="var",A.Varp="varp",A.Collect="collect",A.Count="count",A.Countd="countd",A.Median="median",A.Attr="attr",A.None="none",A.Year="year",A.Qtr="qtr",A.Month="month",A.Day="day",A.Hour="hour",A.Minute="minute",A.Second="second",A.Week="week",A.Weekday="weekday",A.MonthYear="month-year",A.Mdy="mdy",A.End="end",A.TruncYear="trunc-year",A.TruncQtr="trunc-qtr",A.TruncMonth="trunc-month",A.TruncWeek="trunc-week",A.TruncDay="trunc-day",A.TruncHour="trunc-hour",A.TruncMinute="trunc-minute",A.TruncSecond="trunc-second",A.Quart1="quart1",A.Quart3="quart3",A.Skewness="skewness",A.Kurtosis="kurtosis",A.InOut="in-out",A.User="user",(P=t.FieldRoleType||(t.FieldRoleType={})).Dimension="dimension",P.Measure="measure",P.Unknown="unknown",(T=t.FilterUpdateType||(t.FilterUpdateType={})).Add="add",T.All="all",T.Replace="replace",T.Remove="remove",(_=t.SheetType||(t.SheetType={})).Dashboard="dashboard",_.Story="story",_.Worksheet="worksheet",(S=t.DomainRestrictionType||(t.DomainRestrictionType={})).All="all",S.List="list",S.Range="range",(I=t.DateStepPeriod||(t.DateStepPeriod={})).Years="years",I.Quarters="quarters",I.Months="months",I.Weeks="weeks",I.Days="days",I.Hours="hours",I.Minutes="minutes",I.Seconds="seconds",(b=t.FilterNullOption||(t.FilterNullOption={})).NullValues="nullvalues",b.NonNullValues="nonnullvalues",b.AllValues="allvalues",(v=t.FilterDomainType||(t.FilterDomainType={})).Relevant="relevant",v.Database="database",(g=t.SelectionUpdateType||(t.SelectionUpdateType={})).Replace="select-replace",g.Add="select-add",g.Remove="select-remove",(m=t.SelectOptions||(t.SelectOptions={})).Simple="select-options-simple",m.Toggle="select-options-toggle",m.Menu="select-options-menu",m.Range="select-options-range",m.Search="select-options-search",(h=t.QuantitativeIncludedValues||(t.QuantitativeIncludedValues={})).IncludeNull="include-null",h.IncludeNonNull="include-non-null",h.IncludeAll="include-all",(y=t.HierarchicalLevelSelectionState||(t.HierarchicalLevelSelectionState={})).AllSelected="all-selected",y.NoneSelected="none-selected",y.SomeSelected="some-selected",y.UnknownSelected="unknown-selected",(f=t.MarkType||(t.MarkType={})).Bar="bar",f.Line="line",f.Area="area",f.Square="square",f.Circle="circle",f.Shape="shape",f.Text="text",f.Map="map",f.Pie="pie",f.GanttBar="gantt-bar",f.Polygon="polygon",f.Heatmap="heatmap",f.VizExtension="viz-extension",(d=t.FilterType||(t.FilterType={})).Categorical="categorical",d.Range="range",d.RelativeDate="relativeDate",d.Hierarchical="hierarchical",(p=t.DateRangeType||(t.DateRangeType={})).Last="last",p.LastN="lastN",p.Next="next",p.NextN="nextN",p.Current="current",p.ToDate="toDate",(c=t.ExtensionDialogResult||(t.ExtensionDialogResult={})).DialogAlreadyOpen="dialog-already-open",c.InvalidDomain="invalid-domain",c.Success="success",(l=t.ApiShowDataTableSentinel||(t.ApiShowDataTableSentinel={})).SingleTableId="single-table-id-sentinel",l.SingleTableCaption="Single table id sentinel",(u=t.ApiShowDataTableFormat||(t.ApiShowDataTableFormat={})).NativeValuesOnly="native-values-only",u.FormattedValuesOnly="formatted-values-only",u.NativeAndFormattedValues="native-and-formatted-values",(s=t.PageSizeOption||(t.PageSizeOption={})).Letter="letter",s.Legal="legal",s.Note="note",s.Folio="folio",s.Tabloid="tabloid",s.Ledger="ledger",s.Statement="statement",s.Executive="executive",s.A3="a3",s.A4="a4",s.A5="a5",s.B4="b4",s.B5="b5",s.Quarto="quarto",s.Unspecified="unspecified",(a=t.PageOrientation||(t.PageOrientation={})).Printer="printer",a.Portrait="portrait",a.Landscape="landscape",(o=t.ScaleMode||(t.ScaleMode={})).ScaleAuto="auto",o.ScalePercentage="percent",o.ScaleFitPages="fit-pages",(i=t.PageScalingOption||(t.PageScalingOption={})).ScalePctAuto="auto",i.ScalePct400="pct400",i.ScalePct200="pct200",i.ScalePct100="pct100",i.ScalePct90="pct90",i.ScalePct80="pct80",i.ScalePct75="pct75",i.ScalePct60="pct60",i.ScalePct50="pct50",i.ScalePct25="pct25",(n=t.FitPages||(t.FitPages={})).FitOneHigh="fit0x1",n.FitTwoHigh="fit0x2",n.FitOneWide="fit1x0",n.FitTwoWide="fit2x0",(r=t.EncodingType||(t.EncodingType={})).Color="color",r.Size="size",r.Label="label",r.Detail="detail",r.Tooltip="tooltip",r.Shape="shape",r.Path="path",r.Angle="angle",r.Geometry="geometry",r.Custom="custom"},5824:(e,t)=>{"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),(r=t.NotificationId||(t.NotificationId={})).CustomMarkContextMenuClicked="custom-mark-context-menu-clicked",r.ContextMenuClick="context-menu-click",r.CustomViewRemoved="custom-view-removed",r.CustomViewSaved="custom-view-saved",r.CustomViewSetDefault="custom-view-set-default",r.CustomViewsLoaded="custom-views-loaded",r.DashboardLayoutChanged="dashboard-layout-changed",r.EditButtonClicked="edit-button-clicked",r.EditInDesktopButtonClicked="edit-in-desktop-button-clicked",r.ExtensionDialogUpdate="extension-dialog-update",r.FilterChanged="filter-changed",r.FirstVizSizeKnown="first-viz-size-known",r.ParameterChanged="parameter-changed",r.SelectedMarksChanged="selected-marks-changed",r.SettingsChanged="settings-changed",r.SummaryDataChanged="summary-data-changed",r.TestConversionNotification="test-conversion-notification",r.ToolbarStateChanged="toolbar-state-changed",r.VizInteractive="viz-interactive",r.AskDataInteractive="ask-data-interactive",r.WorkbookReadyToClose="workbook-ready-to-close",r.WorkbookFormattingChanged="workbook-formatting-changed",r.WorkbookPublished="workbook-published",r.WorkbookPublishedAs="workbook-published-as",r.UrlAction="url-action",r.TabSwitched="tab-switched",r.StoryPointSwitched="story-point-switched",r.ReadyToReceiveAuthToken="ready-to-receive-auth-token"},4547:(e,t)=>{"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),(r=t.ParameterId||(t.ParameterId={})).ActiveTablesInfo="active-tables-info",r.AnchorDate="anchor-date",r.AnnotateEnum="annotate-enum",r.AnnotationList="annotation-list",r.CategoricalDomain="categorical-domain",r.ClickThroughEnabled="click-through-enabled",r.ColumnsToInclude="columns-to-include",r.ColumnsToIncludeById="columns-to-include-by-id",r.ConnectionDescriptionSummaries="connection-description-summaries",r.CurrentSheetType="current-sheet-type",r.CustomView="custom-view",r.CustomViewIsDefault="custom-view-is-default",r.CustomViewIsPublic="custom-view-is-public",r.CustomViewLuid="custom-view-luid",r.CustomViewName="custom-view-name",r.CustomViews="custom-views",r.Dashboard="dashboard",r.DashboardFilters="dashboard-filters",r.DashboardName="dashboard",r.DashboardObjectPositionAndSizeUpdate="dashboard-object-position-and-size-update",r.DashboardObjectPositionAndSizeUpdateList="dashboard-object-position-and-size-update-list",r.DataRowIndex="data-row-index",r.DataSchema="data-schema",r.DataSource="data-source",r.DataSourceDataTable="data-source-data-table",r.DataSourceId="data-source-id",r.DataSourceName="data-source-name",r.DataTable="data-table",r.DataTableReader="data-table-reader",r.DateRangeType="date-range-type",r.DeltaTimeMs="delta-time-ms",r.DimValSelectionModels="dimensionValueSelectionModels",r.DomainType="domain-type",r.EmbeddingAbstractQuery="embedding-abstract-query",r.EmbeddingBootstrapInfo="embedding-bootstrap-info",r.ExportCrosstabSheetMap="export-crosstab-sheet-map",r.ExportFile="export-file",r.ExportOriginUrl="export-origin-url",r.ExportPdfOptions="export-pdf-options",r.ExtensionBootstrapInfo="extension-bootstrap-info",r.ExtensionContextMenuIds="extension-context-menu-ids",r.ExtensionDialogH="extension-dialog-height",r.ExtensionDialogPayload="extension-dialog-payload",r.ExtensionDialogResult="extension-dialog-result",r.ExtensionDialogStyle="extension-dialog-style",r.ExtensionDialogUrl="extension-dialog-url",r.ExtensionDialogW="extension-dialog-width",r.ExtensionLocator="extension-locator",r.ExtensionSettingsInfo="extension-settings-info",r.ExtensionZoneId="extension-zone-id",r.ExternalMenuDescription="external-menu-description",r.ExternalMenuHeader="external-menu-header",r.ExternalMenuItemDisplayName="external-menu-item-display-name",r.ExternalMenuItemId="external-menu-item-id",r.Field="field",r.FieldId="field-id",r.FieldName="field-name",r.FilterLevels="filter-levels",r.FilterRangeMax="filter-range-max",r.FilterRangeMin="filter-range-min",r.FilterRangeNullOption="filter-range-null-option",r.FilterUpdateType="filter-update-type",r.FilterValues="filter-values",r.FontNameListItems="font-name-list-items",r.FormattedText="formatted-text",r.FunctionName="function-name",r.HierValSelectionModels="hierarchicalValueSelectionModels",r.HighlightedData="highlighted-data",r.HoverTupleInteraction="hover-tuple-interaction",r.IgnoreAliases="ignore-aliases",r.IgnoreSelection="ignore-selection",r.IncludeAllColumns="include-all-columns",r.InvalidAggFieldName="invalid-agg-field-name",r.InvalidDates="invalid-dates",r.InvalidFieldCaption="invalid-field-caption",r.InvalidFields="invalid-fields",r.InvalidValues="invalid-values",r.IsExcludeMode="is-exclude",r.IsExtensionDialog="is-extension-dialog",r.JoinDescription="join-description",r.LogicalTableId="logical-table-id",r.LogicalTableInfoList="logical-table-info-list",r.MaxHeight="max-height",r.MaxRows="max-rows",r.MaxWidth="max-width",r.MinHeight="min-height",r.MinWidth="min-width",r.PageRowCount="page-row-count",r.ParameterCaption="paremeter-caption",r.ParameterError="parameter-error",r.ParameterFieldName="parameter-field-name",r.ParameterInfo="parameter-info",r.ParameterInfos="parameter-infos",r.ParameterValue="parameter-value",r.PeriodType="period-type",r.QuantitativeDomain="quantitative-dmain",r.QuantRangeSelectionModels="quantativeRangeSelectionModels",r.RangeN="range-n",r.ReplaySpeed="replay-speed",r.SelectedData="selected-data",r.SelectedSheetNames="selected-sheet-names",r.Selection="selection",r.SelectionList="selection-list",r.SelectionUpdateType="selectionUpdateType",r.SelectTuplesInteraction="select-tuples-interaction",r.SendNotifications="send-notifications",r.SettingsValues="settings-values",r.SharedFilterSheets="shared-filter-sheets",r.SharedFiltersInfo="shared-filters-info",r.SheetIdentifier="sheet-identifier",r.SheetName="sheet-name",r.SheetPath="sheet-path",r.ShouldRefreshDS="should-refresh-ds",r.ShowDataTableFormat="show-data-table-format",r.State="state",r.StoryPointIndex="story-point-index",r.StoryPointInfo="story-point-info",r.SwitchToSheetName="switch-to-sheet-name",r.TargetPoint="target-point",r.TestConversionParameter="test-conversion-parameter",r.Text="formatted-text",r.TooltipContext="tooltip-context",r.TooltipTextRequest="tooltip-text-request",r.TooltipText="tooltip-text",r.UnderlyingDataTable="underlying-data-table",r.UnderlyingSummaryDataTable="underlying-summary-data-table",r.Url="url",r.UseTabDelimiters="use-tab-delimiters",r.ViewDataTableCacheId="view-data-table-cache-id",r.ViewDataTableId="view-data-table-id",r.VisualId="visual-id",r.VisualSpecification="visual-specification",r.VizAPIInputJson="vizapi-input-json",r.VizAPIStateWithDataModel="vizapi-state-with-data-model",r.VizAPIStateWarningMsg="vizapi-state-warning-msg",r.VizAPISVG="vizapi-svg",r.WorksheetName="worksheet-name",r.WorksheetFilters="worksheet-filters",r.ZoneIdsVisibilityMap="zone-ids-visibility-map"},2400:(e,t)=>{"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),(r=t.VerbId||(t.VerbId={})).ActivateNextStoryPoint="activate-next-story-point",r.ActivatePreviousStoryPoint="activate-previous-story-point",r.ActivateSheet="activateSheet",r.ActivateStoryPoint="activate-story-point",r.AppendExternalMenuItem="append-external-menu-item",r.ApplyCategoricalFilter="categorical-filter",r.ApplyRangeFilter="range-filter",r.ApplyRelativeDateFilter="apply-relative-date-Filter",r.Authenticate="authenticate",r.BlockExtension="block-extension",r.ChangeParameterValue="change-parameter-value",r.ChangeSharedFilter="change-shared-filter",r.ClearFilter="clear-filter",r.ClearSelectedMarks="clear-selected-marks",r.CloseDialog="close-dialog",r.CreateAnnotation="create-annotation",r.DashboardCategoricalFilter="dashboard-categorical-filter",r.DisplayDialog="display-dialog",r.DownloadWorkbook="download-workbook",r.ExecuteExternalMenuItem="execute-external-menu-item",r.ExportCrosstab="export-crosstab",r.ExportCrosstabCsvDownload="export-crosstab-csv-download",r.ExportCrosstabExcelDownload="export-crosstab-excel-download",r.ExportData="export-data",r.ExportDataDownload="export-data-download",r.ExportImage="export-image",r.ExportPdf="export-pdf",r.ExportPdfDownload="export-pdf-download",r.ExportPowerpoint="export-powerpoint",r.ExportPowerpointDownload="export-powerpoint-download",r.FindParameter="find-parameter",r.GetActiveTables="get-active-tables",r.GetAllDataSources="get-all-data-sources",r.GetAnnotations="get-annotations",r.GetCategoricalDomain="get-categorical-domain",r.GetConnectionDescriptionSummaries="get-connection-description-summaries",r.GetCurrentSrc="get-current-src",r.GetCustomViews="get-custom-views",r.GetDashboardFilters="get-dashboard-filters",r.GetDataSource="get-datasource",r.GetDataSourceData="get-datasource-data",r.GetDataSources="get-data-sources",r.GetDataSummaryData="get-summary-data",r.GetDataSummaryDataReader="get-summary-data-reader",r.GetDataTableReaderPage="get-data-table-reader-page",r.GetEmbeddingAbstractQueryWithDataModel="get-embedding-abstract-query-with-data-model",r.GetEmbeddingClientInfo="get-embedding-client-info",r.GetVizStateWithDataModel="get-viz-state-with-data-model",r.GetExportCrosstabSheetMap="get-export-crosstab-sheet-map",r.GetExportPdfOptions="get-export-pdf-options",r.GetField="get-field",r.GetFieldAndDataSource="get-field-and-datasource",r.GetVisualSpecification="get-visual-specification",r.GetFilters="get-filters",r.GetFonts="get-fonts",r.GetHighlightedMarks="get-highlighted-marks",r.GetJoinDescription="get-join-description",r.GetLogicalTableData="get-logical-table-data",r.GetLogicalTableDataReader="get-logical-table-data-reader",r.GetLogicalTables="get-logical-tables",r.GetParametersForSheet="get-parameters-for-sheet",r.GetRangeDomain="get-range-domain",r.GetSelectedMarks="get-selected-marks",r.GetSharedFilter="get-shared-filter",r.GetTooltipText="get-tooltip-text",r.GetUnderlyingData="get-underlying-data",r.GetUnderlyingTableData="get-underlying-table-data",r.GetUnderlyingTableDataReader="get-underlying-table-data-reader",r.GetUnderlyingTables="get-underlying-tables",r.HierarchicalFilter="hierachical-filter",r.InitializeExtension="initialize-extension",r.MoveAndResizeZones="move-and-resize-zones",r.RaiseLeaveMarkNavNotification="raise-leave-mark-nav-notification",r.RaiseHoverTupleNotification="raise-hover-tuple-notification",r.RaiseSelectTuplesNotification="raise-select-tuples-notification",r.Redo="redo",r.RefreshDataSource="refresh-data-source",r.ReleaseDataTableReader="release-data-table-reader",r.RemoveAnnotation="remove-annotation",r.RemoveCustomView="remove-custom-view",r.RemoveExternalMenuItem="remove-external-menu-item",r.RenameExternalMenu="rename-external-menu",r.ReplayAnimation="replay-animation",r.RevertStoryPoint="revert-story-point",r.RevertWorkbook="revert-workbook",r.SaveExtensionSettings="save-extension-settings",r.SaveWorkbookAsCustomView="save-workbook-as-custom-view",r.SelectByValue="select-by-value",r.SetActiveCustomViewAsDefault="set-active-custom-view-as-default",r.SetAutoUpdate="set-auto-update",r.SetClickThrough="set-click-through",r.SetVizStateWithDataModel="set-viz-state-with-data-model",r.SetSheetSize="set-sheet-size",r.SetZoneVisibility="set-zone-visibility",r.Share="share",r.ShowCustomView="show-custom-view",r.TestConversionVerb="test-conversion-verb",r.Undo="undo",r.UpdateCustomView="update-custom-view",r.VizAPI="viz-api"},2496:(e,t)=>{"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),(r=t.AskDataOptionNames||(t.AskDataOptionNames={})).token="token",r.origin="origin",r.showEmbed="showEmbed",r.showPin="showPin",r.showSave="showSave",r.showShare="showShare",r.debug=":jsdebug",r.ApiID=":apiID",r.ApiExternalVersion=":apiExternalVersion",r.ApiInternalVersion=":apiInternalVersion",r.AskDataWebComponent=":askDataWebComponent"},2472:(e,t)=>{"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),(r=t.PulseOptionNames||(t.PulseOptionNames={})).embed="embed",r.token="token",r.disableExploreFilter="disableExploreFilter",r.layout="embed_layout",r.ApiExternalVersion=":apiExternalVersion",r.ApiInternalVersion=":apiInternalVersion",r.PulseWebComponent=":pulseWebComponent"},552:(e,t)=>{"use strict";var r,n,i;Object.defineProperty(t,"__esModule",{value:!0}),function(e){e.ONE="1",e.ALERTS=":alerts",e.ALIAS="alias",e.ALLOW_DEFERRED_BOOTSTRAP=":allowDeferredBootstrap",e.ALLOW_AUTOGEN_WORKSHEET_PHONE_LAYOUTS="allowAutogenWorksheetPhoneLayouts",e.API_ID=":apiID",e.APP=":app",e.ATTACHMENT="attachment",e.IS_IPAD_APP="app",e.ANIMATE_TRANSITION=":animate_transition",e.ASCENDING="ascending",e.AUTHENTICATION="authentication",e.ATTRIBUTES="attributes",e.AUTHORING_SHEET=":authSheet",e.AXIS="axis",e.BOOTSTRAP_WHEN_NOTIFIED=":bootstrapWhenNotified",e.BROWSER_BACK_BUTTON_UNDO=":browserBackButtonUndo",e.BROWSER_RENDERING_ON="isBrowserRendering",e.BROWSER_RENDERING_THRESHOLD="browserRenderingThreshold",e.CHARSET="charset",e.CLIENT_DIMENSION="clientDimension",e.CLIENT_IP="client_ip",e.CLIENT_NUM="clientNum",e.COLON_EMBEDDED=":embedded",e.COLON_MOBILE=":mobile",e.COLON_DEEP_LINKING_DISABLED=":deepLinkingDisabled",e.COLON_WATERMARK=":watermark",e.COMMENTS=":comments",e.COMMENTING_ENABLED=":commentingEnabled",e.COMMENTING_MENTIONS_ENABLED=":commentingMentions",e.CONNECTION="connection",e.CREATED_BY_FEATURE="createdByFeature",e.CRYPTED_PASSWORD="crypted",e.CSSDEBUG=":cssdebug",e.CSV="csv",e.CUSTOM_VIEWS=":customViews",e.CV=":cv",e.CV_ID="cvId",e.DASHBOARD_PORT_SIZE="dashboardPortSize",e.DATA_DETAILS=":dataDetails",e.DATASOURCE="datasource",e.DEBUG=":debug",e.DELAY=":delay",e.DEPTH="depth",e.DEVICE_TYPE=":device",e.DEVICE_PIXEL_RATIO="devicePixelRatio",e.DEVICE_PREVIEW_MODE=":devicepreviewmode",e.DIMENSIONS=":dimensions",e.DISABLE_SHARED_SESSIONS=":disable_shared_sessions",e.DISABLE_URL_ACTIONS_POPUPS=":disableUrlActionsPopups",e.DIRECTION="direction",e.DISPLAY_OVERLAY=":display_overlay",e.DISPLAY_SHARE=":display_share",e.DISPLAY_SPINNER=":display_spinner",e.DISPLAY_STATIC_IMAGE=":display_static_image",e.DISPLAY_TABS="display_tabs",e.DISPLAY_VIEW_COUNT=":display_count",e.IGNORE_STICKY_SESSION=":ignore_sticky_session",e.INCREMENT_VIEW_COUNT=":increment_view_count",e.DOCMODE="docmode",e.DOMAIN="domain",e.DO_WORK="do_work",e.DX="dx",e.DY="dy",e.EDIT_DATA_ALERT=":editDataAlert",e.EMBED=":embed",e.EMBEDDED="embedded",e.ENCRYPTED="encrypted",e.API_EXTERNAL_VERSION=":apiExternalVersion",e.API_INTERNAL_VERSION=":apiInternalVersion",e.EXCLUDE="exclude",e.EXPORT_FORMAT=":export_format",e.FIELDNAME="fieldname",e.FIELD_NAME="field_name",e.FIELD_SEP="field_sep",e.FILE="file",e.FILTER_TILE_SIZE="filterTileSize",e.FN="fn",e.FOCUS="focus",e.FORCE_CACHE="force_cache",e.FORMAT="format",e.FORMAT_DATA_VALUE_LOCALLY="formatDataValueLocally",e.FROM_WG=":from_wg",e.GRAPHQL_DATABASE_ID=":graphQLDatabaseId",e.GRAPHQL_TABLE_ID=":graphQLTableId",e.GUID=":guid",e.H="h",e.HIDDEN="hidden",e.HIDE_CLOSE_BUTTON=":hideCloseButton",e.HIDE_EDIT_BUTTON=":hideEditButton",e.HIDE_EDIT_IN_DESKTOP_BUTTON=":hideEditInDesktopButton",e.HIGH_DPI=":highdpi",e.IMAGE_SIZE_LIMIT="imageSizeLimit",e.TRANSPARENT_LINE_MARKS_LIMIT="transparentLineMarkLimit",e.CLIENT_RENDER_PIXEL_LIMIT="clientRenderPixelLimit",e.IN="in",e.INSTANCE_ID=":iid",e.IS_GUEST_REDIRECT_FROM_VIZPORTAL=":isGuestRedirectFromVizportal",e.IS_MARK_ANIMATION_ENABLED="isMarkAnimationEnabled",e.IS_VIZPORTAL=":isVizPortal",e.INPUT_="input_string",e.JSDEBUG=":jsdebug",e.JSON="json",e.JSON_ONLY=":jsonOnly",e.KEEPFILE="keepfile",e.KEY="key",e.LANGUAGE="language",e.LANGUAGE_REQUESTED=":language",e.LINKTARGET=":linktarget",e.LOAD_ORDER_ID=":loadOrderID",e.LOAD_NEWEST_REVISION=":loadNewestRevision",e.LOCAL_PATHS=":localPaths",e.LOCALE="locale",e.LOCATION_ID="locationid",e.LOCATION_TYPE="locationtype",e.WORKBOOK_LOCALE="workbookLocale",e.MAXROWS="maxrows",e.MAX_AGE="maxAge",e.MAX_ROWS="maxRows",e.METHOD="method",e.MOBILE="mobile",e.MODIFIER="modifier",e.NAME="name",e.NAV_TYPE="navType",e.NAV_SRC="navSrc",e.NOATTACHMENT="no-attachment",e.NO_OVERWRITE="no_overwrite",e.OPEN_AUTHORING_IN_TOP_WINDOW=":openAuthoringInTopWindow",e.OPENID_HD=":openid_hd",e.OPENID_LOGIN_HINT=":openid_login_hint",e.OAUTHREQUEST="oauthrequest",e.OAUTH_CREDENTIAL_IDS="oauth_credential_ids",e.OFFLINE_MODE=":offlinemode",e.ORIGIN=":origin",e.OVERLAY=":overlay",e.P="p",e.PATH="path",e.PANE_RESOLVER_X="paneResolverX",e.PANE_RESOLVER_Y="paneResolverY",e.PARAM="param",e.PARENT_ID="parent_id",e.PASSWORD="password",e.PATTERN="pattern",e.PIXEL_RATIO=":pixelratio",e.PREFIX=":prefix",e.PREVIEW=":preview",e.PRIMARY_CONTENT_URL="primary_content_url",e.PROJECT="project",e.PROTOCOL="protocol",e.PSEUDO=":pseudo",e.QUERY="query",e.R="r",e.RANGE_TYPE="range_type",e.RECORD_SEP="record_sep",e.RECORD_CLIENT_PERFORMANCE=":record_client_performance",e.RECORD_PERFORMANCE=":record_performance",e.RECOVER_OLD_SESSION_ID=":recover_old_session_id",e.RECOVER_SESSION_STATE_TICKETS=":recover_session_state_tickets",e.REFRESH=":refresh",e.REFRESHUNMODIFIED=":refreshunmodified",e.REGION="region",e.RELOAD_ON_CUSTOM_VIEW_SAVE=":reloadOnCustomViewSave",e.RENDER=":render",e.RENDER_MAPS_CLIENT_SIDE="renderMapsClientSide",e.RETRY=":retry",e.REUSE="reuse",e.REUSE_FOREVER="reuse_forever",e.REVERT=":revert",e.SAVE_DB_PASSWORDS="save_db_passwords",e.SELECT_X="select_x",e.SELECT_Y="select_y",e.SESSION_FEATURE_PREFIX=":ff_",e.SESSION_FLAGS=":session_feature_flags",e.SHARE_BUTTON="share_button",e.SHEET_ID="sheet_id",e.SHARED="shared",e.SHOWALL="showall",e.SHOW_APP_BANNER=":showAppBanner",e.SHOW_ASK_DATA=":showAskData",e.SHOW_PARAMS="showParams",e.SHOW_SHARE_OPTIONS=":showShareOptions",e.SIZE=":size",e.SOURCE="source",e.STATE="state",e.STICKY_SESSION_KEY="stickySessionKey",e.SUBSCRIPTIONS=":subscriptions",e.SUMMARY="summary",e.SUPPRESS_DEFAULT_EDIT_BEHAVIOR=":suppressDefaultEditBehavior",e.SYNC_SESSION=":sync_session",e.SYNC_SESSION_STATE="sync_session_state",e.TABS=":tabs",e.TARGET="target",e.TARGET_SITE="target_site",e.TOOLBAR=":toolbar",e.TOOLTIP=":tooltip",e.TS="ts",e.UNDERLYING_TABLE_ID="underlying_table_id",e.UNDERLYING_TABLE_CAPTION="underlying_table_caption",e.UPDATE_TYPE="update_type",e.USE_GUEST=":useGuest",e.USE_INLINE_IMAGES="use_inline_images",e.USERAGENT="useragent",e.USERNAME="username",e.VALUE="value",e.VERBOSE_MODE="verboseMode",e.VIEW_ID="views_id",e.VIZ_SNAPSHOT_ID="viz_snapshot_id",e.VW=":vw",e.W="w",e.WORKSHEET_PORT_SIZE="worksheetPortSize",e.WATERMARK="watermark",e.WATERMARK_MARGIN=":watermark_margin",e.WB=":wb",e.WHICH="which",e.X="x",e.Y="y",e.ZID="zid",e.ZONE_ID="zone_id",e.KEYCHAIN_VERSION="keychain_version",e.DATASOURCE_ID="datasource_id",e.DATASOURCE_NAME="datasource_name",e.LENS_ID="lens_id",e.WIDTH="width",e.HEIGHT="height",e.LAYOUT_VIEWS="views",e.LAYOUT_MENUS="menus",e.LAYOUT_GEOMETRY="geometry",e.LAYOUT_PAGES="pages",e.LAYOUT_CACHEURL="cacheurl",e.LAYOUT_SHEET="sheet",e.LAYOUT_DEPTH="depth"}(r||(r={})),function(e){e.SHOW_VIZ_HOME=":showVizHome"}(n||(n={})),(i=t.VizOptionNames||(t.VizOptionNames={})).Size=":size",i.Embed=":embed",i.ApiInternalVersion=":apiInternalVersion",i.ApiExternalVersion=":apiExternalVersion",i.ShowVizHome=":showVizHome",i.Jsdebug=":jsdebug",i.BootstrapWhenNotified=":bootstrapWhenNotified",i.NavType="navType",i.NavSrc="navSrc",i.debug=":jsdebug",i.ApiID=":apiID",i.disableUrlActionsPopups=":disableUrlActionsPopups",i.hideTabs=":tabs",i.toolbar=":toolbar",i.device=":device",i.instanceIdToClone=":iid",i.touchOptimize="mobile",i.hideEditButton=":hideEditButton",i.hideEditInDesktopButton=":hideEditInDesktopButton",i.suppressDefaultEditBehavior=":suppressDefaultEditBehavior",i.hideCloseButton=":hideCloseButton"},3256:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(1808),i=r(3448),o=r(1680),a=r(4020),s=r(7204),u=function(){function e(e,t,r){this.thisWindow=e,this.otherWindow=t,this.otherWindowOrigin=r}return e.prototype.startListening=function(){var e=this;if(!this.unregisterFunction){var t=this.onMessageReceived.bind(this);this.thisWindow.addEventListener("message",t,!0),this.unregisterFunction=function(){return e.thisWindow.removeEventListener("message",t,!0)}}},e.prototype.stopListening=function(){this.unregisterFunction&&(this.unregisterFunction(),this.unregisterFunction=void 0)},e.prototype.setInitializeMessageHandler=function(e){this.initializeMessageHandler=e},e.prototype.setCommandResponseMessageHandler=function(e){this.commandResponseMessageHandler=e},e.prototype.setCommandMessageHandler=function(e){this.commandMessageHandler=e},e.prototype.setNotificationMessageHandler=function(e){this.notificationMessageHandler=e},e.prototype.setHandshakeMessageHandler=function(e){this.handshakeMessageHandler=e},e.prototype.prepareInitializationMessage=function(e,t,r){var i={msgGuid:n.raw(),msgType:s.MessageType.Initialize,crossFrameVersion:t,apiVersion:e,options:r};return this.prepareMessage(i)},e.prototype.prepareCommandMessage=function(e,t){var r={msgGuid:n.raw(),msgType:s.MessageType.Command,verbId:e,parameters:t};return this.prepareMessage(r)},e.prototype.prepareCommandResponseMessage=function(e,t,r){var i={msgGuid:n.raw(),msgType:s.MessageType.CommandResponse,commandGuid:e,data:t,error:r};return r&&(i.error=JSON.parse(JSON.stringify(r))),this.prepareMessage(i)},e.prototype.prepareNotificationMessage=function(e,t){var r={msgGuid:n.raw(),msgType:s.MessageType.Notification,notificationId:e,data:t};return this.prepareMessage(r)},e.prototype.prepareAckMessage=function(){var e={msgGuid:n.raw(),msgType:s.MessageType.Ack,platformVersion:i.INTERNAL_CONTRACT_VERSION};return this.prepareMessage(e)},e.prototype.prepareMessage=function(e){if(!this.otherWindow||!this.otherWindowOrigin)throw"Other window not initialized, cannot dispatch messages";return new o.CrossFramePreparedMessage(e,this.otherWindow,this.otherWindowOrigin)},e.prototype.onMessageReceived=function(e){if((!this.otherWindow||e.source===this.otherWindow)&&e.data){var t=e.data;if(a.isMessage(t))switch(t.msgType){case s.MessageType.Initialize:if(!a.isInitMessage(t)||!this.initializeMessageHandler)return;this.initializeMessageHandler(t,e.source);break;case s.MessageType.CommandResponse:if(!a.isCommandResponseMessage(t)||!this.commandResponseMessageHandler)return;this.commandResponseMessageHandler(t,e.source);break;case s.MessageType.Command:if(!a.isCommandMessage(t)||!this.commandMessageHandler)return;this.commandMessageHandler(t,e.source);break;case s.MessageType.Notification:if(!a.isNotificationMessage(t)||!this.notificationMessageHandler)return;this.notificationMessageHandler(t,e.source);break;case s.MessageType.Handshake:if(!a.isHandshakeMessage(t)||!this.handshakeMessageHandler)return;this.handshakeMessageHandler(t,e.source)}}},e.prototype.setOtherWindow=function(e){this.otherWindow=e},e.prototype.setOtherWindowOrigin=function(e){this.otherWindowOrigin=e},e}();t.CrossFrameMessenger=u},1680:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e,t,r){this._message=e,this._target=t,this._origin=r}return Object.defineProperty(e.prototype,"messageGuid",{get:function(){return this._message.msgGuid},enumerable:!0,configurable:!0}),e.prototype.send=function(){return this._target.postMessage(this._message,this._origin),this},e}();t.CrossFramePreparedMessage=r},4020:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(1808),i=r(5824),o=r(7204),a=new Set([i.NotificationId.EditButtonClicked,i.NotificationId.EditInDesktopButtonClicked,i.NotificationId.WorkbookPublished,i.NotificationId.WorkbookReadyToClose,i.NotificationId.ReadyToReceiveAuthToken]);function s(e){if(!e)return!1;var t=e;return!(!(t&&t.msgGuid&&t.msgType)||!n.isGuid(t.msgGuid)||"string"!=typeof t.msgType||[o.MessageType.Command,o.MessageType.CommandResponse,o.MessageType.Initialize,o.MessageType.Notification,o.MessageType.Handshake].indexOf(t.msgType)<0)}function u(e){if(!e)return!1;var t=e;return"object"==typeof t&&"number"==typeof t.fix&&"number"==typeof t.minor&&"number"==typeof t.major}t.isMessage=s,t.isVersion=u,t.isInitMessage=function(e){if(!s(e))return!1;var t=e;return!!(t.msgType===o.MessageType.Initialize&&t.apiVersion&&u(t.apiVersion)&&t.crossFrameVersion&&u(t.crossFrameVersion))},t.isCommandResponseMessage=function(e){if(!s(e))return!1;var t=e;return!(t.msgType!==o.MessageType.CommandResponse||!n.isGuid(t.commandGuid)||!t.data&&!t.error)},t.isCommandMessage=function(e){if(!s(e))return!1;var t=e;return!(t.msgType!==o.MessageType.Command||!t.parameters||"object"!=typeof t.parameters||!t.verbId||"string"!=typeof t.verbId)},t.isNotificationMessage=function(e){if(!s(e))return!1;var t=e;return!(t.msgType!==o.MessageType.Notification||!t.data&&!a.has(t.notificationId)||!t.notificationId||"string"!=typeof t.notificationId)},t.isHandshakeMessage=function(e){return!!s(e)&&e.msgType===o.MessageType.Handshake}},7204:(e,t)=>{"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),(r=t.MessageType||(t.MessageType={})).Initialize="initialize",r.Notification="notification",r.Command="command",r.CommandResponse="command-response",r.Handshake="v-handshake",r.Ack="v-ack"},9220:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(){}return e.prototype.upgradeExecuteCall=function(e,t){return{verb:e,parameters:t}},e.prototype.downgradeExecuteReturn=function(e){return e},e.prototype.downgradeNotification=function(e){return e},e}();t.IdentityVersionConverter=r},2320:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e,t,r,n,i){if(this._externalMajorVersion=e,this._platformMajorVersion=t,this._upgradeExecuteTranslations=r,this._downgradeExecuteTranslations=n,this._downgradeNotificationTranslations=i,this._externalMajorVersion>this._platformMajorVersion)throw new Error("Cannot convert between external version "+this._externalMajorVersion+" and "+this._platformMajorVersion)}return e.fromData=function(e,t,r,n,i){return new this(e.major,t.major,r,n,i)},e.prototype.upgradeExecuteCall=function(e,t){for(var r={verb:e,parameters:t},n=0,i=this._upgradeExecuteTranslations;n{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(9220),i=r(2320),o=r(720);function a(e,t){return e.major===t.major&&e.minor===t.minor}function s(e,t,r,o,s){var l=e.major,c=e.minor,p=t.major;if(l>p)throw new Error("External version must be less than or equal to platform version.\n externalMajorVersion="+l+" platformMajorVersion="+p);if(a(e,t))return new n.IdentityVersionConverter;var d=u(l,p,c,r),f=u(l,p,c,o),y=u(l,p,c,s);return f.reverse(),y.reverse(),i.StackingVersionConverter.fromData(e,t,d,f,y)}function u(e,t,r,n){for(var i=[],o=e;o<=t;o++)if(o in n)for(var a=o===e?r:0,s=l(Object.keys(n[o])),u=a;u<=s;u++)u in n[o]&&i.push.apply(i,n[o][u]);return i}function l(e){return e.map((function(e){return Number(e)})).reduce((function(e,t){return e>t?e:t}))}t.VersionLessThan=function(e,t){return!(e.major>t.major)&&(e.major{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(5824);t.DowngradeWorksheetNames=function(e){var t=e.result;return void 0!==t.extensionDashboardInfo&&t.extensionDashboardInfo.zones.forEach((function(e){e.sheetInfo&&(e.name=e.sheetInfo.name)})),e},t.DowngradeFlipboardZoneID=function(e){if(e.notificationId===n.NotificationId.SelectedMarksChanged){var t=e.data;void 0===t.flipboardZoneID&&(t.flipboardZoneID=0)}return e}},4528:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(){}return e.prototype.downgradeExecuteCall=function(e,t){return{verb:e,parameters:t}},e.prototype.upgradeExecuteReturn=function(e,t,r){return e},e.prototype.upgradeNotification=function(e){return e},e}();t.ExternalIdentityVersionConverter=r},5768:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e,t,r,n,i){if(this._externalVersion=e,this._platformVersion=t,this._downgradeExecuteCallTranslations=r,this._upgradeExecuteReturnTranslations=n,this._upgradeNotificationTranslations=i,this._externalVersion.major>this._platformVersion.major)throw new Error("Cannot convert between external version "+this._externalVersion.major+"\n and "+this._platformVersion.major)}return e.prototype.downgradeExecuteCall=function(e,t){for(var r={verb:e,parameters:t},n=0,i=this._downgradeExecuteCallTranslations;n{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(3760),i=r(4528),o=r(5768),a=r(2088);function s(e,t,r,a,s){var l=e.major,c=t.major,p=t.minor;if(l>c)throw new Error("External version must be less than or equal to platform version.\n externalMajorVersion="+l+" platformMajorVersion="+c);if(l{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(3448);function i(e){void 0!==e&&void 0!==e.dataTable&&Array.isArray(e.dataTable)&&e.dataTable.forEach((function(t){t.forEach((function(t,r){var i=t.value;null!==i&&(t.value=n.DataTypeConverter.convertValueAsStringToValue(i,e.headers[r].dataType))}))}))}function o(e,t){if(t[n.ParameterId.LogicalTableId]!==n.ApiShowDataTableSentinel.SingleTableId)throw new Error("Invalid logical table id passed to "+e+".")}t.UpgradeDataTableTypes=function(e,t,r){if(!e)return e;var n=e.result;if(void 0!==n.data&&void 0!==n.isSummary)return i(n.data),e;var o=e.result;return void 0!==o.data&&Array.isArray(o.data)?(o.data.forEach((function(e){i(e)})),e):e},t.DowngradeUnderlyingTableDataAsync=function(e,t){return e===n.VerbId.GetUnderlyingTableData&&(o(e,t),e=n.VerbId.GetUnderlyingData),{verb:e,parameters:t}},t.DowngradeLogicalTableDataAsync=function(e,t){return e===n.VerbId.GetLogicalTableData&&(o(e,t),e=n.VerbId.GetDataSourceData),{verb:e,parameters:t}},t.UpgradeDataTableRowsAndColumns=function(e,t,r){return function(e){return e===n.VerbId.GetDataSummaryData}(t)&&r[n.ParameterId.MaxRows]&&(e=function(e,t){var r=e.result;return r.data&&Array.isArray(r.data.dataTable)?(t>0&&t{"use strict";function n(e){for(var r in e)t.hasOwnProperty(r)||(t[r]=e[r])}Object.defineProperty(t,"__esModule",{value:!0});var i=r(2808);t.ApiVersion=i.ApiVersion,n(r(5184));var o=r(8540);t.CrossFrameDispatcher=o.CrossFrameDispatcher;var a=r(8340);t.DataSource=a.DataSource;var s=r(1044);t.ExternalToInternalEnumMappings=s.ExternalToInternalEnumMappings;var u=r(6557);t.InternalToExternalEnumMappings=u.InternalToExternalEnumMappings;var l=r(2680);t.EventListenerManager=l.EventListenerManager;var c=r(1072);t.Field=c.Field;var p=r(2520);t.CustomViewImpl=p.CustomViewImpl;var d=r(1940);t.DashboardImpl=d.DashboardImpl;var f=r(6488);t.DashboardObjectImpl=f.DashboardObjectImpl;var y=r(2180);t.DataSourceImpl=y.DataSourceImpl;var h=r(8552);t.ParameterImpl=h.ParameterImpl;var m=r(8332);t.SheetImpl=m.SheetImpl;var g=r(1116);t.SheetInfoImpl=g.SheetInfoImpl;var v=r(5144);t.SingleEventManagerImpl=v.SingleEventManagerImpl;var b=r(6804);t.StoryImpl=b.StoryImpl;var I=r(2608);t.StoryPointImpl=I.StoryPointImpl;var S=r(6068);t.StoryPointInfoImpl=S.StoryPointInfoImpl;var _=r(3044);t.WorkbookImpl=_.WorkbookImpl;var T=r(6500);t.WorksheetImpl=T.WorksheetImpl;var P=r(3987);t.Point=P.Point,n(r(8672)),n(r(3008));var A=r(1832);t.ClientInfoServiceImpl=A.ClientInfoServiceImpl;var E=r(1288);t.NotificationServiceImpl=E.NotificationServiceImpl;var w=r(6428);t.NotificationServiceImplBase=w.NotificationServiceImplBase,t.Registration=w.Registration;var O=r(1776);t.ServiceImplBase=O.ServiceImplBase;var D=r(4109);t.SizeServiceImpl=D.SizeServiceImpl;var x=r(2248);t.StoryActivationServiceImpl=x.StoryActivationServiceImpl;var F=r(6664);t.TableauError=F.TableauError;var C=r(1724);t.Deferred=C.Deferred;var N=r(7480);t.ErrorHelpers=N.ErrorHelpers;var M=r(5044);t.ExportHelpers=M.ExportHelpers;var k=r(2780);t.SheetUtils=k.SheetUtils;var R=r(1576);t.VersionNumber=R.VersionNumber;var V=r(8648);t.VersionedExternalApiDispatcher=V.VersionedExternalApiDispatcher},2808:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(1576),i=function(){function e(){}return Object.defineProperty(e,"Instance",{get:function(){return e._instance},enumerable:!0,configurable:!0}),e.SetVersionNumber=function(t,r){e._instance=new n.VersionNumber(t,r)},e}();t.ApiVersion=i},716:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._connectionInfo=e}return Object.defineProperty(e.prototype,"name",{get:function(){return this._connectionInfo.name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"id",{get:function(){return this._connectionInfo.id},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"serverURI",{get:function(){return this._connectionInfo.serverURI},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"type",{get:function(){return this._connectionInfo.type},enumerable:!0,configurable:!0}),e}();t.ConnectionSummary=r},5184:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(3448),i=r(8540);t.doCrossFrameBootstrap=function(e,t,r){return new Promise((function(o,a){var s;(s=function(e){try{return e.self!==e.parent}catch(e){return!0}}(e)?e.parent:e.opener)||a("This extension is not running inside an iframe, desktop, or popup window. Initialization failed.");var u=new n.CrossFrameMessenger(e,s,"*"),l=u.prepareInitializationMessage(t,n.MESSAGING_VERSION,r);u.setCommandResponseMessageHandler((function(e){e.commandGuid===l.messageGuid&&o((function(){return new i.CrossFrameDispatcher(u)}))})),u.startListening(),l.send()}))}},8540:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=function(){function e(e){if(this._messenger=e,this._pendingPromises={},this._notificationHandlers=[],!this._messenger)throw"Missing messenger object";this._messenger.setCommandResponseMessageHandler(this.onCommandResponse.bind(this)),this._messenger.setNotificationMessageHandler(this.onNotification.bind(this))}return e.prototype.execute=function(e,t){var r=this,n=this._messenger.prepareCommandMessage(e,t),i=new Promise((function(e,t){r._pendingPromises[n.messageGuid]={resolve:e,reject:t}}));return n.send(),i},e.prototype.registerNotificationHandler=function(e){this._notificationHandlers.push(e)},e.prototype.unregisterNotificationHandler=function(e){this._notificationHandlers=this._notificationHandlers.filter((function(t){return t!==e}))},e.prototype.onCommandResponse=function(e){if(!(Object.keys(this._pendingPromises).indexOf(e.commandGuid)<0)){var t=this._pendingPromises[e.commandGuid];e.error&&t.reject(e.error),e.data&&t.resolve({result:e.data}),delete this._pendingPromises[e.commandGuid]}},e.prototype.onNotification=function(e){for(var t=0,r=this._notificationHandlers;t{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._dataSourceImpl=e}return Object.defineProperty(e.prototype,"name",{get:function(){return this._dataSourceImpl.name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"id",{get:function(){return this._dataSourceImpl.id},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"fields",{get:function(){return this._dataSourceImpl.fields},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"extractUpdateTime",{get:function(){return this._dataSourceImpl.extractUpdateTime},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isExtract",{get:function(){return this._dataSourceImpl.isExtract},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isPublished",{get:function(){return this._dataSourceImpl.isPublished},enumerable:!0,configurable:!0}),e.prototype.publishedUrl=function(){return this._dataSourceImpl.publishedUrl()},e.prototype.refreshAsync=function(){return this._dataSourceImpl.refreshAsync()},e.prototype.getActiveTablesAsync=function(){return console.warn("DataSource.getActiveTablesAsync is deprecated. Please use DataSource.getLogicalTablesAsync."),this._dataSourceImpl.getActiveTablesAsync()},e.prototype.getConnectionSummariesAsync=function(){return this._dataSourceImpl.getConnectionSummariesAsync()},e.prototype.getUnderlyingDataAsync=function(e){return console.warn("DataSource.getUnderlyingDataAsync is deprecated. Please use DataSource.getLogicalTablesAsync and DataSource.getLogicalTableDataAsync."),this._dataSourceImpl.getUnderlyingDataAsync(e)},e.prototype.getLogicalTablesAsync=function(){return this._dataSourceImpl.getLogicalTablesAsync()},e.prototype.getLogicalTableDataAsync=function(e,t){return this._dataSourceImpl.getLogicalTableDataAsync(e,t)},e.prototype.getLogicalTableDataReaderAsync=function(e,t,r){return this._dataSourceImpl.getLogicalTableDataReaderAsync(e,t,r)},e}();t.DataSource=r},1044:(e,t,r)=>{"use strict";var n,i,o,a,s,u,l,c,p,d;Object.defineProperty(t,"__esModule",{value:!0});var f=r(7419),y=r(3448),h=r(5520),m=function(){function e(){}return e.filterDomainType=new h.EnumConverter(((n={})[f.FilterDomainType.Relevant]=y.FilterDomainType.Relevant,n[f.FilterDomainType.Database]=y.FilterDomainType.Database,n)),e.nullOptions=new h.EnumConverter(((i={})[f.FilterNullOption.AllValues]=y.FilterNullOption.AllValues,i[f.FilterNullOption.NonNullValues]=y.FilterNullOption.NonNullValues,i[f.FilterNullOption.NullValues]=y.FilterNullOption.NullValues,i)),e.filterUpdateType=new h.EnumConverter(((o={})[f.FilterUpdateType.Add]=y.FilterUpdateType.Add,o[f.FilterUpdateType.All]=y.FilterUpdateType.All,o[f.FilterUpdateType.Remove]=y.FilterUpdateType.Remove,o[f.FilterUpdateType.Replace]=y.FilterUpdateType.Replace,o)),e.setVisibilityType=new h.EnumConverter(((a={})[f.ZoneVisibilityType.Show]=!0,a[f.ZoneVisibilityType.Hide]=!1,a)),e.setReplaySpeedType=new h.EnumConverter(((s={})[f.ReplaySpeedType.Slow]=2,s[f.ReplaySpeedType.Normal]=1,s[f.ReplaySpeedType.Fast]=.5,s)),e.sheetType=new h.EnumConverter(((u={})[f.SheetType.Dashboard]=y.SheetType.Dashboard,u[f.SheetType.Worksheet]=y.SheetType.Worksheet,u[f.SheetType.Story]=y.SheetType.Story,u)),e.showDataTableFormatType=new h.EnumConverter(((l={})[f.IncludeDataValuesOption.AllValues]=y.ApiShowDataTableFormat.NativeAndFormattedValues,l[f.IncludeDataValuesOption.OnlyNativeValues]=y.ApiShowDataTableFormat.NativeValuesOnly,l[f.IncludeDataValuesOption.OnlyFormattedValues]=y.ApiShowDataTableFormat.FormattedValuesOnly,l)),e.periodType=new h.EnumConverter(((c={})[f.PeriodType.Years]=y.DateStepPeriod.Years,c[f.PeriodType.Quarters]=y.DateStepPeriod.Quarters,c[f.PeriodType.Months]=y.DateStepPeriod.Months,c[f.PeriodType.Weeks]=y.DateStepPeriod.Weeks,c[f.PeriodType.Days]=y.DateStepPeriod.Days,c[f.PeriodType.Hours]=y.DateStepPeriod.Hours,c[f.PeriodType.Minutes]=y.DateStepPeriod.Minutes,c[f.PeriodType.Seconds]=y.DateStepPeriod.Seconds,c)),e.dateRangeType=new h.EnumConverter(((p={})[f.DateRangeType.Last]=y.DateRangeType.Last,p[f.DateRangeType.LastN]=y.DateRangeType.LastN,p[f.DateRangeType.Next]=y.DateRangeType.Next,p[f.DateRangeType.NextN]=y.DateRangeType.NextN,p[f.DateRangeType.Current]=y.DateRangeType.Current,p[f.DateRangeType.ToDate]=y.DateRangeType.ToDate,p)),e.dialogStyles=new h.EnumConverter(((d={})[f.DialogStyle.Window]=y.DialogStyle.Window,d[f.DialogStyle.Modal]=y.DialogStyle.Modal,d[f.DialogStyle.Modeless]=y.DialogStyle.Modeless,d)),e}();t.ExternalToInternalEnumMappings=m},6557:(e,t,r)=>{"use strict";var n,i,o,a,s,u,l,c,p,d,f,y,h,m,g,v,b,I;Object.defineProperty(t,"__esModule",{value:!0});var S=r(7419),_=r(3448),T=r(5520),P=function(){function e(){}return e.extensionContext=new T.EnumConverter(((n={})[_.ExtensionContext.Desktop]=S.ExtensionContext.Desktop,n[_.ExtensionContext.Server]=S.ExtensionContext.Server,n)),e.extensionMode=new T.EnumConverter(((i={})[_.ExtensionMode.Authoring]=S.ExtensionMode.Authoring,i[_.ExtensionMode.Viewing]=S.ExtensionMode.Viewing,i)),e.columnType=new T.EnumConverter(((o={})[_.ColumnType.Continuous]=S.ColumnType.Continuous,o[_.ColumnType.Discrete]=S.ColumnType.Discrete,o[_.ColumnType.Unknown]=S.ColumnType.Unknown,o)),e.fieldAggregationType=new T.EnumConverter(((a={})[_.FieldAggregationType.Attr]=S.FieldAggregationType.Attr,a[_.FieldAggregationType.Avg]=S.FieldAggregationType.Avg,a[_.FieldAggregationType.Collect]=S.FieldAggregationType.Collect,a[_.FieldAggregationType.Count]=S.FieldAggregationType.Count,a[_.FieldAggregationType.Countd]=S.FieldAggregationType.Countd,a[_.FieldAggregationType.Day]=S.FieldAggregationType.Day,a[_.FieldAggregationType.End]=S.FieldAggregationType.End,a[_.FieldAggregationType.Hour]=S.FieldAggregationType.Hour,a[_.FieldAggregationType.InOut]=S.FieldAggregationType.InOut,a[_.FieldAggregationType.Kurtosis]=S.FieldAggregationType.Kurtosis,a[_.FieldAggregationType.Max]=S.FieldAggregationType.Max,a[_.FieldAggregationType.Mdy]=S.FieldAggregationType.Mdy,a[_.FieldAggregationType.Median]=S.FieldAggregationType.Median,a[_.FieldAggregationType.Min]=S.FieldAggregationType.Min,a[_.FieldAggregationType.Minute]=S.FieldAggregationType.Minute,a[_.FieldAggregationType.MonthYear]=S.FieldAggregationType.MonthYear,a[_.FieldAggregationType.None]=S.FieldAggregationType.None,a[_.FieldAggregationType.Qtr]=S.FieldAggregationType.Qtr,a[_.FieldAggregationType.Quart1]=S.FieldAggregationType.Quart1,a[_.FieldAggregationType.Quart3]=S.FieldAggregationType.Quart3,a[_.FieldAggregationType.Second]=S.FieldAggregationType.Second,a[_.FieldAggregationType.Skewness]=S.FieldAggregationType.Skewness,a[_.FieldAggregationType.Stdev]=S.FieldAggregationType.Stdev,a[_.FieldAggregationType.Stdevp]=S.FieldAggregationType.Stdevp,a[_.FieldAggregationType.Sum]=S.FieldAggregationType.Sum,a[_.FieldAggregationType.TruncDay]=S.FieldAggregationType.TruncDay,a[_.FieldAggregationType.TruncHour]=S.FieldAggregationType.TruncHour,a[_.FieldAggregationType.TruncMinute]=S.FieldAggregationType.TruncMinute,a[_.FieldAggregationType.TruncMonth]=S.FieldAggregationType.TruncMonth,a[_.FieldAggregationType.TruncQtr]=S.FieldAggregationType.TruncQtr,a[_.FieldAggregationType.TruncSecond]=S.FieldAggregationType.TruncSecond,a[_.FieldAggregationType.TruncWeek]=S.FieldAggregationType.TruncWeek,a[_.FieldAggregationType.TruncYear]=S.FieldAggregationType.TruncYear,a[_.FieldAggregationType.User]=S.FieldAggregationType.User,a[_.FieldAggregationType.Var]=S.FieldAggregationType.Var,a[_.FieldAggregationType.Varp]=S.FieldAggregationType.Varp,a[_.FieldAggregationType.Week]=S.FieldAggregationType.Week,a[_.FieldAggregationType.Weekday]=S.FieldAggregationType.Weekday,a[_.FieldAggregationType.Year]=S.FieldAggregationType.Year,a)),e.fieldRoleType=new T.EnumConverter(((s={})[_.FieldRoleType.Dimension]=S.FieldRoleType.Dimension,s[_.FieldRoleType.Measure]=S.FieldRoleType.Measure,s[_.FieldRoleType.Unknown]=S.FieldRoleType.Unknown,s)),e.sheetType=new T.EnumConverter(((u={})[_.SheetType.Dashboard]=S.SheetType.Dashboard,u[_.SheetType.Story]=S.SheetType.Story,u[_.SheetType.Worksheet]=S.SheetType.Worksheet,u)),e.dashboardObjectType=new T.EnumConverter(((l={})[_.DashboardObjectType.Extension]=S.DashboardObjectType.Extension,l[_.DashboardObjectType.Blank]=S.DashboardObjectType.Blank,l[_.DashboardObjectType.Image]=S.DashboardObjectType.Image,l[_.DashboardObjectType.Legend]=S.DashboardObjectType.Legend,l[_.DashboardObjectType.PageFilter]=S.DashboardObjectType.PageFilter,l[_.DashboardObjectType.ParameterControl]=S.DashboardObjectType.ParameterControl,l[_.DashboardObjectType.QuickFilter]=S.DashboardObjectType.QuickFilter,l[_.DashboardObjectType.Text]=S.DashboardObjectType.Text,l[_.DashboardObjectType.Title]=S.DashboardObjectType.Title,l[_.DashboardObjectType.WebPage]=S.DashboardObjectType.WebPage,l[_.DashboardObjectType.Worksheet]=S.DashboardObjectType.Worksheet,l)),e.dataType=new T.EnumConverter(((c={})[_.DataType.Bool]=S.DataType.Bool,c[_.DataType.Date]=S.DataType.Date,c[_.DataType.DateTime]=S.DataType.DateTime,c[_.DataType.Float]=S.DataType.Float,c[_.DataType.Int]=S.DataType.Int,c[_.DataType.Spatial]=S.DataType.Spatial,c[_.DataType.String]=S.DataType.String,c)),e.filterUpdateType=new T.EnumConverter(((p={})[_.FilterUpdateType.Add]=S.FilterUpdateType.Add,p[_.FilterUpdateType.All]=S.FilterUpdateType.All,p[_.FilterUpdateType.Remove]=S.FilterUpdateType.Remove,p[_.FilterUpdateType.Replace]=S.FilterUpdateType.Replace,p)),e.allowableValues=new T.EnumConverter(((d={})[_.DomainRestrictionType.All]=S.ParameterValueType.All,d[_.DomainRestrictionType.List]=S.ParameterValueType.List,d[_.DomainRestrictionType.Range]=S.ParameterValueType.Range,d)),e.dateStepPeriod=new T.EnumConverter(((f={})[_.DateStepPeriod.Years]=S.PeriodType.Years,f[_.DateStepPeriod.Quarters]=S.PeriodType.Quarters,f[_.DateStepPeriod.Months]=S.PeriodType.Months,f[_.DateStepPeriod.Weeks]=S.PeriodType.Weeks,f[_.DateStepPeriod.Days]=S.PeriodType.Days,f[_.DateStepPeriod.Hours]=S.PeriodType.Hours,f[_.DateStepPeriod.Minutes]=S.PeriodType.Minutes,f[_.DateStepPeriod.Seconds]=S.PeriodType.Seconds,f)),e.dateRangeType=new T.EnumConverter(((y={})[_.DateRangeType.Current]=S.DateRangeType.Current,y[_.DateRangeType.Last]=S.DateRangeType.Last,y[_.DateRangeType.LastN]=S.DateRangeType.LastN,y[_.DateRangeType.Next]=S.DateRangeType.Next,y[_.DateRangeType.NextN]=S.DateRangeType.NextN,y[_.DateRangeType.ToDate]=S.DateRangeType.ToDate,y)),e.errorCode=new T.EnumConverter(((h={})[_.ErrorCodes.INITIALIZATION_ERROR]=S.ErrorCodes.InternalError,h[_.ErrorCodes.INTERNAL_ERROR]=S.ErrorCodes.InternalError,h[_.ErrorCodes.MISSING_ENUM_MAPPING]=S.ErrorCodes.InternalError,h[_.ErrorCodes.MISSING_PARAMETER]=S.ErrorCodes.InternalError,h[_.ErrorCodes.PERMISSION_DENIED]=S.ErrorCodes.InternalError,h[_.ErrorCodes.PRES_MODEL_PARSING_ERROR]=S.ErrorCodes.InternalError,h[_.ErrorCodes.UNKNOWN_VERB_ID]=S.ErrorCodes.InternalError,h[_.ErrorCodes.VERSION_NOT_CONFIGURED]=S.ErrorCodes.APINotInitialized,h[_.ErrorCodes.VISIBILITY_ERROR]=S.ErrorCodes.VisibilityError,h),S.ErrorCodes.InternalError),e.filterType=new T.EnumConverter(((m={})[_.FilterType.Categorical]=S.FilterType.Categorical,m[_.FilterType.Range]=S.FilterType.Range,m[_.FilterType.RelativeDate]=S.FilterType.RelativeDate,m[_.FilterType.Hierarchical]=S.FilterType.Hierarchical,m)),e.classNameKey=new T.EnumConverter(((g={})["tableau-dashboard-title"]=S.ClassNameKey.DashboardTitle,g["tableau-story-title"]=S.ClassNameKey.StoryTitle,g["tableau-tooltip"]=S.ClassNameKey.Tooltip,g["tableau-worksheet"]=S.ClassNameKey.Worksheet,g["tableau-worksheet-title"]=S.ClassNameKey.WorksheetTitle,g["dashboard-title"]=S.ClassNameKey.DashboardTitle,g["story-title"]=S.ClassNameKey.StoryTitle,g.tooltip=S.ClassNameKey.Tooltip,g.worksheet=S.ClassNameKey.Worksheet,g["worksheet-title"]=S.ClassNameKey.WorksheetTitle,g)),e.hierarchicalLevelSelectionState=new T.EnumConverter(((v={})[_.HierarchicalLevelSelectionState.AllSelected]=S.HierarchicalLevelSelectionState.AllSelected,v[_.HierarchicalLevelSelectionState.NoneSelected]=S.HierarchicalLevelSelectionState.NoneSelected,v[_.HierarchicalLevelSelectionState.SomeSelected]=S.HierarchicalLevelSelectionState.SomeSelected,v[_.HierarchicalLevelSelectionState.UnknownSelected]=S.HierarchicalLevelSelectionState.UnknownSelected,v)),e.annotationType=new T.EnumConverter(((b={})[_.AnnotateEnum.Area]=S.AnnotationType.Area,b[_.AnnotateEnum.Mark]=S.AnnotationType.Mark,b[_.AnnotateEnum.Point]=S.AnnotationType.Point,b)),e.markType=new T.EnumConverter(((I={})[_.MarkType.Area]=S.MarkType.Area,I[_.MarkType.Bar]=S.MarkType.Bar,I[_.MarkType.Circle]=S.MarkType.Circle,I[_.MarkType.GanttBar]=S.MarkType.GanttBar,I[_.MarkType.Heatmap]=S.MarkType.Heatmap,I[_.MarkType.Line]=S.MarkType.Line,I[_.MarkType.Map]=S.MarkType.Map,I[_.MarkType.Pie]=S.MarkType.Pie,I[_.MarkType.Polygon]=S.MarkType.Polygon,I[_.MarkType.Shape]=S.MarkType.Shape,I[_.MarkType.Square]=S.MarkType.Square,I[_.MarkType.Text]=S.MarkType.Text,I[_.MarkType.VizExtension]=S.MarkType.VizExtension,I)),e}();t.InternalToExternalEnumMappings=P},2680:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(6664),o=function(){function e(){this._eventListenerManagers={}}return e.prototype.addEventListener=function(e,t){if(!this._eventListenerManagers.hasOwnProperty(e))throw new i.TableauError(n.ErrorCodes.UnsupportedEventName,"Cannot add event, unsupported event type: "+e);return this._eventListenerManagers[e].addEventListener(t)},e.prototype.removeEventListener=function(e,t){if(!this._eventListenerManagers.hasOwnProperty(e))throw new i.TableauError(n.ErrorCodes.UnsupportedEventName,"Cannot remove event, unsupported event type: "+e);return this._eventListenerManagers[e].removeEventListener(t)},e.prototype.addNewEventType=function(e){this._eventListenerManagers[e.eventType]=e},e}();t.EventListenerManager=o},1072:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._fieldImpl=e}return Object.defineProperty(e.prototype,"name",{get:function(){return this._fieldImpl.name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"id",{get:function(){return this._fieldImpl.id},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"description",{get:function(){return this._fieldImpl.description},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"dataType",{get:function(){return this._fieldImpl.dataType},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"aggregation",{get:function(){return this._fieldImpl.aggregation},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"dataSource",{get:function(){return this._fieldImpl.dataSource},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"role",{get:function(){return this._fieldImpl.role},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"columnType",{get:function(){return this._fieldImpl.columnType},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isCalculatedField",{get:function(){return this._fieldImpl.isCalculatedField},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isCombinedField",{get:function(){return this._fieldImpl.isCombinedField},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isGenerated",{get:function(){return this._fieldImpl.isGenerated},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isGeospatial",{get:function(){return this._fieldImpl.isGeospatial},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isHidden",{get:function(){return this._fieldImpl.isHidden},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isPresentOnPublishedDatasource",{get:function(){return this._fieldImpl.isPresentOnPublishedDatasource},enumerable:!0,configurable:!0}),e}();t.Field=r},2520:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(5136),i=function(){function e(e,t){this._registryId=t,this._luid=e.luid,this._name=e.name,this._shared=e.shared,this._isDefault=e.isDefault,this._ownerName=e.owner.userFriendlyName,this._url=e.url}return Object.defineProperty(e.prototype,"luid",{get:function(){return this._luid},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"name",{get:function(){return this._name},set:function(e){this._name=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"shared",{get:function(){return this._shared},set:function(e){this._shared=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isDefault",{get:function(){return this._isDefault},set:function(e){this._isDefault=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"ownerName",{get:function(){return this._ownerName},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"url",{get:function(){return this._url},enumerable:!0,configurable:!0}),e.prototype.saveAsync=function(){return n.ApiServiceRegistry.get(this._registryId).getService("viz-service").saveAsync(this)},e}();t.CustomViewImpl=i},1940:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(7419),s=r(3448),u=r(6557),l=r(3987),c=r(3008),p=r(6664),d=r(7480),f=r(6488),y=r(8332),h=r(1116),m=r(6500),g=function(e){function t(t,r,n,i,o,a){void 0===a&&(a=0);var s=e.call(this,t,i)||this;return s._zones=r,s._sheetPath=n,s._parentStoryPointImpl=o,s._activeDashboardObjectId=a,s}return i(t,e),Object.defineProperty(t.prototype,"worksheetsImpl",{get:function(){return this._worksheetsImpl},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"objects",{get:function(){return this._objects},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"parentStoryPoint",{get:function(){return this._parentStoryPointImpl},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"activeDashboardObjectId",{get:function(){return this._activeDashboardObjectId},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"activeDashboardName",{get:function(){return this._sheetPath.sheetName},enumerable:!0,configurable:!0}),t.prototype.initializeWithPublicInterfaces=function(){this._worksheetsImpl=new Array,this._objects=new Array,this.zoneMap=new Map;for(var e=0,t=this._zones;e{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e,t,r,n,i,o,a,s,u,l){this._dashboardImpl=e,this._type=t,this._position=r,this._size=n,this._worksheetImpl=i,this._name=o,this._isFloating=a,this._isVisible=s,this._id=u,this._fieldId=l}return Object.defineProperty(e.prototype,"dashboardImpl",{get:function(){return this._dashboardImpl},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"type",{get:function(){return this._type},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"position",{get:function(){return this._position},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"size",{get:function(){return this._size},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"worksheetImpl",{get:function(){return this._worksheetImpl},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"name",{get:function(){return this._name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isFloating",{get:function(){return this._isFloating},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isVisible",{get:function(){return this._isVisible},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"id",{get:function(){return this._id},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"fieldId",{get:function(){return this._fieldId},enumerable:!0,configurable:!0}),e}();t.DashboardObjectImpl=r},2180:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(716),o=r(1072),a=r(624),s=r(3008),u=r(7603),l=r(7480),c=r(5288),p=function(){function e(e,t){var r=this;this._dataSourceInfo=e,this._registryId=t,this._fields=e.fields.map((function(e){var t=new c.FieldImpl(e,r);return new o.Field(t)}))}return Object.defineProperty(e.prototype,"name",{get:function(){return this._dataSourceInfo.name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"id",{get:function(){return this._dataSourceInfo.id},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"extractUpdateTime",{get:function(){return this._dataSourceInfo.extractUpdateTime},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"fields",{get:function(){return this._fields},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isExtract",{get:function(){return this._dataSourceInfo.isExtract},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isPublished",{get:function(){return this._dataSourceInfo.isPublished},enumerable:!0,configurable:!0}),e.prototype.publishedUrl=function(){return this._dataSourceInfo.publishedUrl},e.prototype.getMaxPageRowLimit=function(){return 1e4},e.prototype.refreshAsync=function(){return s.ApiServiceRegistry.get(this._registryId).getService("data-source-service").refreshAsync(this._dataSourceInfo.id)},e.prototype.getConnectionSummariesAsync=function(){return s.ApiServiceRegistry.get(this._registryId).getService("data-source-service").getConnectionSummariesAsync(this._dataSourceInfo.id).then((function(e){return e.map((function(e){return new i.ConnectionSummary(e)}))}))},e.prototype.getActiveTablesAsync=function(){return s.ApiServiceRegistry.get(this._registryId).getService("data-source-service").getActiveTablesAsync(this._dataSourceInfo.id).then((function(e){return e.map((function(e){return new u.TableSummary(e)}))}))},e.prototype.getUnderlyingDataAsync=function(e){return e=e||{},s.ApiServiceRegistry.get(this._registryId).getService("get-data-service").getDataSourceDataAsync(this.id,!!e.ignoreAliases,e.maxRows||0,e.columnsToInclude||[],e.columnsToIncludeById||[],e.includeDataValuesOption||n.IncludeDataValuesOption.AllValues)},e.prototype.getLogicalTableDataAsync=function(e,t){return t=t||{},s.ApiServiceRegistry.get(this._registryId).getService("get-data-service").getLogicalTableDataAsync(this.id,e,!!t.ignoreAliases,t.maxRows||0,t.columnsToInclude||[],t.columnsToIncludeById||[],t.includeDataValuesOption||n.IncludeDataValuesOption.AllValues)},e.prototype.getLogicalTableDataReaderAsync=function(e,t,r){return r=r||{},s.ApiServiceRegistry.get(this._registryId).getService("get-data-service").getLogicalTableDataReaderAsync(this.id,e,t||this.getMaxPageRowLimit(),!!r.ignoreAliases,r.columnsToIncludeById||[],r.includeDataValuesOption||n.IncludeDataValuesOption.AllValues)},e.prototype.initializeWithPublicInterfaces=function(e){l.ErrorHelpers.verifyInternalValue(e,"dataSource"),this._fields=this._dataSourceInfo.fields.map((function(t){var r=new c.FieldImpl(t,e);return new o.Field(r)}))},e.prototype.getLogicalTablesAsync=function(){return s.ApiServiceRegistry.get(this._registryId).getService("data-source-service").getLogicalTablesAsync(this.id).then((function(e){return e.map((function(e){return new a.LogicalTable(e)}))}))},e}();t.DataSourceImpl=p},5288:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(3448),o=r(6557),a=function(){function e(e,t){this._fieldInfo=e,this._parentDataSource=t}return Object.defineProperty(e.prototype,"name",{get:function(){return this._fieldInfo.name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"id",{get:function(){return this._fieldInfo.id},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"description",{get:function(){return this._fieldInfo.description},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"dataType",{get:function(){var e;return null!=(e=this._fieldInfo.dataType)?e:n.DataType.Unknown},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"aggregation",{get:function(){return o.InternalToExternalEnumMappings.fieldAggregationType.convert(this._fieldInfo.aggregation)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"dataSource",{get:function(){if(!this._parentDataSource)throw new Error("Data source information is not available for this field. Please use getFieldAsync method to get field's data source information");return this._parentDataSource},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"role",{get:function(){return o.InternalToExternalEnumMappings.fieldRoleType.convert(this._fieldInfo.role)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"columnType",{get:function(){var e=this._fieldInfo.columnType||i.ColumnType.Unknown;return o.InternalToExternalEnumMappings.columnType.convert(e)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isCalculatedField",{get:function(){return this._fieldInfo.isCalculatedField},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isCombinedField",{get:function(){return this._fieldInfo.isCombinedField},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isGenerated",{get:function(){return this._fieldInfo.isGenerated},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isGeospatial",{get:function(){return this._fieldInfo.isGeospatial},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isHidden",{get:function(){return this._fieldInfo.isHidden},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isPresentOnPublishedDatasource",{get:function(){return this._fieldInfo.isPresentOnPublishedDatasource},enumerable:!0,configurable:!0}),e}();t.FieldImpl=a},8552:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(6557),o=r(3008),a=r(8052),s=r(7480),u=r(1172),l=function(){function e(e,t){this._registryId=t,this.setParameterInfo(e)}return Object.defineProperty(e.prototype,"name",{get:function(){return this._parameterInfo.name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"currentValue",{get:function(){return a.DataValueFactory.MakeParameterDataValue(this._parameterInfo.currentValue,this._parameterInfo.dataType)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"dataType",{get:function(){return i.InternalToExternalEnumMappings.dataType.convert(this._parameterInfo.dataType)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"id",{get:function(){return this._globalFieldName},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"allowableValues",{get:function(){return this._allowableValues},enumerable:!0,configurable:!0}),e.prototype.changeValueAsync=function(e){var t=this;s.ErrorHelpers.verifyParameter(e,"newValue");var r=u.Param.serializeParameterValue(e);return o.ApiServiceRegistry.get(this._registryId).getService("parameters-service").changeParameterValueAsync(this._globalFieldName,r).then((function(e){return t.setParameterInfo(e),t.currentValue}))},e.prototype.setParameterInfo=function(e){this._parameterInfo=e,this._globalFieldName=e.fieldName;var t,r,o,s,u,l=i.InternalToExternalEnumMappings.allowableValues.convert(e.allowableValuesType);l===n.ParameterValueType.List?t=(e.allowableValues||[]).map((function(t){return a.DataValueFactory.MakeParameterDataValue(t,e.dataType)})):l===n.ParameterValueType.Range&&(r=e.minValue&&a.DataValueFactory.MakeParameterDataValue(e.minValue,e.dataType),o=e.maxValue&&a.DataValueFactory.MakeParameterDataValue(e.maxValue,e.dataType),s=e.stepSize,u=e.dateStepPeriod&&i.InternalToExternalEnumMappings.dateStepPeriod.convert(e.dateStepPeriod)),this._allowableValues={type:l,allowableValues:t,minValue:r,maxValue:o,stepSize:s,dateStepPeriod:u}},e}();t.ParameterImpl=l},8332:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(3008),o=r(6664),a=r(7480),s=r(1172),u=r(2780),l=function(){function e(e,t){this._sheetInfoImpl=e,this._registryId=t}return Object.defineProperty(e.prototype,"name",{get:function(){return this._sheetInfoImpl.name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"sheetType",{get:function(){return this._sheetInfoImpl.sheetType},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"sheetPath",{get:function(){return this._sheetInfoImpl.sheetPath},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"size",{get:function(){return this._sheetInfoImpl.sheetSize},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"hidden",{get:function(){if(void 0!==this._sheetInfoImpl.isHidden)return this._sheetInfoImpl.isHidden;throw new o.TableauError(n.EmbeddingErrorCodes.ImplementationError,"isHidden not implemented")},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"active",{get:function(){if(void 0!==this._sheetInfoImpl.isActive)return this._sheetInfoImpl.isActive;throw new o.TableauError(n.EmbeddingErrorCodes.ImplementationError,"active not implemented")},set:function(e){void 0!==this._sheetInfoImpl.isActive&&(this._sheetInfoImpl.active=e)},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"index",{get:function(){if(void 0!==this._sheetInfoImpl.index)return this._sheetInfoImpl.index;throw new o.TableauError(n.EmbeddingErrorCodes.ImplementationError,"index not implemented")},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"url",{get:function(){if(void 0!==this._sheetInfoImpl.url)return this._sheetInfoImpl.url;throw new o.TableauError(n.EmbeddingErrorCodes.ImplementationError,"url not implemented")},enumerable:!0,configurable:!0}),e.prototype.getSheetSize=function(){if(!u.SheetUtils.isValidSheetSize(this.size))throw new o.TableauError(n.EmbeddingErrorCodes.InternalError,"size is not of type SheetSize");return this.size},e.prototype.findParameterAsync=function(e){return a.ErrorHelpers.verifyParameter(e,"parameterName"),i.ApiServiceRegistry.get(this._registryId).getService("parameters-service").findParameterByNameAsync(e)},e.prototype.getParametersAsync=function(){return i.ApiServiceRegistry.get(this._registryId).getService("parameters-service").getParametersForSheetAsync(this.sheetPath)},e.prototype.changeSizeAsync=function(e){var t=this,r=new o.TableauError(n.EmbeddingErrorCodes.InvalidSize,"Invalid sheet size parameter");if(!e||!e.behavior)throw r;var a=this.normalizeSheetSize(e),s=a.behavior===n.SheetSizeBehavior.Automatic;if(!s&&!a.minSize&&!a.maxSize)throw r;if(!s&&this.sheetType===n.SheetType.Worksheet)throw new o.TableauError(n.EmbeddingErrorCodes.InvalidSizeBehaviorOnWorksheet,"Only SheetSizeBehavior.Automatic is allowed on Worksheets");if(s&&this.getSheetSize().behavior===a.behavior)return Promise.resolve(e);var l=this.processNewSize(a);return i.ApiServiceRegistry.get(this._registryId).getService("size-service").changeSizeAsync(this.name,l).then((function(){return i.ApiServiceRegistry.get(t._registryId).getService("client-info-service").getClientInfoAsync().then((function(e){var r=e.publishedSheets.find((function(e){return e.name===t.name}));if(!r)throw new o.TableauError(n.SharedErrorCodes.InternalError,"Can't find sheet with name "+t.name);var i=u.SheetUtils.getSheetSizeFromSizeConstraints(r.sizeConstraint);return t._sheetInfoImpl.sheetSize=i,i}))}))},e.prototype.normalizeSheetSize=function(t){var r=t.behavior;return a.ErrorHelpers.verifyEnumValue(r,n.SheetSizeBehavior,"SheetSizeBehavior"),{behavior:r,minSize:e.parseDimensions(t.minSize),maxSize:e.parseDimensions(t.maxSize)}},e.prototype.processNewSize=function(e){var t,r,i,a,u=e.behavior,l=e.minSize,c=e.maxSize,p=!s.Param.isNullOrUndefined(null===(t=l)||void 0===t?void 0:t.width),d=!s.Param.isNullOrUndefined(null===(r=l)||void 0===r?void 0:r.height),f=!s.Param.isNullOrUndefined(null===(i=c)||void 0===i?void 0:i.width),y=!s.Param.isNullOrUndefined(null===(a=c)||void 0===a?void 0:a.height),h=p&&d,m=f&&y;switch(u){case n.SheetSizeBehavior.Automatic:return{behavior:u};case n.SheetSizeBehavior.AtMost:if(!c||!m)throw new o.TableauError(n.EmbeddingErrorCodes.MissingMaxSize,"Missing maxSize for SheetSizeBehavior.AtMost");if((v={width:c.width,height:c.height}).width<0||v.height<0)throw new o.TableauError(n.EmbeddingErrorCodes.InvalidSize,"Size value cannot be less than zero");return{behavior:u,maxSize:v};case n.SheetSizeBehavior.AtLeast:if(!l||!h)throw new o.TableauError(n.EmbeddingErrorCodes.MissingMinSize,"Missing minSize for SheetSizeBehavior.AtLeast");if((g={width:l.width,height:l.height}).width<0||g.height<0)throw new o.TableauError(n.EmbeddingErrorCodes.InvalidSize,"Size value cannot be less than zero");return{behavior:u,minSize:g};case n.SheetSizeBehavior.Range:if(!(l&&c&&h&&m))throw new o.TableauError(n.EmbeddingErrorCodes.MissingMinMaxSize,"Missing minSize or maxSize for SheetSizeBehavior.Range");var g={width:l.width,height:l.height},v={width:c.width,height:c.height};if(g.width<0||g.height<0||v.width<0||v.height<0||g.width>v.width||g.height>v.height)throw new o.TableauError(n.EmbeddingErrorCodes.InvalidSize,"Missing minSize or maxSize for SheetSizeBehavior.Range");return{behavior:u,minSize:g,maxSize:v};case n.SheetSizeBehavior.Exactly:if(l&&c){if(h&&m){if(g={width:l.width,height:l.height},v={width:c.width,height:c.height},g.width!==v.width||g.height!==v.height)throw new o.TableauError(n.EmbeddingErrorCodes.InvalidSize,"Conflicting size values for SheetSizeBehavior.Exactly");return{behavior:u,minSize:g,maxSize:v}}if(h)return{behavior:u,minSize:g={width:l.width,height:l.height},maxSize:g};if(m)return{behavior:u,minSize:v={width:c.width,height:c.height},maxSize:v}}throw new o.TableauError(n.EmbeddingErrorCodes.InvalidSize,"Invalid sheet size parameter");default:throw new o.TableauError(n.SharedErrorCodes.InternalError,"Unsupported sheet size behavior: "+u)}},e.parseDimensions=function(e){var t={width:void 0,height:void 0};if(!e)return t;var r=s.Param.tryParseNumber(e.width),n=r.success,i=r.parsed,o=s.Param.tryParseNumber(e.height),a=o.success,u=o.parsed;return n&&a?{width:i,height:u}:n?{width:i}:a?{height:u}:t},e}();t.SheetImpl=l},1116:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=function(){function e(e,t,r,n,i,o,a){this._name=e,this._sheetType=t,this._sheetSize=r,this._index=n,this._isActive=i,this._isHidden=o,this._url=a}return Object.defineProperty(e.prototype,"name",{get:function(){return this._name},set:function(e){this._name=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"sheetSize",{get:function(){return this._sheetSize},set:function(e){this._sheetSize=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"sheetType",{get:function(){return this._sheetType},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"sheetPath",{get:function(){return{sheetName:this.name,isDashboard:this.sheetType===n.SheetType.Dashboard}},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"index",{get:function(){return this._index},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isActive",{get:function(){return this._isActive},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"active",{set:function(e){this._isActive=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isHidden",{get:function(){return this._isHidden},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"url",{get:function(){return this._url},enumerable:!0,configurable:!0}),e}();t.SheetInfoImpl=i},5144:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._eventType=e,this._handlers=[]}return Object.defineProperty(e.prototype,"eventType",{get:function(){return this._eventType},enumerable:!0,configurable:!0}),e.prototype.addEventListener=function(e){var t=this;return this._handlers.push(e),function(){return t.removeEventListener(e)}},e.prototype.removeEventListener=function(e){var t=this._handlers.length;return this._handlers=this._handlers.filter((function(t){return t!==e})),t>this._handlers.length},e.prototype.triggerEvent=function(e){for(var t=0,r=this._handlers;t=this._storyPointInfoImpls.length)throw new s.TableauError(o.EmbeddingErrorCodes.IndexOutOfRange,"The index passed to this command is out of range.");if(e===this._activeStoryPointImpl.index)return Promise.resolve(this._activeStoryPointImpl);var t=this._deferred.getNewPromiseOrThrowIfBusy();return a.ApiServiceRegistry.get(this._registryId).getService("story-activation-service").activateStoryPointAsync(e),t},t.prototype.revertStoryPointAsync=function(e){var t=this;if(u.ErrorHelpers.verifyParameter(e,"index"),u.ErrorHelpers.verifyParameterType(e,"number","index"),e<0||e>=this._storyPointInfoImpls.length)throw new s.TableauError(o.EmbeddingErrorCodes.IndexOutOfRange,"The index passed to this command is out of range.");return a.ApiServiceRegistry.get(this._registryId).getService("story-activation-service").revertStoryPointAsync(e).then((function(e){return t.updateStoryInfo(e.index,e),new d.StoryPointInfoImpl(e.caption,e.index,e.storyPointId,!1,e.updated,t)}))},t.prototype.clearPendingPromises=function(){this._deferred&&this._deferred.reject("All pending promises cleared")},t}(c.SheetImpl);t.StoryImpl=f},2608:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(6664),o=r(2780),a=r(1940),s=r(1116),u=r(6500),l=function(){function e(e,t,r,n){this._storyPointInfoImpl=e,n&&(this._containedSheetImpl=this.createContainedSheet(n,t,r))}return Object.defineProperty(e.prototype,"index",{get:function(){return this._storyPointInfoImpl.index},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"caption",{get:function(){return this._storyPointInfoImpl.caption},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"active",{get:function(){return this._storyPointInfoImpl.active},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updated",{get:function(){return this._storyPointInfoImpl.updated},set:function(e){this._storyPointInfoImpl.updated=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"parentStory",{get:function(){return this._storyPointInfoImpl.parentStory},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"containedSheet",{get:function(){return this._containedSheetImpl},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"storyPointId",{get:function(){return this._storyPointInfoImpl.storyPointId},enumerable:!0,configurable:!0}),e.prototype.createContainedSheet=function(e,t,r){var l,c=o.SheetUtils.getPublishedSheetInfoByName(e.name,t),p=o.SheetUtils.createAutomaticSize(),d=void 0===c,f=c?c.url:"",y=new s.SheetInfoImpl(e.name,o.SheetUtils.getSheetTypeEnum(e.sheetType),p,-1,!1,d,f);switch(y.sheetType){case n.SheetType.Worksheet:var h={worksheet:y.name};l=new u.WorksheetImpl(y,r,h,null,this);break;case n.SheetType.Dashboard:var m={sheetName:y.name,isDashboard:!0};l=new a.DashboardImpl(y,e.dashboardZones,m,r,this);break;default:throw new i.TableauError(n.SharedErrorCodes.ServerError,"Invalid SheetType")}return l},e}();t.StoryPointImpl=l},6068:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e,t,r,n,i,o){this._caption=e,this._index=t,this._storyPointId=r,this._active=n,this._updated=i,this._parentStoryImpl=o}return Object.defineProperty(e.prototype,"caption",{get:function(){return this._caption},set:function(e){this._caption=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"index",{get:function(){return this._index},set:function(e){this._index=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"storyPointId",{get:function(){return this._storyPointId},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"active",{get:function(){return this._active},set:function(e){this._active=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"updated",{get:function(){return this._updated},set:function(e){this._updated=e},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"parentStory",{get:function(){return this._parentStoryImpl},enumerable:!0,configurable:!0}),e}();t.StoryPointInfoImpl=r},3044:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});t.WorkbookImpl=function(){}},6500:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(7419),s=r(8340),u=r(624),l=r(3483),c=r(3008),p=r(6664),d=r(7480),f=r(2180),y=function(e){function t(t,r,n,i,o){var a=e.call(this,t,r)||this;return a._visualId=n,a._parentDashboardImpl=i,a._parentStoryPointImpl=o,a}return i(t,e),Object.defineProperty(t.prototype,"parentDashboard",{get:function(){return this._parentDashboardImpl},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"parentStoryPoint",{get:function(){return this._parentStoryPointImpl},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"visualId",{get:function(){return this._visualId},enumerable:!0,configurable:!0}),t.prototype.getMaxPageRowLimit=function(){return 1e4},t.prototype.applyFilterAsync=function(e,t,r,n){return d.ErrorHelpers.verifyEnumValue(r,o.FilterUpdateType,"Contract.FilterUpdateType"),this.verifyActiveSheet(),c.ApiServiceRegistry.get(this._registryId).getService("filter-service").applyFilterAsync(this.visualId,e,t,r,n)},t.prototype.applyRangeFilterAsync=function(e,t){return d.ErrorHelpers.verifyParameter(e,"fieldName"),d.ErrorHelpers.verifyParameter(t,"filterOptions"),t.nullOption?d.ErrorHelpers.verifyEnumValue(t.nullOption,a.FilterNullOption,"FilterNullOption"):d.ErrorHelpers.verifyRangeParamType(t.min,t.max),this.verifyActiveSheet(),c.ApiServiceRegistry.get(this._registryId).getService("filter-service").applyRangeFilterAsync(this.visualId,e,t)},t.prototype.applyHierarchicalFilterAsync=function(e,t,r,n){if(d.ErrorHelpers.verifyParameter(e,"fieldName"),d.ErrorHelpers.verifyParameter(t,"values"),d.ErrorHelpers.verifyEnumValue(r,o.FilterUpdateType,"Contract.FilterUpdateType"),!Array.isArray(t)&&!t.levels)throw new p.TableauError(a.ErrorCodes.InvalidParameter,"values parameter for applyHierarchicalFilterAsync must be an array or contain a levels key");return this.verifyActiveSheet(),c.ApiServiceRegistry.get(this._registryId).getService("filter-service").applyHierarchicalFilterAsync(this.visualId,e,t,r,n)},t.prototype.clearFilterAsync=function(e){return d.ErrorHelpers.verifyParameter(e,"fieldName"),this.verifyActiveSheet(),c.ApiServiceRegistry.get(this._registryId).getService("filter-service").clearFilterAsync(this.visualId,e)},t.prototype.applyRelativeDateFilterAsync=function(e,t){return d.ErrorHelpers.verifyStringParameter(e,"fieldName"),d.ErrorHelpers.verifyParameter(t,"options"),d.ErrorHelpers.verifyEnumValue(t.periodType,a.PeriodType,"PeriodType"),d.ErrorHelpers.verifyEnumValue(t.rangeType,a.DateRangeType,"DateRangeType"),this.verifyActiveSheet(),c.ApiServiceRegistry.get(this._registryId).getService("filter-service").applyRelativeDateFilterAsync(this.visualId,e,t)},t.prototype.getDataSourcesAsync=function(){var e=this;return this.verifyActiveSheet(),c.ApiServiceRegistry.get(this._registryId).getService("data-source-service").getDataSourcesAsync(this.visualId).then((function(t){var r=t,n=r.worksheetDataSchemaMap[e.name],i=[],o=n.primaryDataSource;i.push(e.createDataSourceFromInfo(r.dataSources[o]));for(var a=0,s=n.referencedDataSourceList;a{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._logicalTable=e}return Object.defineProperty(e.prototype,"id",{get:function(){return this._logicalTable.id},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"caption",{get:function(){return this._logicalTable.caption},enumerable:!0,configurable:!0}),e}();t.LogicalTable=r},5064:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});t.TooltipTextRequestModel=function(e,t){this.visualIdPresModel=e,this.tupleId=t}},6296:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3008),s=r(7480),u=function(){function e(e,t,r,n,i){this._worksheetName=e,this._fieldName=t,this._filterType=r,this._fieldId=n,this._registryId=i}return Object.defineProperty(e.prototype,"worksheetName",{get:function(){return this._worksheetName},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"fieldName",{get:function(){return this._fieldName},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"fieldId",{get:function(){return this._fieldId},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"filterType",{get:function(){return this._filterType},enumerable:!0,configurable:!0}),e.prototype.getFieldAsync=function(){return a.ApiServiceRegistry.get(this._registryId).getService("data-source-service").getFieldAsync(this._fieldId)},e.prototype.getAppliedWorksheetsAsync=function(){return a.ApiServiceRegistry.get(this._registryId).getService("filter-service").getAppliedWorksheetsAsync(this._worksheetName,this._fieldId)},e.prototype.setAppliedWorksheetsAsync=function(e){s.ErrorHelpers.verifyParameter(e,"applyToWorksheets");var t=new Set(e);return a.ApiServiceRegistry.get(this._registryId).getService("filter-service").setAppliedWorksheetsAsync(this._worksheetName,this._fieldName,this._fieldId,Array.from(t))},e}();t.Filter=u;var l=function(e){function t(t,r,n,i,o,a,s,u){var l=e.call(this,t,r,i,n,o)||this;return l._appliedValues=a,l._isExcludeMode=s,l._isAllSelected=u,l}return i(t,e),Object.defineProperty(t.prototype,"isAllSelected",{get:function(){return this._isAllSelected},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"appliedValues",{get:function(){return this._appliedValues},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"isExcludeMode",{get:function(){return this._isExcludeMode},enumerable:!0,configurable:!0}),t.prototype.getDomainAsync=function(e){return e||(e=o.FilterDomainType.Relevant),s.ErrorHelpers.verifyEnumValue(e,o.FilterDomainType,"FilterDomainType"),a.ApiServiceRegistry.get(this._registryId).getService("filter-service").getCategoricalDomainAsync(this._worksheetName,this._fieldId,e)},t}(u);t.CategoricalFilter=l;var c=function(){function e(e,t,r){this._value=e,this._hierarchicalPath=t,this._level=r}return Object.defineProperty(e.prototype,"value",{get:function(){return this._value},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"hierarchicalPath",{get:function(){return this._hierarchicalPath},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"level",{get:function(){return this._level},enumerable:!0,configurable:!0}),e}();t.HierarchicalDataValue=c;var p=function(){function e(e,t){this._name=e,this._levelSelectionState=t}return Object.defineProperty(e.prototype,"name",{get:function(){return this._name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"levelSelectionState",{get:function(){return this._levelSelectionState},enumerable:!0,configurable:!0}),e}();t.HierarchicalLevelDetail=p;var d=function(e){function t(t,r,n,i,o,a,s,u,l,c,p){var d=e.call(this,t,r,i,n,o)||this;return d._dimensionName=a,d._hierarchyCaption=s,d._numberOfLevels=u,d._levelDetails=l,d._appliedValues=c,d._isAllSelected=p,d}return i(t,e),t.prototype.getDomainAsync=function(e){throw new Error("Method not implemented.")},Object.defineProperty(t.prototype,"dimensionName",{get:function(){return this._dimensionName},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"hierarchyCaption",{get:function(){return this._hierarchyCaption},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"numberOfLevels",{get:function(){return this._numberOfLevels},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"levelDetails",{get:function(){return this._levelDetails},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"isAllSelected",{get:function(){return this._isAllSelected},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"appliedValues",{get:function(){return this._appliedValues},enumerable:!0,configurable:!0}),t}(u);t.HierarchicalFilter=d;var f=function(e){function t(t,r,n,i,o,a,s,u){var l=e.call(this,t,r,i,n,o)||this;return l._min=a,l._max=s,l._includeNullValues=u,l}return i(t,e),Object.defineProperty(t.prototype,"minValue",{get:function(){return this._min},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"maxValue",{get:function(){return this._max},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"includeNullValues",{get:function(){return this._includeNullValues},enumerable:!0,configurable:!0}),t.prototype.getDomainAsync=function(e){var t=a.ApiServiceRegistry.get(this._registryId).getService("filter-service");return e||(e=o.FilterDomainType.Relevant),s.ErrorHelpers.verifyEnumValue(e,o.FilterDomainType,"FilterDomainType"),t.getRangeDomainAsync(this._worksheetName,this._fieldId,e)},t}(u);t.RangeFilter=f;var y=function(e){function t(t,r,n,i,o,a,s,u,l){var c=e.call(this,t,r,i,n,o)||this;return c._anchorDate=a,c._periodType=s,c._rangeType=u,c._rangeN=l,c}return i(t,e),Object.defineProperty(t.prototype,"anchorDate",{get:function(){return this._anchorDate},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"periodType",{get:function(){return this._periodType},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"rangeType",{get:function(){return this._rangeType},enumerable:!0,configurable:!0}),Object.defineProperty(t.prototype,"rangeN",{get:function(){return this._rangeN},enumerable:!0,configurable:!0}),t}(u);t.RelativeDateFilter=y;var h=function(){function e(e,t){this._values=e,this._domainType=t}return Object.defineProperty(e.prototype,"values",{get:function(){return this._values},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"type",{get:function(){return this._domainType},enumerable:!0,configurable:!0}),e}();t.CategoricalDomain=h;var m=function(){function e(e,t,r){this._min=e,this._max=t,this._domainType=r}return Object.defineProperty(e.prototype,"type",{get:function(){return this._domainType},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"min",{get:function(){return this._min},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"max",{get:function(){return this._max},enumerable:!0,configurable:!0}),e}();t.RangeDomain=m},5068:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e,t,r,n,i,o){this._data=e,this._columns=t,this._totalRowCount=r,this._isTotalRowCountLimited=n,this._isSummaryData=i,this._marksInfo=o,this._name=i?"Summary Data Table":"Underlying Data Table"}return Object.defineProperty(e.prototype,"name",{get:function(){return this._name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"data",{get:function(){return this._data},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"columns",{get:function(){return this._columns},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"marksInfo",{get:function(){return this._marksInfo},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"totalRowCount",{get:function(){return this._totalRowCount},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isTotalRowCountLimited",{get:function(){return this._isTotalRowCountLimited},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isSummaryData",{get:function(){return this._isSummaryData},enumerable:!0,configurable:!0}),e}();t.DataTable=r;var n=function(){function e(e,t,r){this._type=e,this._color=t,this._tupleId=r}return Object.defineProperty(e.prototype,"type",{get:function(){return this._type},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"color",{get:function(){return this._color},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"tupleId",{get:function(){return this._tupleId},enumerable:!0,configurable:!0}),e}();t.MarkInfo=n;var i=function(){function e(e,t,r,n,i){this._fieldName=e,this._fieldId=t,this._dataType=r,this._isReferenced=n,this._index=i}return Object.defineProperty(e.prototype,"fieldName",{get:function(){return this._fieldName},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"fieldId",{get:function(){return this._fieldId},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"dataType",{get:function(){return this._dataType},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"isReferenced",{get:function(){return this._isReferenced},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"index",{get:function(){return this._index},enumerable:!0,configurable:!0}),e}();t.Column=i;var o=function(){function e(e,t,r){this._value=e,this._nativeValue=t,this._formattedValue=r}return Object.defineProperty(e.prototype,"value",{get:function(){return this._value},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"nativeValue",{get:function(){return this._nativeValue},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"formattedValue",{get:function(){return this._formattedValue},enumerable:!0,configurable:!0}),e}();t.DataValue=o},7968:function(e,t,r){"use strict";var n=this&&this.__awaiter||function(e,t,r,n){return new(r||(r=Promise))((function(i,o){function a(e){try{u(n.next(e))}catch(e){o(e)}}function s(e){try{u(n.throw(e))}catch(e){o(e)}}function u(e){var t;e.done?i(e.value):(t=e.value,t instanceof r?t:new r((function(e){e(t)}))).then(a,s)}u((n=n.apply(e,t||[])).next())}))},i=this&&this.__generator||function(e,t){var r,n,i,o,a={label:0,sent:function(){if(1&i[0])throw i[1];return i[1]},trys:[],ops:[]};return o={next:s(0),throw:s(1),return:s(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function s(o){return function(s){return function(o){if(r)throw new TypeError("Generator is already executing.");for(;a;)try{if(r=1,n&&(i=2&o[0]?n.return:o[0]?n.throw||((i=n.return)&&i.call(n),0):n.next)&&!(i=i.call(n,o[1])).done)return i;switch(n=0,i&&(o=[2&o[0],i.value]),o[0]){case 0:case 1:i=o;break;case 4:return a.label++,{value:o[1],done:!1};case 5:a.label++,n=o[1],o=[0];continue;case 7:o=a.ops.pop(),a.trys.pop();continue;default:if(!((i=(i=a.trys).length>0&&i[i.length-1])||6!==o[0]&&2!==o[0])){a=0;continue}if(3===o[0]&&(!i||o[1]>i[0]&&o[1]{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e,t){this._x=e,this._y=t}return Object.defineProperty(e.prototype,"x",{get:function(){return this._x},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"y",{get:function(){return this._y},enumerable:!0,configurable:!0}),e}();t.Point=r},3483:(e,t)=>{"use strict";var r;Object.defineProperty(t,"__esModule",{value:!0}),(r=t.GetDataType||(t.GetDataType={})).Summary="summary",r.Underlying="underlying"},8672:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(3008),i=r(3964),o=r(8028),a=r(1384),s=r(9196),u=r(4924),l=r(3851),c=r(8864),p=r(7712),d=r(1288),f=r(7260),y=r(8784),h=r(4109),m=r(6096),g=r(744),v=r(8856);t.registerAllSharedServices=function(e,t,r){n.ApiServiceRegistry.get(t).registerService(new o.AnimationServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new s.DataSourceServiceImpl(e,t,r)),n.ApiServiceRegistry.get(t).registerService(new u.ExportServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new p.GetDataServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new c.FilterServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new d.NotificationServiceImpl(e)),n.ApiServiceRegistry.get(t).registerService(new f.ParametersServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new y.SelectionServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new a.AnnotationServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new v.ZoneServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new h.SizeServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new m.VisualModelServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new g.VizServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new l.ExternalContextMenuServiceImpl(e,t)),n.ApiServiceRegistry.get(t).registerService(new i.AccessibilityServiceImpl(e,t))}},3008:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(6664);window.__tableauApiServiceRegistry=window.__tableauApiServiceRegistry||{};var o=function(){function e(){this._services={}}return e.prototype.registerService=function(e){this._services[e.serviceName]=e},e.prototype.getService=function(e){if(!this._services.hasOwnProperty(e))throw new i.TableauError(n.ErrorCodes.InternalError,"Service not registered: "+e);return this._services[e]},e}(),a=function(){function e(){}return e.get=function(t){if(window.__tableauApiServiceRegistry&&window.__tableauApiServiceRegistry[t]||e.setInstance(t,new o),!window.__tableauApiServiceRegistry[t])throw new i.TableauError(n.ErrorCodes.InternalError,"Service registry failed");return window.__tableauApiServiceRegistry[t]},e.setInstance=function(e,t){window.__tableauApiServiceRegistry||(window.__tableauApiServiceRegistry={}),window.__tableauApiServiceRegistry[e]=t},e.clearRegistry=function(){window.__tableauApiServiceRegistry={}},e}();t.ApiServiceRegistry=a},3964:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(3448),a=r(5064),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"accessibility"},enumerable:!0,configurable:!0}),t.prototype.getTooltipTextAsync=function(e,t){var r,n=new a.TooltipTextRequestModel(e,t),i=((r={})[o.ParameterId.FunctionName]="getTooltipTextAsync",r[o.ParameterId.TooltipTextRequest]=n,r);return this.execute(o.VerbId.GetTooltipText,i).then((function(e){return e.result}))},t.prototype.leaveMarkNavigationAsync=function(e){var t,r=((t={})[o.ParameterId.FunctionName]="leaveMarkNavigationAsync",t[o.ParameterId.VisualId]=e,t);return this.execute(o.VerbId.RaiseLeaveMarkNavNotification,r).then((function(e){}))},t}(r(1776).ServiceImplBase);t.AccessibilityServiceImpl=s},8028:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(1044),u=r(7480),l=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"animation-service"},enumerable:!0,configurable:!0}),t.prototype.replayAsync=function(e){var t,r=((t={})[a.ParameterId.ReplaySpeed]=1,t);return u.ErrorHelpers.verifyEnumValue(e,o.ReplaySpeedType,"ReplaySpeedType"),r[a.ParameterId.ReplaySpeed]=s.ExternalToInternalEnumMappings.setReplaySpeedType.convert(e),this.execute(a.VerbId.ReplayAnimation,r).then((function(e){}))},t}(r(1776).ServiceImplBase);t.AnimationServiceImpl=l},1384:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(6557),u=r(7104),l=r(6664),c=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"annotation-service"},enumerable:!0,configurable:!0}),t.prototype.annotateMarkAsync=function(e,t,r){var n,i=this.parseMarkSelectionIds([t]),o=""+r+"",s=((n={})[a.ParameterId.FunctionName]="annotateMarkAsync",n[a.ParameterId.VisualId]=e,n[a.ParameterId.AnnotateEnum]=a.AnnotateEnum.Mark,n[a.ParameterId.TargetPoint]={x:0,y:0},n[a.ParameterId.SelectionList]=[i.selection],n[a.ParameterId.FormattedText]=o,n);return this.execute(a.VerbId.CreateAnnotation,s).then((function(e){}))},t.prototype.getAnnotationsAsync=function(e){var t,r=this,n=((t={})[a.ParameterId.FunctionName]="getAnnotationsAsync",t[a.ParameterId.VisualId]=e,t);return this.execute(a.VerbId.GetAnnotations,n).then((function(e){var t=e.result;return r.annotationFilterMap(t)}))},t.prototype.removeAnnotationAsync=function(e,t){var r,n=this.parseAnnotationSelectionIds([t]),i=((r={})[a.ParameterId.FunctionName]="removeAnnotationAsync",r[a.ParameterId.VisualId]=e,r[a.ParameterId.SelectionList]=[n.selection],r);return this.execute(a.VerbId.RemoveAnnotation,i).then((function(e){}))},t.prototype.parseMarkSelectionIds=function(e){var t=[],r=new u.SelectionModelsContainer;if(e.forEach((function(e){var r=e.tupleId;if(!(null!=r&&r>0))throw new l.TableauError(o.ErrorCodes.InternalError,"invalid tupleId");t.push(r.toString())})),0!==t.length){var n=new u.TupleSelectionModel;n.selectionType="tuples",n.objectIds=t,r.selection=n}return r},t.prototype.parseAnnotationSelectionIds=function(e){var t=[],r=new u.SelectionModelsContainer;if(e.forEach((function(e){var r=e.annotationId;if(!(null!=r&&r>=0))throw new l.TableauError(o.ErrorCodes.InternalError,"invalid annotationId");t.push(r.toString())})),0!==t.length){var n=new u.TupleSelectionModel;n.selectionType="annotations",n.objectIds=t,r.selection=n}return r},t.prototype.mapAnnotation=function(e){return{annotationHTML:e.annotationText,annotationId:e.annotationId,annotationText:e.annotationPlainText,annotationType:s.InternalToExternalEnumMappings.annotationType.convert(e.annotateEnum),tupleId:e.tupleId}},t.prototype.annotationFilterMap=function(e){var t=this;return e.map((function(e){return t.mapAnnotation(e)}))},t}(r(1776).ServiceImplBase);t.AnnotationServiceImpl=c},1832:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(3448),a=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"client-info-service"},enumerable:!0,configurable:!0}),t.prototype.getClientInfoAsync=function(){var e,t=o.VerbId.GetEmbeddingClientInfo,r=((e={})[o.ParameterId.FunctionName]="getClientInfoAsync",e);return this.execute(t,r).then((function(e){return e.result}))},t}(r(1776).ServiceImplBase);t.ClientInfoServiceImpl=a},9196:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(3448),u=r(8340),l=r(1072),c=r(2180),p=r(5288),d=r(6664),f=r(1776);t.SENTINEL_LOGICAL_TABLE_INFO={id:a.ApiShowDataTableSentinel.SingleTableId,caption:a.ApiShowDataTableSentinel.SingleTableCaption};var y={major:1,minor:20,fix:1},h=function(e){function r(t,r,n){void 0===n&&(n=y);var i=e.call(this,t,r)||this;return i._platformVersion=n,i}return i(r,e),Object.defineProperty(r.prototype,"serviceName",{get:function(){return"data-source-service"},enumerable:!0,configurable:!0}),r.prototype.refreshAsync=function(e){var t,r=((t={})[s.ParameterId.FunctionName]="refreshAsync",t[s.ParameterId.DeltaTimeMs]=0,t[s.ParameterId.ShouldRefreshDS]=!0,t);return e&&(r[s.ParameterId.DataSourceId]=e),this.execute(s.VerbId.RefreshDataSource,r).then((function(e){}))},r.prototype.getActiveTablesAsync=function(e){var t,r=((t={})[s.ParameterId.FunctionName]="getActiveTablesAsync",t[s.ParameterId.DataSourceId]=e,t);return this.execute(s.VerbId.GetActiveTables,r).then((function(t){var r=t.result;if(0===r.tables.length)throw new d.TableauError(o.ErrorCodes.UnsupportedMethodForDataSourceType,"getActiveTables is not supported for: "+e);return r.tables}))},r.prototype.getDataSourcesAsync=function(e){var t,r=((t={})[s.ParameterId.FunctionName]="getDataSourcesAsync",t[s.ParameterId.VisualId]=e,t);return this.execute(s.VerbId.GetDataSources,r).then((function(e){return e.result}))},r.prototype.getAllDataSourcesAsync=function(){var e,t=((e={})[s.ParameterId.FunctionName]="getAllDataSourcesAsync",e);return this.execute(s.VerbId.GetAllDataSources,t).then((function(e){return e.result}))},r.prototype.getConnectionSummariesAsync=function(e){var t,r=((t={})[s.ParameterId.FunctionName]="getConnectionSummariesAsync",t[s.ParameterId.DataSourceId]=e,t);return this.execute(s.VerbId.GetConnectionDescriptionSummaries,r).then((function(e){return e.result}))},r.prototype.getFieldAsync=function(e){var t,r=this,n=s.VerbId.GetFieldAndDataSource,i=((t={})[s.ParameterId.FunctionName]="getFieldAsync",t[s.ParameterId.FieldId]=e,t);return this.execute(n,i).then((function(e){var t=e.result[s.ParameterId.DataSource],n=e.result[s.ParameterId.Field];return r.convertField(n,r.convertDataSource(t))}))},r.prototype.getLogicalTablesAsync=function(e){var r;if(!this.isObjectModelSupportedByPlatform())return new Promise((function(e){return e([t.SENTINEL_LOGICAL_TABLE_INFO])}));var n=((r={})[s.ParameterId.FunctionName]="getLogicalTablesAsync",r[s.ParameterId.DataSourceId]=e,r);return this.execute(s.VerbId.GetLogicalTables,n).then((function(e){return e.result}))},r.prototype.getUnderlyingTablesAsync=function(e){var r;if(!this.isObjectModelSupportedByPlatform())return new Promise((function(e){return e([t.SENTINEL_LOGICAL_TABLE_INFO])}));var n=((r={})[s.ParameterId.FunctionName]="getUnderlyingTablesAsync",r[s.ParameterId.VisualId]=e,r);return this.execute(s.VerbId.GetUnderlyingTables,n).then((function(e){return e.result}))},r.prototype.convertField=function(e,t){return new l.Field(new p.FieldImpl(e,t))},r.prototype.convertDataSource=function(e){return new u.DataSource(new c.DataSourceImpl(e,this._registryId))},r.prototype.isObjectModelSupportedByPlatform=function(){return a.VersionLessThan({major:1,minor:13,fix:0},this._platformVersion)},r}(f.ServiceImplBase);t.DataSourceServiceImpl=h},4924:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)}),o=this&&this.__awaiter||function(e,t,r,n){return new(r||(r=Promise))((function(i,o){function a(e){try{u(n.next(e))}catch(e){o(e)}}function s(e){try{u(n.throw(e))}catch(e){o(e)}}function u(e){var t;e.done?i(e.value):(t=e.value,t instanceof r?t:new r((function(e){e(t)}))).then(a,s)}u((n=n.apply(e,t||[])).next())}))},a=this&&this.__generator||function(e,t){var r,n,i,o,a={label:0,sent:function(){if(1&i[0])throw i[1];return i[1]},trys:[],ops:[]};return o={next:s(0),throw:s(1),return:s(2)},"function"==typeof Symbol&&(o[Symbol.iterator]=function(){return this}),o;function s(o){return function(s){return function(o){if(r)throw new TypeError("Generator is already executing.");for(;a;)try{if(r=1,n&&(i=2&o[0]?n.return:o[0]?n.throw||((i=n.return)&&i.call(n),0):n.next)&&!(i=i.call(n,o[1])).done)return i;switch(n=0,i&&(o=[2&o[0],i.value]),o[0]){case 0:case 1:i=o;break;case 4:return a.label++,{value:o[1],done:!1};case 5:a.label++,n=o[1],o=[0];continue;case 7:o=a.ops.pop(),a.trys.pop();continue;default:if(!((i=(i=a.trys).length>0&&i[i.length-1])||6!==o[0]&&2!==o[0])){a=0;continue}if(3===o[0]&&(!i||o[1]>i[0]&&o[1]0&&i[i.length-1])||6!==o[0]&&2!==o[0])){a=0;continue}if(3===o[0]&&(!i||o[1]>i[0]&&o[1]0?s[l.ParameterId.FilterLevels]=u:r.length>0?s[l.ParameterId.FilterValues]=r:s[l.ParameterId.FilterLevels]=[],s[l.ParameterId.FilterUpdateType]=p.ExternalToInternalEnumMappings.filterUpdateType.convert(n),s[l.ParameterId.IsExcludeMode]=i&&!!i.isExcludeMode,this.execute(a,s).then((function(e){return t}))},t.prototype.clearFilterAsync=function(e,t){var r,n=l.VerbId.ClearFilter,i=((r={})[l.ParameterId.FunctionName]="clearFilterAsync",r);return i[l.ParameterId.VisualId]=e,i[l.ParameterId.FieldName]=t,this.execute(n,i).then((function(e){return t}))},t.prototype.applyRelativeDateFilterAsync=function(e,t,r){var n,i=l.VerbId.ApplyRelativeDateFilter,o=((n={})[l.ParameterId.FunctionName]="applyRelativeDateFilterAsync",n);if(o[l.ParameterId.VisualId]=e,o[l.ParameterId.FieldName]=t,o[l.ParameterId.PeriodType]=p.ExternalToInternalEnumMappings.periodType.convert(r.periodType),o[l.ParameterId.DateRangeType]=p.ExternalToInternalEnumMappings.dateRangeType.convert(r.rangeType),r.rangeType===s.DateRangeType.LastN||r.rangeType===s.DateRangeType.NextN){if(void 0===r.rangeN||null===r.rangeN)throw new c.TableauError(s.EmbeddingErrorCodes.MissingRangeNForRelativeDateFilters,"Missing rangeN field for a relative date filter of LASTN or NEXTN.");o[l.ParameterId.RangeN]=r.rangeN}return void 0!==r.anchorDate&&null!==r.anchorDate&&(o[l.ParameterId.AnchorDate]=this.convertAnchorDate(r.anchorDate)),this.execute(i,o).then((function(e){return e.result}))},t.prototype.getFiltersAsync=function(e){var t,r=this,n=l.VerbId.GetFilters,i=((t={})[l.ParameterId.FunctionName]="getFiltersAsync",t);return i[l.ParameterId.VisualId]=e,this.execute(n,i).then((function(e){var t=e.result;return r.convertDomainFilters(t)}))},t.prototype.getCategoricalDomainAsync=function(e,t,r){var n,i=this,o=l.VerbId.GetCategoricalDomain,a=((n={})[l.ParameterId.FunctionName]="getCategoricalDomainAsync",n);return a[l.ParameterId.VisualId]={worksheet:e},a[l.ParameterId.FieldId]=t,a[l.ParameterId.DomainType]=p.ExternalToInternalEnumMappings.filterDomainType.convert(r),this.execute(o,a).then((function(e){var t=e.result;return i.convertCategoricalDomain(t,r)}))},t.prototype.getRangeDomainAsync=function(e,t,r){var n,i=this,o=l.VerbId.GetRangeDomain,a=((n={})[l.ParameterId.FunctionName]="getRangeDomainAsync",n);return a[l.ParameterId.VisualId]={worksheet:e},a[l.ParameterId.FieldId]=t,a[l.ParameterId.DomainType]=p.ExternalToInternalEnumMappings.filterDomainType.convert(r),this.execute(o,a).then((function(e){var t=e.result;return i.convertRangeDomain(t,r)}))},t.prototype.getDashboardFiltersAsync=function(){var e,t=this,r=l.VerbId.GetDashboardFilters,n=((e={})[l.ParameterId.FunctionName]="getDashboardFiltersAsync",e);return this.execute(r,n).then((function(e){var r=e.result;return t.convertDomainFilters(r)}))},t.prototype.applyDashboardFilterAsync=function(e,t,r,n){var i,o=l.VerbId.DashboardCategoricalFilter,a=((i={})[l.ParameterId.FunctionName]="applyDashboardFilterAsync",i);return a[l.ParameterId.FieldName]=e,a[l.ParameterId.FilterValues]=t,a[l.ParameterId.FilterUpdateType]=p.ExternalToInternalEnumMappings.filterUpdateType.convert(r),a[l.ParameterId.IsExcludeMode]=n&&!!n.isExcludeMode,this.execute(o,a).then((function(e){return e.result}))},t.prototype.getAppliedWorksheetsAsync=function(e,t){var r;return o(this,void 0,void 0,(function(){var n,i;return a(this,(function(o){switch(o.label){case 0:return[4,this.executeGetAppliedWorksheets(e,t,"getAppliedWorksheetsAsync")];case 1:return n=o.sent(),i=[],null===(r=n.worksheets)||void 0===r||r.map((function(e){e.isSelected&&i.push(e.worksheetName)})),[2,i]}}))}))},t.prototype.setAppliedWorksheetsAsync=function(e,t,r,n){return o(this,void 0,void 0,(function(){var i,o,u,p,d;return a(this,(function(a){switch(a.label){case 0:return[4,this.executeGetAppliedWorksheets(e,r,"getAppliedWorksheetsAsyncInternal")];case 1:if(!(i=a.sent())||!i.worksheets)throw new c.TableauError(s.SharedErrorCodes.InternalError,"This filter does not apply to multiple worksheets");if(o=[],u="",i.worksheets.forEach((function(e){e.isActive&&(u=e.worksheetName),(e.isSelected||e.isEnabled)&&o.push(e.worksheetName)})),""===u)throw new c.TableauError(s.SharedErrorCodes.InternalError,"No active worksheet");if(!n.includes(u))throw new c.TableauError(s.SharedErrorCodes.InternalError,u+" must be included in the applied worksheets");return n.forEach((function(e){if(!o.includes(e))throw new c.TableauError(s.SharedErrorCodes.InternalError,"The field "+t+" isn't applicable to the worksheet "+e)})),p=l.VerbId.ChangeSharedFilter,(d={})[l.ParameterId.FunctionName]="setAppliedWorksheetsAsync",d[l.ParameterId.VisualId]={worksheet:e},d[l.ParameterId.FieldId]=r,d[l.ParameterId.SharedFilterSheets]=n,[2,this.execute(p,d).then((function(e){return n}))]}}))}))},t.prototype.executeGetAppliedWorksheets=function(e,t,r){var n=l.VerbId.GetSharedFilter,i={};return i[l.ParameterId.FunctionName]=r,i[l.ParameterId.VisualId]={worksheet:e},i[l.ParameterId.FieldId]=t,this.execute(n,i).then((function(e){return e.result}))},t.prototype.convertDomainFilters=function(e){var t=this,r=[];return e.forEach((function(e){switch(e.filterType){case l.FilterType.Categorical:if(!(n=e))throw new Error("Invalid Categorical Filter");r.push(t.convertCategoricalFilter(n));break;case l.FilterType.Hierarchical:if(!(n=e))throw new Error("Invalid Hierarchical Filter");r.push(t.convertHierarchicalFilter(n));break;case l.FilterType.Range:if(!(n=e))throw new Error("Invalid Range Filter");r.push(t.convertRangeFilter(n));break;case l.FilterType.RelativeDate:var n;if(!(n=e))throw new Error("Invalid Relative Date Filter");r.push(t.convertRelativeDateFilter(n))}})),r},t.prototype.convertCategoricalFilter=function(e){var t=e.values.map((function(e){return y.DataValueFactory.MakeFilterDataValue(e)}));return new f.CategoricalFilter(e.visualId.worksheet,e.fieldCaption,e.fieldName,l.FilterType.Categorical,this._registryId,t,e.isExclude,e.isAllSelected)},t.prototype.convertHierarchicalFilter=function(e){var t=e.values.map((function(e){return new f.HierarchicalDataValue(y.DataValueFactory.MakeFilterDataValue(e.value),e.hierarchicalPath,e.level)})),r=e.levelInfo.map((function(e){return new f.HierarchicalLevelDetail(e.name,d.InternalToExternalEnumMappings.hierarchicalLevelSelectionState.convert(e.levelSelectionState))}));return new f.HierarchicalFilter(e.visualId.worksheet,e.fieldCaption,e.fieldName,l.FilterType.Hierarchical,this._registryId,e.dimensionName,e.hierarchyCaption,e.levels,r,t,e.isAllSelected)},t.prototype.convertRangeFilter=function(e){var t=y.DataValueFactory.MakeFilterDataValue(e.min),r=y.DataValueFactory.MakeFilterDataValue(e.max);return new f.RangeFilter(e.visualId.worksheet,e.fieldCaption,e.fieldName,l.FilterType.Range,this._registryId,t,r,e.includeNullValues)},t.prototype.convertRelativeDateFilter=function(e){var t=y.DataValueFactory.MakeFilterDataValue(e.anchorDate);return new f.RelativeDateFilter(e.visualId.worksheet,e.fieldCaption,e.fieldName,s.FilterType.RelativeDate,this._registryId,t,d.InternalToExternalEnumMappings.dateStepPeriod.convert(e.periodType),d.InternalToExternalEnumMappings.dateRangeType.convert(e.rangeType),e.rangeN)},t.prototype.convertCategoricalDomain=function(e,t){var r=e.values.map((function(e){return y.DataValueFactory.MakeFilterDataValue(e)}));return new f.CategoricalDomain(r,t)},t.prototype.convertRangeDomain=function(e,t){var r=y.DataValueFactory.MakeFilterDataValue(e.min),n=y.DataValueFactory.MakeFilterDataValue(e.max);return new f.RangeDomain(r,n,t)},t.prototype.convertAnchorDate=function(e){var t=e.getUTCFullYear(),r=e.getUTCMonth()+1,n=e.getUTCDate(),i=e.getUTCHours(),o=e.getUTCMinutes(),a=e.getUTCSeconds();if(isNaN(t)||isNaN(r)||isNaN(n)||isNaN(i)||isNaN(o)||isNaN(a))throw new c.TableauError(s.EmbeddingErrorCodes.InvalidDateParameter,"Invalid date parameter: anchorDate");return t+"-"+r+"-"+n+" "+i+":"+o+":"+a},t.prototype.apiFilterHandlerCheckForCommandError=function(e){if(e[u.ParameterId.ParameterError]){if(e[u.ParameterId.InvalidFieldCaption])throw new c.TableauError(s.SharedErrorCodes.InvalidFilterFieldName,e[u.ParameterId.InvalidFieldCaption]);if(e[u.ParameterId.InvalidValues])throw new c.TableauError(s.SharedErrorCodes.InvalidFilterFieldValue,e[u.ParameterId.InvalidValues]);if(e[u.ParameterId.InvalidAggFieldName])throw new c.TableauError(s.SharedErrorCodes.InvalidAggregationFieldName,e[u.ParameterId.InvalidAggFieldName]);throw new c.TableauError(s.SharedErrorCodes.ServerError,"Server Error")}},t}(r(1776).ServiceImplBase);t.FilterServiceImpl=m},7712:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(6680),u=r(5136),l=r(1044),c=r(5068),p=r(7968),d=r(8052),f=r(3483),y=function(e){function t(){var t=null!==e&&e.apply(this,arguments)||this;return t.viewDataTableCacheId=s.v4(),t}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"get-data-service"},enumerable:!0,configurable:!0}),t.prototype.getMaxRowLimit=function(){return 1e4},t.prototype.getViewDataTableCacheId=function(){return this.viewDataTableCacheId},t.prototype.getLimitedMaxRows=function(e,t){return e>0&&e{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e,t){this._filterFn=e,this._callbackFn=t}return e.prototype.onNotification=function(e){this._filterFn(e)&&this._callbackFn(e)},e}();t.Registration=r;var n=function(){function e(e){this.dispatcher=e,this._handlers={},this.dispatcher.registerNotificationHandler(this.onNotification.bind(this))}return e.prototype.registerHandler=function(e,t,n){var i=this,o=this._handlers[e]||new Array,a=new r(t,n);return o.push(a),this._handlers[e]=o,function(){return i.removeRegistration(e,a)}},e.prototype.hasHandlersForNotificationType=function(e){return this._handlers.hasOwnProperty(e)},e.prototype.onNotification=function(e){this.hasHandlersForNotificationType(e.notificationId)&&this._handlers[e.notificationId].forEach((function(t){return t.onNotification(e.data)}))},e.prototype.removeRegistration=function(e,t){this.hasHandlersForNotificationType(e)&&(this._handlers[e]=this._handlers[e].filter((function(e){return e!==t})))},e}();t.NotificationServiceImplBase=n},7260:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(8552),u=r(6664),l=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"parameters-service"},enumerable:!0,configurable:!0}),t.prototype.getParametersForSheetAsync=function(e){var t,r=((t={})[a.ParameterId.FunctionName]="getParametersForSheetAsync",t[a.ParameterId.SheetPath]=e,t);return this.getParametersAsync(r)},t.prototype.getAllParametersAsync=function(){var e,t=((e={})[a.ParameterId.FunctionName]="getParametersForSheetAsync",e);return this.getParametersAsync(t)},t.prototype.getParametersAsync=function(e){var t=this;return this.execute(a.VerbId.GetParametersForSheet,e).then((function(e){return e.result.map((function(e){return new s.ParameterImpl(e,t._registryId)}))}))},t.prototype.changeParameterValueAsync=function(e,t){var r,n=((r={})[a.ParameterId.FunctionName]="changeParameterValueAsync",r[a.ParameterId.ParameterFieldName]=e,r[a.ParameterId.ParameterValue]=t,r);return this.execute(a.VerbId.ChangeParameterValue,n).then((function(e){return e.result}))},t.prototype.findParameterByNameAsync=function(e){return this.findParameterAsync(e,void 0)},t.prototype.findParameterByGlobalFieldNameAsync=function(e){return this.findParameterAsync(void 0,e)},t.prototype.findParameterAsync=function(e,t){var r,n=this,i=((r={})[a.ParameterId.FunctionName]="findParameterAsync",r);if(void 0!==e)i[a.ParameterId.ParameterCaption]=e;else{if(void 0===t)throw new u.TableauError(o.ErrorCodes.InvalidParameter,"name or fieldName must be provided to find parameter");i[a.ParameterId.ParameterFieldName]=t}return this.execute(a.VerbId.FindParameter,i).then((function(e){if("fieldName"in e.result){var t=e.result;return new s.ParameterImpl(t,n._registryId)}}))},t}(r(1776).ServiceImplBase);t.ParametersServiceImpl=l},8784:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(7104),u=r(6664),l=r(1172),c=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"selection-service"},enumerable:!0,configurable:!0}),t.prototype.clearSelectedMarksAsync=function(e){var t,r=((t={})[a.ParameterId.FunctionName]="clearSelectedMarksAsync",t[a.ParameterId.VisualId]=e,t);return this.execute(a.VerbId.ClearSelectedMarks,r).then((function(e){}))},t.prototype.selectMarksByValueAsync=function(e,t,r){var n,i=this;if(0===t.length)throw new u.TableauError(o.ErrorCodes.InvalidParameter,"Selection criteria missing for selecting marks by value");var s=this.validateSelectionUpdateType(r),l=this.parseSelectionMarks(t),c=((n={})[a.ParameterId.FunctionName]="selectMarksByValueAsync",n[a.ParameterId.VisualId]=e,n[a.ParameterId.SelectionUpdateType]=s,n);return l.hierModelArr&&l.hierModelArr.length&&(c[a.ParameterId.HierValSelectionModels]=l.hierModelArr),l.quantModelArr&&l.quantModelArr.length&&(c[a.ParameterId.QuantRangeSelectionModels]=l.quantModelArr),l.dimModelArr&&l.dimModelArr.length&&(c[a.ParameterId.DimValSelectionModels]=l.dimModelArr),this.execute(a.VerbId.SelectByValue,c).then((function(e){i.apiFilterHandlerCheckForCommandError(e.result)}))},t.prototype.hoverTupleAsync=function(e,t,r,n){var i,o=new s.HoverTupleInteractionModel(e,this.ensureTupleIDIsNonNegative(t),r,n),u=((i={})[a.ParameterId.FunctionName]="hoverTupleAsync",i[a.ParameterId.HoverTupleInteraction]=o,i);return this.execute(a.VerbId.RaiseHoverTupleNotification,u).then((function(e){}))},t.prototype.selectTuplesAsync=function(e,t,r,n){var i,o=new s.SelectTuplesInteractionModel(e,t,r,n),u=((i={})[a.ParameterId.FunctionName]="selectTuplesAsync",i[a.ParameterId.SelectTuplesInteraction]=o,i);return this.execute(a.VerbId.RaiseSelectTuplesNotification,u).then((function(e){}))},t.prototype.apiFilterHandlerCheckForCommandError=function(e){if(e[a.ParameterId.ParameterError]){if(e[a.ParameterId.InvalidFields])throw new u.TableauError(o.SharedErrorCodes.InvalidSelectionFieldName,e[a.ParameterId.InvalidFields]);if(e[a.ParameterId.InvalidValues])throw new u.TableauError(o.SharedErrorCodes.InvalidSelectionValue,e[a.ParameterId.InvalidValues]);if(e[a.ParameterId.InvalidDates])throw new u.TableauError(o.SharedErrorCodes.InvalidSelectionDate,e[a.ParameterId.InvalidDates])}},t.prototype.selectMarksByIdAsync=function(e,t,r){var n;if(0===t.length)throw new u.TableauError(o.ErrorCodes.InvalidParameter,"Marks info missing for selecting marks by Id");var i=this.validateSelectionUpdateType(r),s=this.parseSelectionIds(t),l=((n={})[a.ParameterId.FunctionName]="selectMarksByIdAsync",n[a.ParameterId.VisualId]=e,n[a.ParameterId.SelectionUpdateType]=i,n[a.ParameterId.Selection]=s.selection,n);return this.execute(a.VerbId.SelectByValue,l).then((function(e){}))},t.prototype.parseSelectionIds=function(e){for(var t=[],r=new s.SelectionModelsContainer,n=0;n0?e:0},t}(r(1776).ServiceImplBase);t.SelectionServiceImpl=c},1776:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(6557),i=r(6664),o=r(5520),a=function(){function e(e,t){this._dispatcher=e,this._registryId=t}return e.prototype.execute=function(e,t){return this._dispatcher.execute(e,t).catch((function(e){var t=e,r=n.InternalToExternalEnumMappings.errorCode.convert(t.errorCode,o.ShouldThrow.No);throw new i.TableauError(r,t.message)}))},e}();t.ServiceImplBase=a},4109:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(3448),a=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"size-service"},enumerable:!0,configurable:!0}),t.prototype.changeSizeAsync=function(e,t){var r,n,i,a,s,u=((r={})[o.ParameterId.FunctionName]="changeSizeAsync",r[o.ParameterId.SheetName]=e,r[o.ParameterId.MinHeight]=(null===(n=t.minSize)||void 0===n?void 0:n.height)||0,r[o.ParameterId.MinWidth]=(null===(i=t.minSize)||void 0===i?void 0:i.width)||0,r[o.ParameterId.MaxHeight]=(null===(a=t.maxSize)||void 0===a?void 0:a.height)||0,r[o.ParameterId.MaxWidth]=(null===(s=t.maxSize)||void 0===s?void 0:s.width)||0,r);return this.execute(o.VerbId.SetSheetSize,u).then((function(e){}))},t}(r(1776).ServiceImplBase);t.SizeServiceImpl=a},2248:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(3448),a=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"story-activation-service"},enumerable:!0,configurable:!0}),t.prototype.activateNextStoryPointAsync=function(){var e,t=o.VerbId.ActivateNextStoryPoint,r=((e={})[o.ParameterId.FunctionName]="activateNextStoryPointAsync",e);return this.execute(t,r).then((function(e){}))},t.prototype.activatePreviousStoryPointAsync=function(){var e,t=o.VerbId.ActivatePreviousStoryPoint,r=((e={})[o.ParameterId.FunctionName]="activatePreviousStoryPointAsync",e);return this.execute(t,r).then((function(e){}))},t.prototype.activateStoryPointAsync=function(e){var t,r=o.VerbId.ActivateStoryPoint,n=((t={})[o.ParameterId.FunctionName]="activateStoryPointAsync",t);return n[o.ParameterId.StoryPointIndex]=e,this.execute(r,n).then((function(e){}))},t.prototype.revertStoryPointAsync=function(e){var t,r=o.VerbId.RevertStoryPoint,n=((t={})[o.ParameterId.FunctionName]="revertStoryPointAsync",t);return n[o.ParameterId.StoryPointIndex]=e,this.execute(r,n).then((function(e){return e.result}))},t}(r(1776).ServiceImplBase);t.StoryActivationServiceImpl=a},6096:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(3448),a=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"visual-model-service"},enumerable:!0,configurable:!0}),t.prototype.getVisualSpecificationAsync=function(e){var t,r=((t={})[o.ParameterId.FunctionName]="getVisualSpecificationAsync",t[o.ParameterId.WorksheetName]=e.worksheet,t);return this.execute(o.VerbId.GetVisualSpecification,r).then((function(e){return e.result}))},t}(r(1776).ServiceImplBase);t.VisualModelServiceImpl=a},744:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(3448),a=r(2520),s=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"viz-service"},enumerable:!0,configurable:!0}),t.prototype.createVizImageAsync=function(e){var t,r=((t={})[o.ParameterId.FunctionName]="createVizImageAsync",t[o.ParameterId.VizAPIInputJson]=JSON.stringify(e),t);return this.execute(o.VerbId.VizAPI,r).then((function(e){return e.result}))},t.prototype.activateSheetAsync=function(e){var t,r=((t={})[o.ParameterId.FunctionName]="activateSheetAsync",t[o.ParameterId.SwitchToSheetName]=e,t);return this.execute(o.VerbId.ActivateSheet,r).then((function(){}))},t.prototype.getCustomViewsAsync=function(){var e,t=this,r=((e={})[o.ParameterId.FunctionName]="getCustomViewsAsync",e);return this.execute(o.VerbId.GetCustomViews,r).then((function(e){return e.result.map((function(e){return new a.CustomViewImpl(e,t._registryId)}))}))},t.prototype.showCustomViewAsync=function(e){var t,r=this,n=((t={})[o.ParameterId.FunctionName]="showCustomViewAsync",t[o.ParameterId.CustomViewName]=e||"",t);return this.execute(o.VerbId.ShowCustomView,n).then((function(e){var t,n=e.result;return(null===(t=n)||void 0===t?void 0:t.luid)?new a.CustomViewImpl(n,r._registryId):void 0}))},t.prototype.removeCustomViewAsync=function(e){var t,r=this,n=((t={})[o.ParameterId.FunctionName]="removeCustomViewAsync",t[o.ParameterId.CustomViewName]=e,t);return this.execute(o.VerbId.RemoveCustomView,n).then((function(e){var t=e.result;return new a.CustomViewImpl(t,r._registryId)}))},t.prototype.saveCustomViewAsync=function(e){var t,r=this,n=((t={})[o.ParameterId.FunctionName]="saveCustomViewAsync",t[o.ParameterId.CustomViewName]=e,t[o.ParameterId.CustomViewIsDefault]=!1,t);return this.execute(o.VerbId.SaveWorkbookAsCustomView,n).then((function(e){var t=e.result;return new a.CustomViewImpl(t,r._registryId)}))},t.prototype.setActiveCustomViewAsDefaultAsync=function(){var e,t=((e={})[o.ParameterId.FunctionName]="setActiveCustomViewAsDefaultAsync",e);return this.execute(o.VerbId.SetActiveCustomViewAsDefault,t).then((function(){}))},t.prototype.saveAsync=function(e){var t,r=this,n=((t={})[o.ParameterId.FunctionName]="saveAsync",t[o.ParameterId.CustomViewLuid]=e.luid,t[o.ParameterId.CustomViewName]=e.name,t[o.ParameterId.CustomViewIsDefault]=e.isDefault,t[o.ParameterId.CustomViewIsPublic]=e.shared,t);return this.execute(o.VerbId.UpdateCustomView,n).then((function(e){var t=e.result;return new a.CustomViewImpl(t,r._registryId)}))},t.prototype.getCurrentSrcAsync=function(){var e,t=((e={})[o.ParameterId.FunctionName]="getCurrentSrcAsync",e);return this.execute(o.VerbId.GetCurrentSrc,t).then((function(e){return e.result}))},t}(r(1776).ServiceImplBase);t.VizServiceImpl=s},8856:function(e,t,r){"use strict";var n,i=this&&this.__extends||(n=function(e,t){return n=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},n(e,t)},function(e,t){function r(){this.constructor=e}n(e,t),e.prototype=null===t?Object.create(t):(r.prototype=t.prototype,new r)});Object.defineProperty(t,"__esModule",{value:!0});var o=r(7419),a=r(3448),s=r(1044),u=r(7480),l=r(1172),c=function(e){function t(){return null!==e&&e.apply(this,arguments)||this}return i(t,e),Object.defineProperty(t.prototype,"serviceName",{get:function(){return"zone-service"},enumerable:!0,configurable:!0}),t.prototype.setVisibilityAsync=function(e,t,r){var n,i=((n={})[a.ParameterId.FunctionName]="setVisibilityAsync",n[a.ParameterId.Dashboard]=e,n[a.ParameterId.ZoneIdsVisibilityMap]={},n);return l.Param.convertParameterToMap(r,"zoneVisibilityMap").forEach((function(e,r){u.ErrorHelpers.verifyZoneIsValid(t,Number.parseInt(r,10)),u.ErrorHelpers.verifyEnumValue(e,o.DashboardObjectVisibilityType,"DashboardObjectVisibilityType"),i[a.ParameterId.ZoneIdsVisibilityMap][r]=s.ExternalToInternalEnumMappings.setVisibilityType.convert(e)})),this.execute(a.VerbId.SetZoneVisibility,i).then((function(e){}))},t.prototype.moveAndResizeAsync=function(e,t,r){var n,i=((n={})[a.ParameterId.Dashboard]=e,n[a.ParameterId.DashboardObjectPositionAndSizeUpdateList]=r,n);return r.forEach((function(e){u.ErrorHelpers.verifyZoneIsValidAndFloating(t,e.dashboardObjectID),u.ErrorHelpers.verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate(e)})),this.execute(a.VerbId.MoveAndResizeZones,i).then((function(e){}))},t}(r(1776).ServiceImplBase);t.ZoneServiceImpl=c},7603:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(e){this._tableInfo=e}return Object.defineProperty(e.prototype,"name",{get:function(){return this._tableInfo.name},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"id",{get:function(){return this._tableInfo.id},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"connectionId",{get:function(){return this._tableInfo.connectionId},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"customSQL",{get:function(){return this._tableInfo.customSQL},enumerable:!0,configurable:!0}),e}();t.TableSummary=r},6664:function(e,t){"use strict";var r,n=this&&this.__extends||(r=function(e,t){return r=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(e,t){e.__proto__=t}||function(e,t){for(var r in t)t.hasOwnProperty(r)&&(e[r]=t[r])},r(e,t)},function(e,t){function n(){this.constructor=e}r(e,t),e.prototype=null===t?Object.create(t):(n.prototype=t.prototype,new n)});Object.defineProperty(t,"__esModule",{value:!0});var i=function(e){function t(r,n){var i=e.call(this,r+": "+n)||this;return i._errorCode=r,Object.setPrototypeOf(i,t.prototype),i}return n(t,e),Object.defineProperty(t.prototype,"errorCode",{get:function(){return this._errorCode},enumerable:!0,configurable:!0}),t}(Error);t.TableauError=i},8052:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(3448),i=r(5068),o=function(){function e(){}return e.MakeParameterDataValue=function(e,t){return new i.DataValue(e.value,n.DataTypeConverter.convertStringValueToNativeValue(e.value,t),e.formattedValue)},e.MakeFilterDataValue=function(e){return new i.DataValue(e.value,e.value,e.formattedValue)},e.MakeTableDataValue=function(e,t){return new i.DataValue(e.value,void 0!==e.value?n.DataTypeConverter.convertValueToNativeValue(e.value,t):void 0,e.formattedValue)},e}();t.DataValueFactory=o},1724:(e,t)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var r=function(){function e(){var e=this;this._promise=new Promise((function(t,r){e._resolve=t,e._reject=r}))}return Object.defineProperty(e.prototype,"promise",{get:function(){return this._promise},enumerable:!0,configurable:!0}),e.prototype.resolve=function(e){this._resolve&&this._resolve(e)},e.prototype.reject=function(e){this._reject&&this._reject(e)},e}();t.Deferred=r,t.UnregisterTimeoutInMilliseconds=3e4},5520:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n,i=r(7419),o=r(6664),a=function(){function e(e,t){this._mappings=e,this._defaultVal=t}return e.prototype.convert=function(e,t){if(void 0===t&&(t=n.Yes),this._mappings.hasOwnProperty(e))return this._mappings[e];if(void 0!==this._defaultVal&&t!==n.Yes)return this._defaultVal;throw new o.TableauError(i.ErrorCodes.InternalError,"Enum Mapping not found for: "+e)},e}();t.EnumConverter=a,function(e){e.Yes="yes",e.No="no"}(n=t.ShouldThrow||(t.ShouldThrow={}))},7480:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(6664),o=r(1172),a=function(){function e(){}return e.apiNotImplemented=function(e){return new i.TableauError(n.SharedErrorCodes.InternalError,e+" API not yet implemented.")},e.verifyInternalValue=function(e,t){if(null==e)throw new i.TableauError(n.SharedErrorCodes.InternalError,e+" is invalid value for: "+t)},e.verifyParameter=function(e,t){if(null==e)throw new i.TableauError(n.SharedErrorCodes.InvalidParameter,e+" is invalid value for parameter: "+t)},e.verifyParameterType=function(e,t,r){if(typeof e!==t)throw new i.TableauError(n.SharedErrorCodes.InvalidParameter,e+" has invalid type for parameter: "+r+".")},e.verifyStringParameter=function(e,t){if(null==e||""===e)throw new i.TableauError(n.SharedErrorCodes.InvalidParameter,e+" is invalid value for paramter: "+t)},e.verifyEnumValue=function(e,t,r){var o=!1;if(Object.keys(t).forEach((function(r){t[r]===e.toString()&&(o=!0)})),!o)throw new i.TableauError(n.SharedErrorCodes.InvalidParameter,e+" is invalid value for enum: "+r+".")},e.verifyRange=function(e,t,r){if(!(t<=e&&e{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(3448),i=r(7419),o=r(6664),a=function(){function e(){}return e.updateInternalExportPDFOptions=function(e,t,r){e.currentSheet=r[0],this.updateExportLayoutOptions(e,t),this.updateSheetOptions(e,r)},e.updateExportLayoutOptions=function(e,t){var r=e.exportLayoutOptions;switch(r.imageHeight=this.DefaultLayoutOptions.imageHeight,r.imageWidth=this.DefaultLayoutOptions.imageWidth,t.orientation){case i.PrintOrientation.Landscape:r.pageOrientationOption=n.PageOrientation.Landscape;break;case i.PrintOrientation.Portrait:r.pageOrientationOption=n.PageOrientation.Portrait;break;default:throw new o.TableauError(i.SharedErrorCodes.InternalError,"invalid orientation for ExportPDFOption")}switch(t.pageSize){case i.PrintPageSize.A3:r.pageSizeOption=n.PageSizeOption.A3;break;case i.PrintPageSize.A4:r.pageSizeOption=n.PageSizeOption.A4;break;case i.PrintPageSize.A5:r.pageSizeOption=n.PageSizeOption.A5;break;case i.PrintPageSize.B4:r.pageSizeOption=n.PageSizeOption.B4;break;case i.PrintPageSize.B5:r.pageSizeOption=n.PageSizeOption.B5;break;case i.PrintPageSize.Executive:r.pageSizeOption=n.PageSizeOption.Executive;break;case i.PrintPageSize.Folio:r.pageSizeOption=n.PageSizeOption.Folio;break;case i.PrintPageSize.Ledger:r.pageSizeOption=n.PageSizeOption.Ledger;break;case i.PrintPageSize.Legal:r.pageSizeOption=n.PageSizeOption.Legal;break;case i.PrintPageSize.Letter:r.pageSizeOption=n.PageSizeOption.Letter;break;case i.PrintPageSize.Note:r.pageSizeOption=n.PageSizeOption.Note;break;case i.PrintPageSize.Quarto:r.pageSizeOption=n.PageSizeOption.Quarto;break;case i.PrintPageSize.Statement:r.pageSizeOption=n.PageSizeOption.Statement;break;case i.PrintPageSize.Tabloid:r.pageSizeOption=n.PageSizeOption.Tabloid;break;case i.PrintPageSize.Unspecified:r.pageSizeOption=n.PageSizeOption.Unspecified;break;default:throw new o.TableauError(i.SharedErrorCodes.InternalError,"invalid pageSize for ExportPDFOption")}switch(t.scaling){case i.PrintScaling.AtMost1PageHigh:this.setFitAndScaleValues(r,n.FitPages.FitOneHigh);break;case i.PrintScaling.AtMost1PageWide:this.setFitAndScaleValues(r,n.FitPages.FitOneWide);break;case i.PrintScaling.AtMost2PagesHigh:this.setFitAndScaleValues(r,n.FitPages.FitTwoHigh);break;case i.PrintScaling.AtMost2PagesWide:this.setFitAndScaleValues(r,n.FitPages.FitTwoWide);break;case i.PrintScaling.Automatic:this.setFitAndScaleValues(r,n.PageScalingOption.ScalePctAuto);break;case i.PrintScaling.Perc100:this.setFitAndScaleValues(r,n.PageScalingOption.ScalePct100);break;case i.PrintScaling.Perc200:this.setFitAndScaleValues(r,n.PageScalingOption.ScalePct200);break;case i.PrintScaling.Perc25:this.setFitAndScaleValues(r,n.PageScalingOption.ScalePct25);break;case i.PrintScaling.Perc400:this.setFitAndScaleValues(r,n.PageScalingOption.ScalePct400);break;case i.PrintScaling.Perc50:this.setFitAndScaleValues(r,n.PageScalingOption.ScalePct50);break;case i.PrintScaling.Perc60:this.setFitAndScaleValues(r,n.PageScalingOption.ScalePct60);break;case i.PrintScaling.Perc75:this.setFitAndScaleValues(r,n.PageScalingOption.ScalePct75);break;case i.PrintScaling.Perc80:this.setFitAndScaleValues(r,n.PageScalingOption.ScalePct80);break;case i.PrintScaling.Perc90:this.setFitAndScaleValues(r,n.PageScalingOption.ScalePct90);break;default:throw new o.TableauError(i.SharedErrorCodes.InternalError,"invalid scaling for ExportPDFOption")}},e.updateSheetOptions=function(e,t){for(var r=e.exportLayoutOptions,n=0,i=e.sheetOptions;n{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(6664),o=r(7480),a=function(){function e(){}return e.serializeDateForPlatform=function(e){return e.getUTCFullYear()+"-"+(e.getUTCMonth()+1)+"-"+e.getUTCDate()+" "+e.getUTCHours()+":"+e.getUTCMinutes()+":"+e.getUTCSeconds()},e.serializeBooleanForPlatform=function(e){return e?"true":"false"},e.serializeNumberForPlatform=function(e){return e.toString(10)},e.isTypeNumber=function(e){return"number"==typeof e||e instanceof Number},e.isTypeDate=function(e){return e instanceof Date},e.isTypeString=function(e){return"string"==typeof e||e instanceof String},e.isTypeBool=function(e){return"boolean"==typeof e||e instanceof Boolean},e.isNullOrUndefined=function(e){return null==e},e.serializeParameterValue=function(t){if(e.isTypeNumber(t))return e.serializeNumberForPlatform(t);if(e.isTypeDate(t))return e.serializeDateForPlatform(t);if(e.isTypeBool(t))return e.serializeBooleanForPlatform(t);if(e.isTypeString(t))return t;throw new i.TableauError(n.ErrorCodes.InternalError,"Unexpected invalid value for: "+t)},e.convertParameterToMap=function(e,t){if(o.ErrorHelpers.verifyParameterType(e,"object",t),Array.isArray(e))throw new i.TableauError(n.ErrorCodes.InvalidParameter,"Expecting object or Map for: "+t+".");return e instanceof Map?e:new Map(Object.entries(e))},e.tryParseNumber=function(t){if(e.isNullOrUndefined(t))return{success:!1};if(e.isTypeNumber(t))return{parsed:t,success:!0};var r=t.toString();if("NaN"===r)return{parsed:NaN,success:!0};var n=parseFloat(r);return isNaN(n)?{success:!1}:{parsed:n,success:!0}},e}();t.Param=a},2780:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(3448),o=r(6664),a=function(){function e(){}return e.getSheetSizeFromSizeConstraints=function(e){var t=e.minWidth,r=e.minHeight,i=e.maxWidth,o=e.maxHeight;if(0===r&&0===t)return 0===o&&0===i?{behavior:n.SheetSizeBehavior.Automatic}:{behavior:n.SheetSizeBehavior.AtMost,maxSize:{width:i,height:o}};if(0===o&&0===i)return{behavior:n.SheetSizeBehavior.AtLeast,minSize:{width:t,height:r}};if(o===r&&i===t&&t>0)return{behavior:n.SheetSizeBehavior.Exactly,minSize:{width:t,height:r},maxSize:{width:t,height:r}};var a=0===t&&0===i;return{behavior:n.SheetSizeBehavior.Range,minSize:{width:t,height:r},maxSize:{width:a?2147483647:i,height:o}}},e.createAutomaticSize=function(){return{behavior:n.SheetSizeBehavior.Automatic,minSize:{width:0,height:0},maxSize:{width:0,height:0}}},e.getPublishedSheetInfoByName=function(e,t){return t.find((function(t){return t.name===e}))},e.getSheetTypeEnum=function(e){var t;switch(e){case i.SheetType.Worksheet:t=n.SheetType.Worksheet;break;case i.SheetType.Dashboard:t=n.SheetType.Dashboard;break;case i.SheetType.Story:t=n.SheetType.Story;break;default:throw new o.TableauError(n.SharedErrorCodes.ServerError,"Invalid SheetType")}return t},e.isValidSheetSize=function(e){return void 0!==e.behavior},e}();t.SheetUtils=a},3036:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(6664),o=r(1724),a=function(){function e(e){void 0===e&&(e=o.UnregisterTimeoutInMilliseconds),this._timeoutInMilliseconds=e}return e.prototype.getNewPromiseOrThrowIfBusy=function(){var e=this;if(this._deferred)throw new i.TableauError(n.SharedErrorCodes.ApiExecutionError,"This api cannot be executed till previous call is resolved.");return this._deferred=new o.Deferred,this._timeoutId=setTimeout((function(){var t=new i.TableauError(n.SharedErrorCodes.Timeout,"Api failed to complete in "+e._timeoutInMilliseconds/1e3+" seconds");e.reject(t)}),this._timeoutInMilliseconds),this._deferred.promise},e.prototype.resolve=function(e){this._deferred&&(clearTimeout(this._timeoutId),this._deferred.resolve(e),this._deferred=void 0)},e.prototype.reject=function(e){this._deferred&&(clearTimeout(this._timeoutId),this._deferred.reject(e),this._deferred=void 0)},e}();t.ShortLivedDeferred=a},1576:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(7419),i=r(6664),o=function(){function e(e,t){var r=e.split("-");this.build=this.getBuildNumber(r[1]);var o=(e=r[0]).split(".").map((function(e){return parseInt(e,10)}));if(3!==o.length)throw new i.TableauError(n.ErrorCodes.InternalError,"Invalid version number: "+e);this.major=o[0],this.minor=o[1],this.fix=o[2],this.isAlpha=t}return e.prototype.getBuildNumber=function(e){if(!e)return-1;var t=e.split(".");return t[1]?parseInt(t[1],10):-1},Object.defineProperty(e.prototype,"formattedValue",{get:function(){return this.major+"."+this.minor+"."+this.fix},enumerable:!0,configurable:!0}),Object.defineProperty(e.prototype,"fullFormattedValue",{get:function(){return this.major+"."+this.minor+"."+this.fix+"-pre."+this.build},enumerable:!0,configurable:!0}),e}();t.VersionNumber=o},8648:(e,t,r)=>{"use strict";Object.defineProperty(t,"__esModule",{value:!0});var n=r(3448),i=function(){function e(e,t){var r=this;this._apiDelegateDispatcher=e,this._versionConverter=n.CreateExternalCompatibleVersionConverter(n.INTERNAL_CONTRACT_VERSION,t),this._notificationHandlers=[],e.registerNotificationHandler((function(e){if(0!==r._notificationHandlers.length){var t=r._versionConverter.upgradeNotification(e);r._notificationHandlers.forEach((function(e){e(t)}))}}))}return e.needsVersionConverter=function(e){return n.VersionLessThan(e,n.INTERNAL_CONTRACT_VERSION)},e.prototype.execute=function(e,t){var r=this;try{var n=this._versionConverter.downgradeExecuteCall(e,t);return this._apiDelegateDispatcher.execute(n.verb,n.parameters).then((function(n){return r._versionConverter.upgradeExecuteReturn(n,e,t)}))}catch(e){return Promise.reject(e)}},e.prototype.registerNotificationHandler=function(e){this._notificationHandlers.push(e)},e.prototype.unregisterNotificationHandler=function(e){this._notificationHandlers=this._notificationHandlers.filter((function(t){return t!==e}))},e}();t.VersionedExternalApiDispatcher=i},6680:(e,t,r)=>{"use strict";var n;r.r(t),r.d(t,{NIL:()=>x,parse:()=>m,stringify:()=>c,v1:()=>h,v3:()=>A,v4:()=>E,v5:()=>D,validate:()=>s,version:()=>F});var i=new Uint8Array(16);function o(){if(!n&&!(n="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)||"undefined"!=typeof msCrypto&&"function"==typeof msCrypto.getRandomValues&&msCrypto.getRandomValues.bind(msCrypto)))throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return n(i)}const a=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i,s=function(e){return"string"==typeof e&&a.test(e)};for(var u=[],l=0;l<256;++l)u.push((l+256).toString(16).substr(1));const c=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,r=(u[e[t+0]]+u[e[t+1]]+u[e[t+2]]+u[e[t+3]]+"-"+u[e[t+4]]+u[e[t+5]]+"-"+u[e[t+6]]+u[e[t+7]]+"-"+u[e[t+8]]+u[e[t+9]]+"-"+u[e[t+10]]+u[e[t+11]]+u[e[t+12]]+u[e[t+13]]+u[e[t+14]]+u[e[t+15]]).toLowerCase();if(!s(r))throw TypeError("Stringified UUID is invalid");return r};var p,d,f=0,y=0;const h=function(e,t,r){var n=t&&r||0,i=t||new Array(16),a=(e=e||{}).node||p,s=void 0!==e.clockseq?e.clockseq:d;if(null==a||null==s){var u=e.random||(e.rng||o)();null==a&&(a=p=[1|u[0],u[1],u[2],u[3],u[4],u[5]]),null==s&&(s=d=16383&(u[6]<<8|u[7]))}var l=void 0!==e.msecs?e.msecs:Date.now(),h=void 0!==e.nsecs?e.nsecs:y+1,m=l-f+(h-y)/1e4;if(m<0&&void 0===e.clockseq&&(s=s+1&16383),(m<0||l>f)&&void 0===e.nsecs&&(h=0),h>=1e4)throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");f=l,y=h,d=s;var g=(1e4*(268435455&(l+=122192928e5))+h)%4294967296;i[n++]=g>>>24&255,i[n++]=g>>>16&255,i[n++]=g>>>8&255,i[n++]=255&g;var v=l/4294967296*1e4&268435455;i[n++]=v>>>8&255,i[n++]=255&v,i[n++]=v>>>24&15|16,i[n++]=v>>>16&255,i[n++]=s>>>8|128,i[n++]=255&s;for(var b=0;b<6;++b)i[n+b]=a[b];return t||c(i)},m=function(e){if(!s(e))throw TypeError("Invalid UUID");var t,r=new Uint8Array(16);return r[0]=(t=parseInt(e.slice(0,8),16))>>>24,r[1]=t>>>16&255,r[2]=t>>>8&255,r[3]=255&t,r[4]=(t=parseInt(e.slice(9,13),16))>>>8,r[5]=255&t,r[6]=(t=parseInt(e.slice(14,18),16))>>>8,r[7]=255&t,r[8]=(t=parseInt(e.slice(19,23),16))>>>8,r[9]=255&t,r[10]=(t=parseInt(e.slice(24,36),16))/1099511627776&255,r[11]=t/4294967296&255,r[12]=t>>>24&255,r[13]=t>>>16&255,r[14]=t>>>8&255,r[15]=255&t,r};function g(e,t,r){function n(e,n,i,o){if("string"==typeof e&&(e=function(e){e=unescape(encodeURIComponent(e));for(var t=[],r=0;r>>9<<4)+1}function b(e,t){var r=(65535&e)+(65535&t);return(e>>16)+(t>>16)+(r>>16)<<16|65535&r}function I(e,t,r,n,i,o){return b((a=b(b(t,e),b(n,o)))<<(s=i)|a>>>32-s,r);var a,s}function S(e,t,r,n,i,o,a){return I(t&r|~t&n,e,t,i,o,a)}function _(e,t,r,n,i,o,a){return I(t&n|r&~n,e,t,i,o,a)}function T(e,t,r,n,i,o,a){return I(t^r^n,e,t,i,o,a)}function P(e,t,r,n,i,o,a){return I(r^(t|~n),e,t,i,o,a)}const A=g("v3",48,(function(e){if("string"==typeof e){var t=unescape(encodeURIComponent(e));e=new Uint8Array(t.length);for(var r=0;r>5]>>>i%32&255,a=parseInt(n.charAt(o>>>4&15)+n.charAt(15&o),16);t.push(a)}return t}(function(e,t){e[t>>5]|=128<>5]|=(255&e[n/8])<>>32-t}const D=g("v5",80,(function(e){var t=[1518500249,1859775393,2400959708,3395469782],r=[1732584193,4023233417,2562383102,271733878,3285377520];if("string"==typeof e){var n=unescape(encodeURIComponent(e));e=[];for(var i=0;i>>0;b=v,v=g,g=O(m,30)>>>0,m=h,h=_}r[0]=r[0]+h>>>0,r[1]=r[1]+m>>>0,r[2]=r[2]+g>>>0,r[3]=r[3]+v>>>0,r[4]=r[4]+b>>>0}return[r[0]>>24&255,r[0]>>16&255,r[0]>>8&255,255&r[0],r[1]>>24&255,r[1]>>16&255,r[1]>>8&255,255&r[1],r[2]>>24&255,r[2]>>16&255,r[2]>>8&255,255&r[2],r[3]>>24&255,r[3]>>16&255,r[3]>>8&255,255&r[3],r[4]>>24&255,r[4]>>16&255,r[4]>>8&255,255&r[4]]})),x="00000000-0000-0000-0000-000000000000",F=function(e){if(!s(e))throw TypeError("Invalid UUID");return parseInt(e.substr(14,1),16)}},5892:e=>{"use strict";e.exports=JSON.parse('{"major":1,"minor":162,"fix":0}')}},t={};function r(n){var i=t[n];if(void 0!==i)return i.exports;var o=t[n]={exports:{}};return e[n].call(o.exports,o,o.exports,r),o.exports}r.d=(e,t)=>{for(var n in t)r.o(t,n)&&!r.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:t[n]})},r.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),r.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})};var n={};(()=>{"use strict";var e=n;Object.defineProperty(e,"__esModule",{value:!0});var t=r(5136);r(3e3),r(8315),r(80),r(5668),r(5816),r(3680),r(9308),r(8824),r(8512),r(9232),r(9336);var i=r(976),o=r(5408),a="undefined"!=typeof VERSION_IS_ALPHA&&VERSION_IS_ALPHA;t.ApiVersion.SetVersionNumber("1.12.0-pre.16",a);var s=new i.ExtensionsImpl;e.extensions=new o.Extensions(s);var u=r(7419);e.AnalyticsObjectType=u.AnalyticsObjectType,e.AnnotationType=u.AnnotationType,e.ClassNameKey=u.ClassNameKey,e.ColumnType=u.ColumnType,e.DashboardLayoutChange=u.DashboardLayoutChange,e.DashboardObjectType=u.DashboardObjectType,e.DashboardObjectVisibilityType=u.DashboardObjectVisibilityType,e.DataType=u.DataType,e.DateRangeType=u.DateRangeType,e.DialogStyle=u.DialogStyle,e.EncodingType=u.EncodingType,e.ErrorCodes=u.ErrorCodes,e.ExtensionContext=u.ExtensionContext,e.ExtensionMode=u.ExtensionMode,e.FieldAggregationType=u.FieldAggregationType,e.FieldRoleType=u.FieldRoleType,e.FilterDomainType=u.FilterDomainType,e.FilterNullOption=u.FilterNullOption,e.FilterType=u.FilterType,e.FilterUpdateType=u.FilterUpdateType,e.HierarchicalLevelSelectionState=u.HierarchicalLevelSelectionState,e.IncludeDataValuesOption=u.IncludeDataValuesOption,e.MarkType=u.MarkType,e.ParameterValueType=u.ParameterValueType,e.PeriodType=u.PeriodType,e.QuickTableCalcType=u.QuickTableCalcType,e.ReplaySpeedType=u.ReplaySpeedType,e.SelectOptions=u.SelectOptions,e.SelectionUpdateType=u.SelectionUpdateType,e.SheetType=u.SheetType,e.SortDirection=u.SortDirection,e.TableauEventType=u.TableauEventType,e.TrendLineModelType=u.TrendLineModelType,e.VizImageEncodingType=u.VizImageEncodingType,e.VizImagePaletteType=u.VizImagePaletteType,e.VizImageSizeSettingAlignmentType=u.VizImageSizeSettingAlignmentType,e.VizImageSizeSettingType=u.VizImageSizeSettingType,e.VizImageSortDirectionType=u.VizImageSortDirectionType,e.ZoneVisibilityType=u.ZoneVisibilityType})(),window.tableau=n})(); +//# sourceMappingURL=tableau.extensions.1.12.0-pre.16.min.js.map \ No newline at end of file diff --git a/lib/tableau.extensions.1.latest.js b/lib/tableau.extensions.1.latest.js index 2c61bd95..daddde15 100644 --- a/lib/tableau.extensions.1.latest.js +++ b/lib/tableau.extensions.1.latest.js @@ -709,7 +709,7 @@ module.exports = function (stack, dropEntries) { "use strict"; -var defineProperty = __webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js").f; +var defineProperty = (__webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js").f); var create = __webpack_require__(/*! ../internals/object-create */ "../../node_modules/core-js/internals/object-create.js"); var redefineAll = __webpack_require__(/*! ../internals/redefine-all */ "../../node_modules/core-js/internals/redefine-all.js"); var bind = __webpack_require__(/*! ../internals/function-bind-context */ "../../node_modules/core-js/internals/function-bind-context.js"); @@ -718,7 +718,7 @@ var iterate = __webpack_require__(/*! ../internals/iterate */ "../../node_module var defineIterator = __webpack_require__(/*! ../internals/define-iterator */ "../../node_modules/core-js/internals/define-iterator.js"); var setSpecies = __webpack_require__(/*! ../internals/set-species */ "../../node_modules/core-js/internals/set-species.js"); var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../node_modules/core-js/internals/descriptors.js"); -var fastKey = __webpack_require__(/*! ../internals/internal-metadata */ "../../node_modules/core-js/internals/internal-metadata.js").fastKey; +var fastKey = (__webpack_require__(/*! ../internals/internal-metadata */ "../../node_modules/core-js/internals/internal-metadata.js").fastKey); var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "../../node_modules/core-js/internals/internal-state.js"); var setInternalState = InternalStateModule.set; @@ -1082,7 +1082,7 @@ module.exports = !fails(function () { "use strict"; -var IteratorPrototype = __webpack_require__(/*! ../internals/iterators-core */ "../../node_modules/core-js/internals/iterators-core.js").IteratorPrototype; +var IteratorPrototype = (__webpack_require__(/*! ../internals/iterators-core */ "../../node_modules/core-js/internals/iterators-core.js").IteratorPrototype); var create = __webpack_require__(/*! ../internals/object-create */ "../../node_modules/core-js/internals/object-create.js"); var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "../../node_modules/core-js/internals/create-property-descriptor.js"); var setToStringTag = __webpack_require__(/*! ../internals/set-to-string-tag */ "../../node_modules/core-js/internals/set-to-string-tag.js"); @@ -1485,7 +1485,7 @@ module.exports = !fails(function () { /***/ ((module, __unused_webpack_exports, __webpack_require__) => { var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); -var getOwnPropertyDescriptor = __webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "../../node_modules/core-js/internals/object-get-own-property-descriptor.js").f; +var getOwnPropertyDescriptor = (__webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "../../node_modules/core-js/internals/object-get-own-property-descriptor.js").f); var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-non-enumerable-property */ "../../node_modules/core-js/internals/create-non-enumerable-property.js"); var redefine = __webpack_require__(/*! ../internals/redefine */ "../../node_modules/core-js/internals/redefine.js"); var setGlobal = __webpack_require__(/*! ../internals/set-global */ "../../node_modules/core-js/internals/set-global.js"); @@ -1981,7 +1981,7 @@ var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "../../node_modules/core-js/internals/hidden-keys.js"); var isObject = __webpack_require__(/*! ../internals/is-object */ "../../node_modules/core-js/internals/is-object.js"); var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); -var defineProperty = __webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js").f; +var defineProperty = (__webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js").f); var getOwnPropertyNamesModule = __webpack_require__(/*! ../internals/object-get-own-property-names */ "../../node_modules/core-js/internals/object-get-own-property-names.js"); var getOwnPropertyNamesExternalModule = __webpack_require__(/*! ../internals/object-get-own-property-names-external */ "../../node_modules/core-js/internals/object-get-own-property-names-external.js"); var uid = __webpack_require__(/*! ../internals/uid */ "../../node_modules/core-js/internals/uid.js"); @@ -2564,8 +2564,8 @@ module.exports = function (obj) { var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/core-js/internals/global.js"); var bind = __webpack_require__(/*! ../internals/function-bind-context */ "../../node_modules/core-js/internals/function-bind-context.js"); -var getOwnPropertyDescriptor = __webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "../../node_modules/core-js/internals/object-get-own-property-descriptor.js").f; -var macrotask = __webpack_require__(/*! ../internals/task */ "../../node_modules/core-js/internals/task.js").set; +var getOwnPropertyDescriptor = (__webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "../../node_modules/core-js/internals/object-get-own-property-descriptor.js").f); +var macrotask = (__webpack_require__(/*! ../internals/task */ "../../node_modules/core-js/internals/task.js").set); var IS_IOS = __webpack_require__(/*! ../internals/engine-is-ios */ "../../node_modules/core-js/internals/engine-is-ios.js"); var IS_IOS_PEBBLE = __webpack_require__(/*! ../internals/engine-is-ios-pebble */ "../../node_modules/core-js/internals/engine-is-ios-pebble.js"); var IS_WEBOS_WEBKIT = __webpack_require__(/*! ../internals/engine-is-webos-webkit */ "../../node_modules/core-js/internals/engine-is-webos-webkit.js"); @@ -2759,7 +2759,7 @@ var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/ var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); var toString = __webpack_require__(/*! ../internals/to-string */ "../../node_modules/core-js/internals/to-string.js"); -var trim = __webpack_require__(/*! ../internals/string-trim */ "../../node_modules/core-js/internals/string-trim.js").trim; +var trim = (__webpack_require__(/*! ../internals/string-trim */ "../../node_modules/core-js/internals/string-trim.js").trim); var whitespaces = __webpack_require__(/*! ../internals/whitespaces */ "../../node_modules/core-js/internals/whitespaces.js"); var charAt = uncurryThis(''.charAt); @@ -2791,7 +2791,7 @@ var global = __webpack_require__(/*! ../internals/global */ "../../node_modules/ var fails = __webpack_require__(/*! ../internals/fails */ "../../node_modules/core-js/internals/fails.js"); var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); var toString = __webpack_require__(/*! ../internals/to-string */ "../../node_modules/core-js/internals/to-string.js"); -var trim = __webpack_require__(/*! ../internals/string-trim */ "../../node_modules/core-js/internals/string-trim.js").trim; +var trim = (__webpack_require__(/*! ../internals/string-trim */ "../../node_modules/core-js/internals/string-trim.js").trim); var whitespaces = __webpack_require__(/*! ../internals/whitespaces */ "../../node_modules/core-js/internals/whitespaces.js"); var $parseInt = global.parseInt; @@ -3076,7 +3076,7 @@ exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDes /* eslint-disable es/no-object-getownpropertynames -- safe */ var classof = __webpack_require__(/*! ../internals/classof-raw */ "../../node_modules/core-js/internals/classof-raw.js"); var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../../node_modules/core-js/internals/to-indexed-object.js"); -var $getOwnPropertyNames = __webpack_require__(/*! ../internals/object-get-own-property-names */ "../../node_modules/core-js/internals/object-get-own-property-names.js").f; +var $getOwnPropertyNames = (__webpack_require__(/*! ../internals/object-get-own-property-names */ "../../node_modules/core-js/internals/object-get-own-property-names.js").f); var arraySlice = __webpack_require__(/*! ../internals/array-slice */ "../../node_modules/core-js/internals/array-slice.js"); var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames @@ -3186,7 +3186,7 @@ module.exports = uncurryThis({}.isPrototypeOf); var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../../node_modules/core-js/internals/to-indexed-object.js"); -var indexOf = __webpack_require__(/*! ../internals/array-includes */ "../../node_modules/core-js/internals/array-includes.js").indexOf; +var indexOf = (__webpack_require__(/*! ../internals/array-includes */ "../../node_modules/core-js/internals/array-includes.js").indexOf); var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "../../node_modules/core-js/internals/hidden-keys.js"); var push = uncurryThis([].push); @@ -3298,7 +3298,7 @@ var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "../../nod var uncurryThis = __webpack_require__(/*! ../internals/function-uncurry-this */ "../../node_modules/core-js/internals/function-uncurry-this.js"); var objectKeys = __webpack_require__(/*! ../internals/object-keys */ "../../node_modules/core-js/internals/object-keys.js"); var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "../../node_modules/core-js/internals/to-indexed-object.js"); -var $propertyIsEnumerable = __webpack_require__(/*! ../internals/object-property-is-enumerable */ "../../node_modules/core-js/internals/object-property-is-enumerable.js").f; +var $propertyIsEnumerable = (__webpack_require__(/*! ../internals/object-property-is-enumerable */ "../../node_modules/core-js/internals/object-property-is-enumerable.js").f); var propertyIsEnumerable = uncurryThis($propertyIsEnumerable); var push = uncurryThis([].push); @@ -3485,7 +3485,7 @@ var createNonEnumerableProperty = __webpack_require__(/*! ../internals/create-no var setGlobal = __webpack_require__(/*! ../internals/set-global */ "../../node_modules/core-js/internals/set-global.js"); var inspectSource = __webpack_require__(/*! ../internals/inspect-source */ "../../node_modules/core-js/internals/inspect-source.js"); var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "../../node_modules/core-js/internals/internal-state.js"); -var CONFIGURABLE_FUNCTION_NAME = __webpack_require__(/*! ../internals/function-name */ "../../node_modules/core-js/internals/function-name.js").CONFIGURABLE; +var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(/*! ../internals/function-name */ "../../node_modules/core-js/internals/function-name.js").CONFIGURABLE); var getInternalState = InternalStateModule.get; var enforceInternalState = InternalStateModule.enforce; @@ -3606,7 +3606,7 @@ module.exports = function (CONSTRUCTOR_NAME) { \*****************************************************************/ /***/ ((module, __unused_webpack_exports, __webpack_require__) => { -var defineProperty = __webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js").f; +var defineProperty = (__webpack_require__(/*! ../internals/object-define-property */ "../../node_modules/core-js/internals/object-define-property.js").f); var hasOwn = __webpack_require__(/*! ../internals/has-own-property */ "../../node_modules/core-js/internals/has-own-property.js"); var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "../../node_modules/core-js/internals/well-known-symbol.js"); @@ -4270,7 +4270,7 @@ $({ global: true }, { "use strict"; var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); -var $find = __webpack_require__(/*! ../internals/array-iteration */ "../../node_modules/core-js/internals/array-iteration.js").find; +var $find = (__webpack_require__(/*! ../internals/array-iteration */ "../../node_modules/core-js/internals/array-iteration.js").find); var addToUnscopables = __webpack_require__(/*! ../internals/add-to-unscopables */ "../../node_modules/core-js/internals/add-to-unscopables.js"); var FIND = 'find'; @@ -4503,7 +4503,7 @@ $({ target: 'Object', stat: true, forced: Object.assign !== assign }, { /***/ ((__unused_webpack_module, __unused_webpack_exports, __webpack_require__) => { var $ = __webpack_require__(/*! ../internals/export */ "../../node_modules/core-js/internals/export.js"); -var $entries = __webpack_require__(/*! ../internals/object-to-array */ "../../node_modules/core-js/internals/object-to-array.js").entries; +var $entries = (__webpack_require__(/*! ../internals/object-to-array */ "../../node_modules/core-js/internals/object-to-array.js").entries); // `Object.entries` method // https://tc39.es/ecma262/#sec-object.entries @@ -4743,7 +4743,7 @@ var inspectSource = __webpack_require__(/*! ../internals/inspect-source */ "../. var iterate = __webpack_require__(/*! ../internals/iterate */ "../../node_modules/core-js/internals/iterate.js"); var checkCorrectnessOfIteration = __webpack_require__(/*! ../internals/check-correctness-of-iteration */ "../../node_modules/core-js/internals/check-correctness-of-iteration.js"); var speciesConstructor = __webpack_require__(/*! ../internals/species-constructor */ "../../node_modules/core-js/internals/species-constructor.js"); -var task = __webpack_require__(/*! ../internals/task */ "../../node_modules/core-js/internals/task.js").set; +var task = (__webpack_require__(/*! ../internals/task */ "../../node_modules/core-js/internals/task.js").set); var microtask = __webpack_require__(/*! ../internals/microtask */ "../../node_modules/core-js/internals/microtask.js"); var promiseResolve = __webpack_require__(/*! ../internals/promise-resolve */ "../../node_modules/core-js/internals/promise-resolve.js"); var hostReportErrors = __webpack_require__(/*! ../internals/host-report-errors */ "../../node_modules/core-js/internals/host-report-errors.js"); @@ -5133,7 +5133,7 @@ $({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, { "use strict"; -var charAt = __webpack_require__(/*! ../internals/string-multibyte */ "../../node_modules/core-js/internals/string-multibyte.js").charAt; +var charAt = (__webpack_require__(/*! ../internals/string-multibyte */ "../../node_modules/core-js/internals/string-multibyte.js").charAt); var toString = __webpack_require__(/*! ../internals/to-string */ "../../node_modules/core-js/internals/to-string.js"); var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "../../node_modules/core-js/internals/internal-state.js"); var defineIterator = __webpack_require__(/*! ../internals/define-iterator */ "../../node_modules/core-js/internals/define-iterator.js"); @@ -6608,6 +6608,13 @@ var DashboardObject = /** @class */ (function () { enumerable: true, configurable: true }); + Object.defineProperty(DashboardObject.prototype, "fieldId", { + get: function () { + return this._dashboardObjectImpl.fieldId; + }, + enumerable: true, + configurable: true + }); return DashboardObject; }()); exports.DashboardObject = DashboardObject; @@ -7013,12 +7020,19 @@ var Worksheet = /** @class */ (function (_super) { Worksheet.prototype.removeAnnotationAsync = function (annotation) { return this._worksheetImpl.removeAnnotationAsync(annotation); }; - Worksheet.prototype.hoverTupleAsync = function (hoveredTuple, tooltip) { - return this._worksheetImpl.hoverTupleAsync(hoveredTuple, tooltip); + Worksheet.prototype.hoverTupleAsync = function (hoveredTuple, tooltip, allowHoverActions) { + if (allowHoverActions === void 0) { allowHoverActions = true; } + return this._worksheetImpl.hoverTupleAsync(hoveredTuple, tooltip, allowHoverActions); }; Worksheet.prototype.selectTuplesAsync = function (selectedTuples, selectOption, tooltip) { return this._worksheetImpl.selectTuplesAsync(selectedTuples, selectOption, tooltip); }; + Worksheet.prototype.getTooltipTextAsync = function (tupleId) { + return this._worksheetImpl.getTooltipTextAsync(tupleId); + }; + Worksheet.prototype.leaveMarkNavigationAsync = function () { + return this._worksheetImpl.leaveMarkNavigationAsync(); + }; Worksheet.prototype.visualIdsAreEqual = function (a, b) { return (a && b && @@ -7719,6 +7733,7 @@ exports.FileFormats = Enums_1.FileFormats; exports.PrintOrientation = Enums_1.PrintOrientation; exports.PrintPageSize = Enums_1.PrintPageSize; exports.PrintScaling = Enums_1.PrintScaling; +exports.PulseLayout = Enums_1.PulseLayout; exports.SheetSizeBehavior = Enums_1.SheetSizeBehavior; exports.TableauDialogType = Enums_1.TableauDialogType; exports.Toolbar = Enums_1.Toolbar; @@ -8072,6 +8087,12 @@ var SheetSizeBehavior; SheetSizeBehavior["AtLeast"] = "atleast"; SheetSizeBehavior["AtMost"] = "atmost"; })(SheetSizeBehavior = exports.SheetSizeBehavior || (exports.SheetSizeBehavior = {})); +var PulseLayout; +(function (PulseLayout) { + PulseLayout["Default"] = "default"; + PulseLayout["Card"] = "card"; + PulseLayout["Ban"] = "ban"; +})(PulseLayout = exports.PulseLayout || (exports.PulseLayout = {})); /** * Be careful when adding new event types. Extensions and embedding follow two different patterns on how events are named. * Events should be all lower case and without hyphens or underscores. @@ -8268,6 +8289,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); var PulseAttributes; (function (PulseAttributes) { PulseAttributes["DisableExploreFilter"] = "disable-explore-filter"; + PulseAttributes["Layout"] = "layout"; })(PulseAttributes = exports.PulseAttributes || (exports.PulseAttributes = {})); @@ -8702,6 +8724,7 @@ var Tableau; (function (ColumnType) { ColumnType["Discrete"] = "discrete"; ColumnType["Continuous"] = "continuous"; + ColumnType["Unknown"] = "unknown"; })(ColumnType = Tableau.ColumnType || (Tableau.ColumnType = {})); var ClassNameKey; (function (ClassNameKey) { @@ -9004,7 +9027,7 @@ var Tableau; SelectionUpdateType["Remove"] = "select-remove"; })(SelectionUpdateType = Tableau.SelectionUpdateType || (Tableau.SelectionUpdateType = {})); /** - * Enum for specifying the select option for the {@link Worksheet.selectTuplesAsync} method. + * Enum for specifying the select option for the `extensions.Worksheet.selectTuplesAsync` method. */ var SelectOptions; (function (SelectOptions) { @@ -9219,7 +9242,7 @@ var DataTypeConverter = /** @class */ (function () { var value = new Date(formattedDateString); return Number.isNaN(value.getTime()) ? null : value; }; - // tslint:disable-next-line:no-any + // It would be nice to merge this and the method FilterConverter::convertFilterValuePresModel in api-platform-js DataTypeConverter.convertValueAsStringToValue = function (valueAsString, type) { // This is both DataDictionary and ShowDataTablePresModel compatible. // In the DataDictionary, valueAsString can be '%null%' or '%missing%', while in @@ -9331,6 +9354,7 @@ var ColumnType; (function (ColumnType) { ColumnType["Discrete"] = "discrete"; ColumnType["Continuous"] = "continuous"; + ColumnType["Unknown"] = "unknown"; })(ColumnType = exports.ColumnType || (exports.ColumnType = {})); var DashboardObjectType; (function (DashboardObjectType) { @@ -9869,6 +9893,8 @@ var ParameterId; ParameterId["TestConversionParameter"] = "test-conversion-parameter"; ParameterId["Text"] = "formatted-text"; ParameterId["TooltipContext"] = "tooltip-context"; + ParameterId["TooltipTextRequest"] = "tooltip-text-request"; + ParameterId["TooltipText"] = "tooltip-text"; ParameterId["UnderlyingDataTable"] = "underlying-data-table"; ParameterId["UnderlyingSummaryDataTable"] = "underlying-summary-data-table"; ParameterId["Url"] = "url"; @@ -9968,6 +9994,7 @@ var VerbId; VerbId["GetRangeDomain"] = "get-range-domain"; VerbId["GetSelectedMarks"] = "get-selected-marks"; VerbId["GetSharedFilter"] = "get-shared-filter"; + VerbId["GetTooltipText"] = "get-tooltip-text"; VerbId["GetUnderlyingData"] = "get-underlying-data"; VerbId["GetUnderlyingTableData"] = "get-underlying-table-data"; VerbId["GetUnderlyingTableDataReader"] = "get-underlying-table-data-reader"; @@ -9975,6 +10002,7 @@ var VerbId; VerbId["HierarchicalFilter"] = "hierachical-filter"; VerbId["InitializeExtension"] = "initialize-extension"; VerbId["MoveAndResizeZones"] = "move-and-resize-zones"; + VerbId["RaiseLeaveMarkNavNotification"] = "raise-leave-mark-nav-notification"; VerbId["RaiseHoverTupleNotification"] = "raise-hover-tuple-notification"; VerbId["RaiseSelectTuplesNotification"] = "raise-select-tuples-notification"; VerbId["Redo"] = "redo"; @@ -10048,6 +10076,7 @@ var PulseOptionNames; PulseOptionNames["embed"] = "embed"; PulseOptionNames["token"] = "token"; PulseOptionNames["disableExploreFilter"] = "disableExploreFilter"; + PulseOptionNames["layout"] = "embed_layout"; PulseOptionNames["ApiExternalVersion"] = ":apiExternalVersion"; PulseOptionNames["ApiInternalVersion"] = ":apiInternalVersion"; PulseOptionNames["PulseWebComponent"] = ":pulseWebComponent"; @@ -11976,6 +12005,7 @@ var InternalToExternalEnumMappings = /** @class */ (function () { InternalToExternalEnumMappings.columnType = new EnumConverter_1.EnumConverter((_c = {}, _c[api_internal_contract_js_1.ColumnType.Continuous] = api_external_contract_js_1.ColumnType.Continuous, _c[api_internal_contract_js_1.ColumnType.Discrete] = api_external_contract_js_1.ColumnType.Discrete, + _c[api_internal_contract_js_1.ColumnType.Unknown] = api_external_contract_js_1.ColumnType.Unknown, _c)); InternalToExternalEnumMappings.fieldAggregationType = new EnumConverter_1.EnumConverter((_d = {}, _d[api_internal_contract_js_1.FieldAggregationType.Attr] = api_external_contract_js_1.FieldAggregationType.Attr, @@ -12047,6 +12077,7 @@ var InternalToExternalEnumMappings = /** @class */ (function () { _h[api_internal_contract_js_1.DataType.DateTime] = api_external_contract_js_1.DataType.DateTime, _h[api_internal_contract_js_1.DataType.Float] = api_external_contract_js_1.DataType.Float, _h[api_internal_contract_js_1.DataType.Int] = api_external_contract_js_1.DataType.Int, + _h[api_internal_contract_js_1.DataType.Spatial] = api_external_contract_js_1.DataType.Spatial, _h[api_internal_contract_js_1.DataType.String] = api_external_contract_js_1.DataType.String, _h)); InternalToExternalEnumMappings.filterUpdateType = new EnumConverter_1.EnumConverter((_j = {}, @@ -12187,12 +12218,11 @@ exports.EventListenerManager = EventListenerManager; /*!***************************************************!*\ !*** ../api-shared-js/lib/src/ApiShared/Field.js ***! \***************************************************/ -/***/ ((__unused_webpack_module, exports, __webpack_require__) => { +/***/ ((__unused_webpack_module, exports) => { "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); -var ErrorHelpers_1 = __webpack_require__(/*! ./Utils/ErrorHelpers */ "../api-shared-js/lib/src/ApiShared/Utils/ErrorHelpers.js"); var Field = /** @class */ (function () { function Field(_fieldImpl) { this._fieldImpl = _fieldImpl; @@ -12246,37 +12276,44 @@ var Field = /** @class */ (function () { enumerable: true, configurable: true }); - Object.defineProperty(Field.prototype, "isHidden", { + Object.defineProperty(Field.prototype, "columnType", { get: function () { - return this._fieldImpl.isHidden; + return this._fieldImpl.columnType; }, enumerable: true, configurable: true }); - Object.defineProperty(Field.prototype, "isGenerated", { + Object.defineProperty(Field.prototype, "isCalculatedField", { get: function () { - return this._fieldImpl.isGenerated; + return this._fieldImpl.isCalculatedField; }, enumerable: true, configurable: true }); - Object.defineProperty(Field.prototype, "isCalculatedField", { + Object.defineProperty(Field.prototype, "isCombinedField", { get: function () { - return this._fieldImpl.isCalculatedField; + return this._fieldImpl.isCombinedField; }, enumerable: true, configurable: true }); - Object.defineProperty(Field.prototype, "columnType", { + Object.defineProperty(Field.prototype, "isGenerated", { get: function () { - throw ErrorHelpers_1.ErrorHelpers.apiNotImplemented('Field.columnType'); + return this._fieldImpl.isGenerated; }, enumerable: true, configurable: true }); - Object.defineProperty(Field.prototype, "isCombinedField", { + Object.defineProperty(Field.prototype, "isGeospatial", { get: function () { - return this._fieldImpl.isCombinedField; + return this._fieldImpl.isGeospatial; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(Field.prototype, "isHidden", { + get: function () { + return this._fieldImpl.isHidden; }, enumerable: true, configurable: true @@ -12468,7 +12505,7 @@ var DashboardImpl = /** @class */ (function (_super) { var zoneSize = { width: zone.width, height: zone.height }; // As the dashboard is active, all other zones in the dashboard are inactive. var isActive = false; - if (zone.zoneType === api_internal_contract_js_1.DashboardObjectType.Worksheet) { + if (zone.zoneType === api_internal_contract_js_1.DashboardObjectType.Worksheet || zone.zoneType === api_internal_contract_js_1.DashboardObjectType.QuickFilter) { var worksheetName = ''; var worksheetUrl = ''; var isHidden = false; @@ -12494,12 +12531,14 @@ var DashboardImpl = /** @class */ (function (_super) { storyPointID: this._sheetPath.storyPointID, }; worksheetImpl = new WorksheetImpl_1.WorksheetImpl(sheetInfoImpl, this._registryId, vizId, this, this._parentStoryPointImpl); - this._worksheetsImpl.push(worksheetImpl); + if (zone.zoneType === api_internal_contract_js_1.DashboardObjectType.Worksheet) { + this._worksheetsImpl.push(worksheetImpl); + } } var zonePoint = new Point_1.Point(zone.x, zone.y); var dashboardObjectImpl = new DashboardObjectImpl_1.DashboardObjectImpl(this, InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.dashboardObjectType.convert(zone.zoneType), zonePoint, zoneSize, worksheetImpl, zone.name, zone.isFloating !== undefined ? zone.isFloating : false, // before 1.6.0 we didn't have isFloating, so we assume false zone.isVisible !== undefined ? zone.isVisible : true, // before 1.6.0 we didn't have isVisible, so we assume true - zone.zoneId); + zone.zoneId, zone.fieldId); this._objects.push(dashboardObjectImpl); this.zoneMap.set(zone.zoneId, dashboardObjectImpl); } @@ -12649,7 +12688,7 @@ Object.defineProperty(exports, "__esModule", ({ value: true })); * This does not follow the Impl pattern as it is just a property bag. */ var DashboardObjectImpl = /** @class */ (function () { - function DashboardObjectImpl(_dashboardImpl, _type, _position, _size, _worksheetImpl, _name, _isFloating, _isVisible, _id) { + function DashboardObjectImpl(_dashboardImpl, _type, _position, _size, _worksheetImpl, _name, _isFloating, _isVisible, _id, _fieldId) { this._dashboardImpl = _dashboardImpl; this._type = _type; this._position = _position; @@ -12659,6 +12698,7 @@ var DashboardObjectImpl = /** @class */ (function () { this._isFloating = _isFloating; this._isVisible = _isVisible; this._id = _id; + this._fieldId = _fieldId; } Object.defineProperty(DashboardObjectImpl.prototype, "dashboardImpl", { get: function () { @@ -12723,6 +12763,13 @@ var DashboardObjectImpl = /** @class */ (function () { enumerable: true, configurable: true }); + Object.defineProperty(DashboardObjectImpl.prototype, "fieldId", { + get: function () { + return this._fieldId; + }, + enumerable: true, + configurable: true + }); return DashboardObjectImpl; }()); exports.DashboardObjectImpl = DashboardObjectImpl; @@ -12867,7 +12914,8 @@ exports.DataSourceImpl = DataSourceImpl; "use strict"; Object.defineProperty(exports, "__esModule", ({ value: true })); -var api_external_contract_js_1 = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var Contract = __webpack_require__(/*! @tableau/api-external-contract-js */ "../api-external-contract-js/lib/src/ExternalContract.js"); +var InternalContract = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); var InternalToExternalEnumMappings_1 = __webpack_require__(/*! ../EnumMappings/InternalToExternalEnumMappings */ "../api-shared-js/lib/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.js"); var FieldImpl = /** @class */ (function () { function FieldImpl(_fieldInfo, _parentDataSource) { @@ -12898,7 +12946,7 @@ var FieldImpl = /** @class */ (function () { Object.defineProperty(FieldImpl.prototype, "dataType", { get: function () { var _a; - return _a = this._fieldInfo.dataType, (_a !== null && _a !== void 0 ? _a : api_external_contract_js_1.DataType.Unknown); + return _a = this._fieldInfo.dataType, (_a !== null && _a !== void 0 ? _a : Contract.DataType.Unknown); }, enumerable: true, configurable: true @@ -12926,9 +12974,24 @@ var FieldImpl = /** @class */ (function () { enumerable: true, configurable: true }); - Object.defineProperty(FieldImpl.prototype, "isHidden", { + Object.defineProperty(FieldImpl.prototype, "columnType", { get: function () { - return this._fieldInfo.isHidden; + var definedValue = this._fieldInfo.columnType || InternalContract.ColumnType.Unknown; + return InternalToExternalEnumMappings_1.InternalToExternalEnumMappings.columnType.convert(definedValue); + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isCalculatedField", { + get: function () { + return this._fieldInfo.isCalculatedField; + }, + enumerable: true, + configurable: true + }); + Object.defineProperty(FieldImpl.prototype, "isCombinedField", { + get: function () { + return this._fieldInfo.isCombinedField; }, enumerable: true, configurable: true @@ -12940,16 +13003,16 @@ var FieldImpl = /** @class */ (function () { enumerable: true, configurable: true }); - Object.defineProperty(FieldImpl.prototype, "isCalculatedField", { + Object.defineProperty(FieldImpl.prototype, "isGeospatial", { get: function () { - return this._fieldInfo.isCalculatedField; + return this._fieldInfo.isGeospatial; }, enumerable: true, configurable: true }); - Object.defineProperty(FieldImpl.prototype, "isCombinedField", { + Object.defineProperty(FieldImpl.prototype, "isHidden", { get: function () { - return this._fieldInfo.isCombinedField; + return this._fieldInfo.isHidden; }, enumerable: true, configurable: true @@ -14109,12 +14172,12 @@ var WorksheetImpl = /** @class */ (function (_super) { var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("external-context-menu-service" /* ExternalContextMenu */); return service.renameContextMenuAsync(this.visualId.worksheet, targetMenu, menuHeader, menuDescription); }; - WorksheetImpl.prototype.hoverTupleAsync = function (hoveredTuple, tooltip) { + WorksheetImpl.prototype.hoverTupleAsync = function (hoveredTuple, tooltip, allowHoverActions) { if (this.isInsideDashboardExtension()) { return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, "hoverTupleAsync is not supported in dashboard extensions")); } var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("selection-service" /* Selection */); - return service.hoverTupleAsync(this.visualId, hoveredTuple, tooltip); + return service.hoverTupleAsync(this.visualId, hoveredTuple, tooltip, allowHoverActions); }; WorksheetImpl.prototype.selectTuplesAsync = function (selectedTuples, selectOption, tooltip) { if (this.isInsideDashboardExtension()) { @@ -14123,6 +14186,20 @@ var WorksheetImpl = /** @class */ (function (_super) { var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("selection-service" /* Selection */); return service.selectTuplesAsync(this.visualId, selectedTuples, selectOption, tooltip); }; + WorksheetImpl.prototype.getTooltipTextAsync = function (tupleId) { + if (this.isInsideDashboardExtension()) { + return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, "getTooltipTextAsync is not supported in dashboard extensions")); + } + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("accessibility" /* Accessibility */); + return service.getTooltipTextAsync(this.visualId, tupleId); + }; + WorksheetImpl.prototype.leaveMarkNavigationAsync = function () { + if (this.isInsideDashboardExtension()) { + return Promise.reject(new TableauError_1.TableauError(Contract.SharedErrorCodes.ImplementationError, "leaveMarkNavigationAsync is not supported in dashboard extensions")); + } + var service = ServiceRegistry_1.ApiServiceRegistry.get(this._registryId).getService("accessibility" /* Accessibility */); + return service.leaveMarkNavigationAsync(this.visualId); + }; WorksheetImpl.prototype.createDataSourceFromInfo = function (dataSourceInfo) { var dataSourceImpl = new DataSourceImpl_1.DataSourceImpl(dataSourceInfo, this._registryId); var dataSource = new DataSource_1.DataSource(dataSourceImpl); @@ -14189,6 +14266,27 @@ var LogicalTable = /** @class */ (function () { exports.LogicalTable = LogicalTable; +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Models/AccessibilityModels.js": +/*!************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Models/AccessibilityModels.js ***! + \************************************************************************/ +/***/ ((__unused_webpack_module, exports) => { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +var TooltipTextRequestModel = /** @class */ (function () { + function TooltipTextRequestModel(visualIdPresModel, tupleId) { + this.visualIdPresModel = visualIdPresModel; + this.tupleId = tupleId; + } + return TooltipTextRequestModel; +}()); +exports.TooltipTextRequestModel = TooltipTextRequestModel; + + /***/ }), /***/ "../api-shared-js/lib/src/ApiShared/Models/FilterModels.js": @@ -14981,10 +15079,11 @@ var SelectTuplesInteractionModel = /** @class */ (function () { }()); exports.SelectTuplesInteractionModel = SelectTuplesInteractionModel; var HoverTupleInteractionModel = /** @class */ (function () { - function HoverTupleInteractionModel(visualIdPresModel, tupleId, tooltipContext) { + function HoverTupleInteractionModel(visualIdPresModel, tupleId, tooltipContext, allowHoverActions) { this.visualIdPresModel = visualIdPresModel; this.tupleId = tupleId; this.tooltipContext = tooltipContext; + this.allowHoverActions = allowHoverActions; } return HoverTupleInteractionModel; }()); @@ -15059,6 +15158,7 @@ var GetDataType; Object.defineProperty(exports, "__esModule", ({ value: true })); var ServiceRegistry_1 = __webpack_require__(/*! ./ServiceRegistry */ "../api-shared-js/lib/src/ApiShared/Services/ServiceRegistry.js"); +var AccessibilityServiceImpl_1 = __webpack_require__(/*! ./impl/AccessibilityServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/AccessibilityServiceImpl.js"); var AnimationServiceImpl_1 = __webpack_require__(/*! ./impl/AnimationServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/AnimationServiceImpl.js"); var AnnotationServiceImpl_1 = __webpack_require__(/*! ./impl/AnnotationServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/AnnotationServiceImpl.js"); var DataSourceServiceImpl_1 = __webpack_require__(/*! ./impl/DataSourceServiceImpl */ "../api-shared-js/lib/src/ApiShared/Services/impl/DataSourceServiceImpl.js"); @@ -15088,6 +15188,7 @@ function registerAllSharedServices(dispatcher, registryId, platformVersion) { ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new VisualModelServiceImpl_1.VisualModelServiceImpl(dispatcher, registryId)); ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new VizServiceImpl_1.VizServiceImpl(dispatcher, registryId)); ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new ExternalContextMenuServiceImpl_1.ExternalContextMenuServiceImpl(dispatcher, registryId)); + ServiceRegistry_1.ApiServiceRegistry.get(registryId).registerService(new AccessibilityServiceImpl_1.AccessibilityServiceImpl(dispatcher, registryId)); } exports.registerAllSharedServices = registerAllSharedServices; @@ -15170,6 +15271,71 @@ var ApiServiceRegistry = /** @class */ (function () { exports.ApiServiceRegistry = ApiServiceRegistry; +/***/ }), + +/***/ "../api-shared-js/lib/src/ApiShared/Services/impl/AccessibilityServiceImpl.js": +/*!************************************************************************************!*\ + !*** ../api-shared-js/lib/src/ApiShared/Services/impl/AccessibilityServiceImpl.js ***! + \************************************************************************************/ +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var api_internal_contract_js_1 = __webpack_require__(/*! @tableau/api-internal-contract-js */ "../api-internal-contract-js/lib/src/JsApiInternalContract.js"); +var AccessibilityModels_1 = __webpack_require__(/*! ../../Models/AccessibilityModels */ "../api-shared-js/lib/src/ApiShared/Models/AccessibilityModels.js"); +var ServiceImplBase_1 = __webpack_require__(/*! ./ServiceImplBase */ "../api-shared-js/lib/src/ApiShared/Services/impl/ServiceImplBase.js"); +var AccessibilityServiceImpl = /** @class */ (function (_super) { + __extends(AccessibilityServiceImpl, _super); + function AccessibilityServiceImpl() { + return _super !== null && _super.apply(this, arguments) || this; + } + Object.defineProperty(AccessibilityServiceImpl.prototype, "serviceName", { + get: function () { + return "accessibility" /* Accessibility */; + }, + enumerable: true, + configurable: true + }); + AccessibilityServiceImpl.prototype.getTooltipTextAsync = function (visualId, tupleId) { + var _a; + var tooltipTextRequest = new AccessibilityModels_1.TooltipTextRequestModel(visualId, tupleId); + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getTooltipTextAsync', + _a[api_internal_contract_js_1.ParameterId.TooltipTextRequest] = tooltipTextRequest, + _a); + return this.execute(api_internal_contract_js_1.VerbId.GetTooltipText, parameters).then(function (response) { + return response.result; + }); + }; + AccessibilityServiceImpl.prototype.leaveMarkNavigationAsync = function (visualId) { + var _a; + var parameters = (_a = {}, + _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'leaveMarkNavigationAsync', + _a[api_internal_contract_js_1.ParameterId.VisualId] = visualId, + _a); + return this.execute(api_internal_contract_js_1.VerbId.RaiseLeaveMarkNavNotification, parameters).then(function (response) { + return; + }); + }; + return AccessibilityServiceImpl; +}(ServiceImplBase_1.ServiceImplBase)); +exports.AccessibilityServiceImpl = AccessibilityServiceImpl; + + /***/ }), /***/ "../api-shared-js/lib/src/ApiShared/Services/impl/AnimationServiceImpl.js": @@ -16501,8 +16667,7 @@ var GetDataServiceImpl = /** @class */ (function (_super) { GetDataServiceImpl.prototype.getViewDataTableCacheId = function () { return this.viewDataTableCacheId; }; - GetDataServiceImpl.prototype.getLimitedMaxRows = function (requestedRows) { - var rowCountLimit = this.getMaxRowLimit() + 1; + GetDataServiceImpl.prototype.getLimitedMaxRows = function (requestedRows, rowCountLimit) { return requestedRows > 0 && requestedRows < rowCountLimit ? requestedRows : rowCountLimit; }; GetDataServiceImpl.prototype.getUnderlyingDataAsync = function (visualId, getType, ignoreAliases, ignoreSelection, includeAllColumns, columnsToIncludeById, maxRows, includeDataValuesOption) { @@ -16512,7 +16677,7 @@ var GetDataServiceImpl = /** @class */ (function (_super) { var summaryData = getType === GetDataService_1.GetDataType.Summary; var functionName = summaryData ? 'getSummaryDataAsync' : 'getUnderlyingDataAsync'; var verb = summaryData ? api_internal_contract_js_1.VerbId.GetDataSummaryData : api_internal_contract_js_1.VerbId.GetUnderlyingData; - var requestMaxRows = verb === api_internal_contract_js_1.VerbId.GetUnderlyingData ? this.getLimitedMaxRows(maxRows) : maxRows; + var requestMaxRows = verb === api_internal_contract_js_1.VerbId.GetUnderlyingData ? this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1) : maxRows; var parameters = (_a = {}, _a[api_internal_contract_js_1.ParameterId.FunctionName] = functionName, _a); @@ -16603,7 +16768,7 @@ var GetDataServiceImpl = /** @class */ (function (_super) { _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getDataSourceDataAsync', _a[api_internal_contract_js_1.ParameterId.DataSourceId] = dataSourceId, _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases, - _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows), + _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1), _a[api_internal_contract_js_1.ParameterId.ColumnsToInclude] = this.verifyIncludeColumnArray(columnsToInclude), _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById), _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption), @@ -16623,7 +16788,7 @@ var GetDataServiceImpl = /** @class */ (function (_super) { _a[api_internal_contract_js_1.ParameterId.DataSourceId] = datasourceId, _a[api_internal_contract_js_1.ParameterId.IgnoreAliases] = ignoreAliases, _a[api_internal_contract_js_1.ParameterId.LogicalTableId] = logicalTableId, - _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows), + _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1), _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption), _a); return this.execute(api_internal_contract_js_1.VerbId.GetLogicalTableData, parameters).then(function (response) { @@ -16634,6 +16799,7 @@ var GetDataServiceImpl = /** @class */ (function (_super) { GetDataServiceImpl.prototype.getLogicalTableDataReaderAsync = function (datasourceId, logicalTableId, pageRowCount, ignoreAliases, columnsToIncludeById, includeDataValuesOption) { var _a; var _this = this; + pageRowCount = this.getLimitedMaxRows(pageRowCount, this.getMaxRowLimit()); var parameters = (_a = {}, _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getLogicalTableDataReaderAsync', _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(), @@ -16660,7 +16826,7 @@ var GetDataServiceImpl = /** @class */ (function (_super) { _a[api_internal_contract_js_1.ParameterId.IgnoreSelection] = ignoreSelection, _a[api_internal_contract_js_1.ParameterId.IncludeAllColumns] = includeAllColumns, _a[api_internal_contract_js_1.ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById), - _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows), + _a[api_internal_contract_js_1.ParameterId.MaxRows] = this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1), _a[api_internal_contract_js_1.ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings_1.ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption), _a); return this.execute(api_internal_contract_js_1.VerbId.GetUnderlyingTableData, parameters).then(function (response) { @@ -16671,6 +16837,7 @@ var GetDataServiceImpl = /** @class */ (function (_super) { GetDataServiceImpl.prototype.getUnderlyingTableDataReaderAsync = function (visualId, logicalTableId, pageRowCount, ignoreAliases, ignoreSelection, includeAllColumns, columnsToIncludeById, includeDataValuesOption) { var _a; var _this = this; + pageRowCount = this.getLimitedMaxRows(pageRowCount, this.getMaxRowLimit()); var parameters = (_a = {}, _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'getUnderlyingTableDataReaderAsync', _a[api_internal_contract_js_1.ParameterId.ViewDataTableCacheId] = this.getViewDataTableCacheId(), @@ -17087,9 +17254,9 @@ var SelectionServiceImpl = /** @class */ (function (_super) { * @param tooltip * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error */ - SelectionServiceImpl.prototype.hoverTupleAsync = function (visualId, hoveredTuple, tooltip) { + SelectionServiceImpl.prototype.hoverTupleAsync = function (visualId, hoveredTuple, tooltip, allowHoverActions) { var _a; - var interactionModel = new SelectionModels_1.HoverTupleInteractionModel(visualId, hoveredTuple, tooltip); + var interactionModel = new SelectionModels_1.HoverTupleInteractionModel(visualId, this.ensureTupleIDIsNonNegative(hoveredTuple), tooltip, allowHoverActions); var parameters = (_a = {}, _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'hoverTupleAsync', _a[api_internal_contract_js_1.ParameterId.HoverTupleInteraction] = interactionModel, @@ -17110,8 +17277,7 @@ var SelectionServiceImpl = /** @class */ (function (_super) { */ SelectionServiceImpl.prototype.selectTuplesAsync = function (visualId, selectedTuples, selectOption, tooltip) { var _a; - var option = this.validateSelectOption(selectOption); - var interactionModel = new SelectionModels_1.SelectTuplesInteractionModel(visualId, selectedTuples, option, tooltip); + var interactionModel = new SelectionModels_1.SelectTuplesInteractionModel(visualId, selectedTuples, selectOption, tooltip); var parameters = (_a = {}, _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'selectTuplesAsync', _a[api_internal_contract_js_1.ParameterId.SelectTuplesInteraction] = interactionModel, @@ -17303,21 +17469,13 @@ var SelectionServiceImpl = /** @class */ (function (_super) { } return api_internal_contract_js_1.QuantitativeIncludedValues.IncludeAll; }; - /** - * Method to validate the select option. - * - * @param selectOption - */ - SelectionServiceImpl.prototype.validateSelectOption = function (selectOption) { - if (selectOption === Contract.SelectOptions.Simple) { - return api_internal_contract_js_1.SelectOptions.Simple; - } - else if (selectOption === Contract.SelectOptions.Toggle) { - return api_internal_contract_js_1.SelectOptions.Toggle; - } - else { - throw new TableauError_1.TableauError(Contract.ErrorCodes.InvalidParameter, 'Only simple and toggle select options are currently supported'); + SelectionServiceImpl.prototype.ensureTupleIDIsNonNegative = function (tupleId) { + if (tupleId && tupleId > 0) { + return tupleId; } + // 0 will not refer to a valid tuple (since tuple ids are 1-based), + // but can be used for clearing the current hover or selection + return 0; }; return SelectionServiceImpl; }(ServiceImplBase_1.ServiceImplBase)); @@ -17637,11 +17795,12 @@ var VizServiceImpl = /** @class */ (function (_super) { var _this = this; var parameters = (_a = {}, _a[api_internal_contract_js_1.ParameterId.FunctionName] = 'showCustomViewAsync', - _a[api_internal_contract_js_1.ParameterId.CustomViewName] = customViewName, + _a[api_internal_contract_js_1.ParameterId.CustomViewName] = customViewName || '', _a); return this.execute(api_internal_contract_js_1.VerbId.ShowCustomView, parameters).then(function (response) { + var _a; var customView = response.result; - return new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId); + return ((_a = customView) === null || _a === void 0 ? void 0 : _a.luid) ? new CustomViewImpl_1.CustomViewImpl(customView, _this._registryId) : undefined; }); }; VizServiceImpl.prototype.removeCustomViewAsync = function (customViewName) { @@ -18964,15 +19123,15 @@ exports.VersionedExternalApiDispatcher = VersionedExternalApiDispatcher; "use strict"; __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { -/* harmony export */ "v1": () => (/* reexport safe */ _v1_js__WEBPACK_IMPORTED_MODULE_0__["default"]), -/* harmony export */ "v3": () => (/* reexport safe */ _v3_js__WEBPACK_IMPORTED_MODULE_1__["default"]), -/* harmony export */ "v4": () => (/* reexport safe */ _v4_js__WEBPACK_IMPORTED_MODULE_2__["default"]), -/* harmony export */ "v5": () => (/* reexport safe */ _v5_js__WEBPACK_IMPORTED_MODULE_3__["default"]), -/* harmony export */ "NIL": () => (/* reexport safe */ _nil_js__WEBPACK_IMPORTED_MODULE_4__["default"]), -/* harmony export */ "version": () => (/* reexport safe */ _version_js__WEBPACK_IMPORTED_MODULE_5__["default"]), -/* harmony export */ "validate": () => (/* reexport safe */ _validate_js__WEBPACK_IMPORTED_MODULE_6__["default"]), -/* harmony export */ "stringify": () => (/* reexport safe */ _stringify_js__WEBPACK_IMPORTED_MODULE_7__["default"]), -/* harmony export */ "parse": () => (/* reexport safe */ _parse_js__WEBPACK_IMPORTED_MODULE_8__["default"]) +/* harmony export */ NIL: () => (/* reexport safe */ _nil_js__WEBPACK_IMPORTED_MODULE_4__["default"]), +/* harmony export */ parse: () => (/* reexport safe */ _parse_js__WEBPACK_IMPORTED_MODULE_8__["default"]), +/* harmony export */ stringify: () => (/* reexport safe */ _stringify_js__WEBPACK_IMPORTED_MODULE_7__["default"]), +/* harmony export */ v1: () => (/* reexport safe */ _v1_js__WEBPACK_IMPORTED_MODULE_0__["default"]), +/* harmony export */ v3: () => (/* reexport safe */ _v3_js__WEBPACK_IMPORTED_MODULE_1__["default"]), +/* harmony export */ v4: () => (/* reexport safe */ _v4_js__WEBPACK_IMPORTED_MODULE_2__["default"]), +/* harmony export */ v5: () => (/* reexport safe */ _v5_js__WEBPACK_IMPORTED_MODULE_3__["default"]), +/* harmony export */ validate: () => (/* reexport safe */ _validate_js__WEBPACK_IMPORTED_MODULE_6__["default"]), +/* harmony export */ version: () => (/* reexport safe */ _version_js__WEBPACK_IMPORTED_MODULE_5__["default"]) /* harmony export */ }); /* harmony import */ var _v1_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./v1.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/v1.js"); /* harmony import */ var _v3_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./v3.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/v3.js"); @@ -19632,8 +19791,8 @@ var v3 = (0,_v35_js__WEBPACK_IMPORTED_MODULE_0__["default"])('v3', 0x30, _md5_js "use strict"; __webpack_require__.r(__webpack_exports__); /* harmony export */ __webpack_require__.d(__webpack_exports__, { -/* harmony export */ "DNS": () => (/* binding */ DNS), -/* harmony export */ "URL": () => (/* binding */ URL), +/* harmony export */ DNS: () => (/* binding */ DNS), +/* harmony export */ URL: () => (/* binding */ URL), /* harmony export */ "default": () => (/* export default binding */ __WEBPACK_DEFAULT_EXPORT__) /* harmony export */ }); /* harmony import */ var _stringify_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./stringify.js */ "../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js"); @@ -19820,7 +19979,7 @@ function version(uuid) { /***/ ((module) => { "use strict"; -module.exports = JSON.parse('{"major":1,"minor":153,"fix":0}'); +module.exports = /*#__PURE__*/JSON.parse('{"major":1,"minor":162,"fix":0}'); /***/ }) @@ -19926,7 +20085,7 @@ __webpack_require__(/*! core-js/es/promise */ "../../node_modules/core-js/es/pro var ExtensionsImpl_1 = __webpack_require__(/*! ./ExtensionsApi/Impl/ExtensionsImpl */ "./lib/src/ExtensionsApi/Impl/ExtensionsImpl.js"); var Extensions_1 = __webpack_require__(/*! ./ExtensionsApi/Namespaces/Extensions */ "./lib/src/ExtensionsApi/Namespaces/Extensions.js"); var isAlpha = typeof VERSION_IS_ALPHA !== 'undefined' ? VERSION_IS_ALPHA : false; -api_shared_js_1.ApiVersion.SetVersionNumber( true ? "1.11.0-pre.63" : 0, isAlpha); +api_shared_js_1.ApiVersion.SetVersionNumber( true ? "1.12.0-pre.16" : 0, isAlpha); var extensionImpl = new ExtensionsImpl_1.ExtensionsImpl(); exports.extensions = new Extensions_1.Extensions(extensionImpl); // Export Enums @@ -19977,4 +20136,4 @@ exports.ZoneVisibilityType = api_external_contract_js_1.ZoneVisibilityType; window.tableau = __webpack_exports__; /******/ })() ; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tableau.extensions.1.11.0-pre.63.js","mappings":"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iD;AAC/D,0BAA0B,mBAAO,CAAC,2FAA6B;;AAE/D;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,kEAAkE,gCAAgC;AAClG,KAAK;;AAEL;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,OAAO;AACvC;AACA;AACA;;AAEA;AACA,YAAY,UAAU;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,YAAY,UAAU;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,OAAO;AACP,YAAY,UAAU;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,YAAY,SAAS;AACrB;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,UAAU,UAAU,aAAa,mCAAmC;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,mCAAmC;AACnC,qCAAqC;AACrC,eAAe;AACf,KAAK;;AAEL,UAAU,UAAU;AACpB;AACA;AACA;AACA;AACA;;;;;;;;;;;;AC3Ma;AACb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BAAoB,mBAAO,CAAC,2FAA6B;;AAEzD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,+BAA+B,MAAM,2BAA2B;AAChE;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,GAAG,KAAK,MAAM;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,eAAe;AAC7D,mBAAmB,0CAA0C;AAC7D,CAAC,sCAAsC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ,EAAE;;;;;;;;;;;ACxDF;AACA,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,uBAAuB,mBAAO,CAAC,+GAAuC;AACtE,kBAAkB,mBAAO,CAAC,yFAA4B;AACtD,iBAAiB,mBAAO,CAAC,qFAA0B;AACnD,WAAW,mBAAO,CAAC,uEAAmB;AACtC,4BAA4B,mBAAO,CAAC,6GAAsC;AAC1E,gBAAgB,mBAAO,CAAC,mFAAyB;;AAEjD;AACA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,gBAAgB;AACpB;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;;;;;;;;;;;ACjFA,kBAAkB,mBAAO,CAAC,qFAA0B;AACpD,2BAA2B,mBAAO,CAAC,2GAAqC;AACxE,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,sBAAsB,mBAAO,CAAC,iGAAgC;AAC9D,iBAAiB,mBAAO,CAAC,qFAA0B;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;AClBA,aA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O,CAAC,+GAAuC;AAC5E,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,kBAAkB,mBAAO,CAAC,qFAA0B;;AAEpD;AACA;AACA;AACA;;AAEA,uBAAuB,+CAA+C;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yBAAyB,qBAAqB;AAC9C;AACA;AACA,yBAAyB,oBAAoB;AAC7C;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;AC9BA,aAAa,mBAAO,CAAC,2EAAqB;AAC1C,YAAY,mBAAO,CAAC,2FAA6B;AACjD,WAAW,mBAAO,CAAC,yGAAoC;AACvD,iBAAiB,mBAAO,CAAC,qFAA0B;AACnD,aAAa,mBAAO,CAAC,+FAA+B;AACpD,YAAY,mBAAO,CAAC,yEAAoB;AACxC,WAAW,mBAAO,CAAC,uEAAmB;AACtC,iBAAiB,mBAAO,CAAC,qFAA0B;AACnD,oBAAoB,mBAAO,CAAC,6GAAsC;AAClE,aAAa,mBAAO,CAAC,yFAA4B;AACjD,cAAc,mBAAO,CAAC,2FAA6B;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,EAAE,gBAAgB;;AAElB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;;;;;;;;;;AChHA,0BAA0B,mBAAO,CAAC,2GAAqC;;AAEvE;AACA;;AAEA;AACA;AACA,6DAA6D;AAC7D;AACA;AACA;AACA;;;;;;;;;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hE,iCAAiC,mBAAO,CAAC,2GAAqC;AAC9E,cAAc,mBAAO,CAAC,6EAAsB;AAC5C,0BAA0B,mBAAO,CAAC,2FAA6B;AAC/D,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,sBAAsB,mBAAO,CAAC,iGAAgC;AAC9D,iBAAiB,mBAAO,CAAC,iGAAgC;AACzD,cAAc,mBAAO,CAAC,2FAA6B;AACnD,iBAAiB,mBAAO,CAAC,iGAAgC;;AAEzD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,aAAa;AACzE;AACA,uBAAuB,aAAa,gBAAgB,aAAa;AACjE;AACA;AACA;AACA,2CAA2C,aAAa;AACxD;AACA;AACA;AACA,CAAC;;AAED;AACA,0DAA0D,aAAa;AACvE,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,YAAY;AACZ,UAAU;AACV,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,eAAe;AACnB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,OAAO;AACP;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,OAAO;AACP,MAAM;AACN;AACA;AACA;AACA;AACA,IAAI;AACJ,qBAAqB,aAAa;AAClC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,OAAO,IAAI,cAAc;;AAEzB;AACA,6EAA6E,cAAc;AAC3F;;AAEA;AACA;AACA;AACA,MAAM,gBAAgB;;AAEtB;AACA;AACA;AACA;AACA;AACA;;AAEA,IAAI,0CAA0C;AAC9C;AACA,CAAC;;AAED;AACA;;AAEA;;AAEA;AACA,IAAI,6CAA6C;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED,IAAI,wDAAwD;AAC5D;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED,IAAI,0DAA0D;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA,CAAC;;;;;;;;;;;;AC7YY;AACb,aAAa,2HAA+C;AAC5D,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,0BAA0B,mBAAO,CAA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ACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mDAAmD;;AAEnD;;AAEA,oBAAoB,gBAAgB;AACpC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA,kBAAkB,cAAc;AAChC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kBAAkB,cAAc;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,aAAa;AAC/B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,iEAAe,GAAG;;;;;;;;;;;;;;;ACtNlB,iEAAe,sCAAsC;;;;;;;;;;;;;;;;ACAhB;;AAErC;AACA,OAAO,wDAAQ;AACf;AACA;;AAEA;AACA,gCAAgC;;AAEhC;AACA;AACA;AACA,qBAAqB;;AAErB;AACA,qBAAqB;;AAErB;AACA,qBAAqB;;AAErB;AACA,qBAAqB;AACrB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,iEAAe,KAAK;;;;;;;;;;;;;;;AClCpB,iEAAe,cAAc,EAAE,UAAU,EAAE,eAAe,EAAE,gBAAgB,EAAE,UAAU,GAAG,yCAAyC;;;;;;;;;;;;;;;ACApI;AACA;AACA;AACA;AACA;AACe;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;;;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,mDAAmD;;AAEnD;;AAEA,oBAAoB,gBAAgB;AACpC;AACA;AACA,IAAI;AACJ;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,mBAAmB,QAAQ;AAC3B;;AAEA,oBAAoB,QAAQ;AAC5B;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA,oBAAoB,SAAS;AAC7B;;AAEA,oBAAoB,QAAQ;AAC5B;AACA;;AAEA,sBAAsB,SAAS;AAC/B;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,sBAAsB,UAAU;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,iEAAe,IAAI;;;;;;;;;;;;;;;;AC/FkB;AACrC;AACA;AACA;AACA;;AAEA;;AAEA,gBAAgB,SAAS;AACzB;AACA;;AAEA;AACA;AACA;AACA;AACA,0gBAA0gB;AAC1gB;AACA;AACA;AACA;;AAEA,OAAO,wDAAQ;AACf;AACA;;AAEA;AACA;;AAEA,iEAAe,SAAS;;;;;;;;;;;;;;;;;AC7BG;AACY,CAAC;AACxC;AACA;AACA;;AAEA;;AAEA,eAAe;;;AAGf;AACA,oBAAoB;;AAEpB;AACA;AACA;AACA;AACA;AACA,gFAAgF;AAChF;AACA;;AAEA;AACA,sDAAsD,+CAAG;;AAEzD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;;;AAGA,wEAAwE;AACxE;;AAEA,4EAA4E;;AAE5E,8DAA8D;;AAE9D;AACA;AACA,IAAI;AACJ;;;AAGA;AACA;AACA,IAAI;;;AAGJ;AACA;AACA;;AAEA;AACA;AACA,wBAAwB;;AAExB,2BAA2B;;AAE3B;AACA;AACA;AACA;AACA,sBAAsB;;AAEtB;AACA;AACA,uBAAuB;;AAEvB,oCAAoC;;AAEpC,8BAA8B;;AAE9B,kCAAkC;;AAElC,4BAA4B;;AAE5B,kBAAkB,OAAO;AACzB;AACA;;AAEA,gBAAgB,yDAAS;AACzB;;AAEA,iEAAe,EAAE;;;;;;;;;;;;;;;;;AC9FU;AACA;AAC3B,SAAS,mDAAG,aAAa,+CAAG;AAC5B,iEAAe,EAAE;;;;;;;;;;;;;;;;;;;ACHsB;AACR;;AAE/B;AACA,2CAA2C;;AAE3C;;AAEA,kBAAkB,gBAAgB;AAClC;AACA;;AAEA;AACA;;AAEO;AACA;AACP,6BAAe,oCAAU;AACzB;AACA;AACA;AACA;;AAEA;AACA,kBAAkB,qDAAK;AACvB;;AAEA;AACA;AACA,MAAM;AACN;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,sBAAsB,QAAQ;AAC9B;AACA;;AAEA;AACA;;AAEA,WAAW,yDAAS;AACpB,IAAI;;;AAGJ;AACA,8BAA8B;AAC9B,IAAI,eAAe;;;AAGnB;AACA;AACA;AACA;;;;;;;;;;;;;;;;;AC/D2B;AACY;;AAEvC;AACA;AACA,+CAA+C,+CAAG,KAAK;;AAEvD;AACA,mCAAmC;;AAEnC;AACA;;AAEA,oBAAoB,QAAQ;AAC5B;AACA;;AAEA;AACA;;AAEA,SAAS,yDAAS;AAClB;;AAEA,iEAAe,EAAE;;;;;;;;;;;;;;;;;ACvBU;AACE;AAC7B,SAAS,mDAAG,aAAa,gDAAI;AAC7B,iEAAe,EAAE;;;;;;;;;;;;;;;;ACHc;;AAE/B;AACA,qCAAqC,sDAAU;AAC/C;;AAEA,iEAAe,QAAQ;;;;;;;;;;;;;;;;ACNc;;AAErC;AACA,OAAO,wDAAQ;AACf;AACA;;AAEA;AACA;;AAEA,iEAAe,OAAO;;;;;;;;;;;;;;;;;UCVtB;UACA;;UAEA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;UACA;;UAEA;UACA;;UAEA;UACA;UACA;;;;;WCtBA;WACA;WACA;WACA;WACA,yCAAyC,wCAAwC;WACjF;WACA;WACA;;;;;WCPA;WACA;WACA;WACA;WACA,GAAG;WACH;WACA;WACA,CAAC;;;;;WCPD;;;;;WCAA;WACA;WACA;WACA,uDAAuD,iBAAiB;WACxE;WACA,gDAAgD,aAAa;WAC7D;;;;;;;;;;;;;ACNA;;;;GAIG;;AAEH,8CAA8C;AAE9C,iHAAoD;AACpD,gGAA+B;AAC/B,gGAA+B;AAC/B,wFAAwB;AACxB,8GAAsC;AACtC,sGAAkC;AAClC,gHAAuC;AACvC,4GAAqC;AACrC,sGAAkC;AAClC,wGAAmC;AACnC,0HAA4C;AAC5C,gGAA4B;AAC5B,0FAA0F;AAC1F,4FAA4F;AAC5F,kBAAkB;AAClB,wIAAqE;AACrE,wIAAmE;AAGnE,IAAM,OAAO,GAAY,OAAO,gBAAgB,KAAK,WAAW,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,KAAK,CAAC;AAG5F,0BAAU,CAAC,gBAAgB,CAAC,KAAyC,CAAC,CAAC,CAAC,eAAkB,CAAC,CAAC,CAAC,CAAO,EAAE,OAAO,CAAC,CAAC;AAE/G,IAAM,aAAa,GAAG,IAAI,+BAAc,EAAE,CAAC;AAC9B,kBAAU,GAAG,IAAI,uBAAU,CAAC,aAAa,CAAC,CAAC;AAExD,eAAe;AACf,+EAA+E;AAC/E,yJAyC2C;AAxCzC,4EAAmB;AACnB,kEAAc;AACd,8DAAY;AACZ,0DAAU;AACV,gFAAqB;AACrB,4EAAmB;AACnB,gGAA6B;AAC7B,sDAAQ;AACR,gEAAa;AACb,4DAAW;AACX,8DAAY;AACZ,0DAAU;AACV,sEAAgB;AAChB,gEAAa;AACb,8EAAoB;AACpB,gEAAa;AACb,sEAAgB;AAChB,sEAAgB;AAChB,0DAAU;AACV,sEAAgB;AAChB,oGAA+B;AAC/B,oFAAuB;AACvB,sDAAQ;AACR,0EAAkB;AAClB,0DAAU;AACV,0EAAkB;AAElB,oEAAe;AACf,gEAAa;AACb,4EAAmB;AACnB,wDAAS;AACT,gEAAa;AACb,sEAAgB;AAChB,0EAAkB;AAClB,8EAAoB;AACpB,4EAAmB;AACnB,sGAAgC;AAChC,oFAAuB;AACvB,wFAAyB;AACzB,0EAAkB","sources":["webpack://tableau/../../node_modules/core-js/es/array/find.js","webpack://tableau/../../node_modules/core-js/es/array/from.js","webpack://tableau/../../node_modules/core-js/es/map/index.js","webpack://tableau/../../node_modules/core-js/es/number/is-integer.js","webpack://tableau/../../node_modules/core-js/es/number/is-nan.js","webpack://tableau/../../node_modules/core-js/es/number/parse-float.js","webpack://tableau/../../node_modules/core-js/es/number/parse-int.js","webpack://tableau/../../node_modules/core-js/es/object/assign.js","webpack://tableau/../../node_modules/core-js/es/object/entries.js","webpack://tableau/../../node_modules/core-js/es/object/set-prototype-of.js","webpack://tableau/../../node_modules/core-js/es/promise/index.js","webpack://tableau/../../node_modules/core-js/internals/a-callable.js","webpack://tableau/../../node_modules/core-js/internals/a-constructor.js","webpack://tableau/../../node_modules/core-js/internals/a-possible-prototype.js","webpack://tableau/../../node_modules/core-js/internals/add-to-unscopables.js","webpack://tableau/../../node_modules/core-js/internals/an-instance.js","webpack://tableau/../../node_modules/core-js/internals/an-object.js","webpack://tableau/../../node_modules/core-js/internals/array-from.js","webpack://tableau/../../node_modules/core-js/internals/array-includes.js","webpack://tableau/../../node_modules/core-js/internals/array-iteration.js","webpack://tableau/../../node_modules/core-js/internals/array-slice.js","webpack://tableau/../../node_modules/core-js/internals/array-species-constructor.js","webpack://tableau/../../node_modules/core-js/internals/array-species-create.js","webpack://tableau/../../node_modules/core-js/internals/call-with-safe-iteration-closing.js","webpack://tableau/../../node_modules/core-js/internals/check-correctness-of-iteration.js","webpack://tableau/../../node_modules/core-js/internals/classof-raw.js","webpack://tableau/../../node_modules/core-js/internals/classof.js","webpack://tableau/../../node_modules/core-js/internals/clear-error-stack.js","webpack://tableau/../../node_modules/core-js/internals/collection-strong.js","webpack://tableau/../../node_modules/core-js/internals/collection.js","webpack://tableau/../../node_modules/core-js/internals/copy-constructor-properties.js","webpack://tableau/../../node_modules/core-js/internals/correct-prototype-getter.js","webpack://tableau/../../node_modules/core-js/internals/create-iterator-constructor.js","webpack://tableau/../../node_modules/core-js/internals/create-non-enumerable-property.js","webpack://tableau/../../node_modules/core-js/internals/create-property-descriptor.js","webpack://tableau/../../node_modules/core-js/internals/create-property.js","webpack://tableau/../../node_modules/core-js/internals/define-iterator.js","webpack://tableau/../../node_modules/core-js/internals/descriptors.js","webpack://tableau/../../node_modules/core-js/internals/document-create-element.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-browser.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-ios-pebble.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-ios.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-node.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-webos-webkit.js","webpack://tableau/../../node_modules/core-js/internals/engine-user-agent.js","webpack://tableau/../../node_modules/core-js/internals/engine-v8-version.js","webpack://tableau/../../node_modules/core-js/internals/entry-unbind.js","webpack://tableau/../../node_modules/core-js/internals/enum-bug-keys.js","webpack://tableau/../../node_modules/core-js/internals/error-stack-installable.js","webpack://tableau/../../node_modules/core-js/internals/export.js","webpack://tableau/../../node_modules/core-js/internals/fails.js","webpack://tableau/../../node_modules/core-js/internals/freezing.js","webpack://tableau/../../node_modules/core-js/internals/function-apply.js","webpack://tableau/../../node_modules/core-js/internals/function-bind-context.js","webpack://tableau/../../node_modules/core-js/internals/function-call.js","webpack://tableau/../../node_modules/core-js/internals/function-name.js","webpack://tableau/../../node_modules/core-js/internals/function-uncurry-this.js","webpack://tableau/../../node_modules/core-js/internals/get-built-in.js","webpack://tableau/../../node_modules/core-js/internals/get-iterator-method.js","webpack://tableau/../../node_modules/core-js/internals/get-iterator.js","webpack://tableau/../../node_modules/core-js/internals/get-method.js","webpack://tableau/../../node_modules/core-js/internals/global.js","webpack://tableau/../../node_modules/core-js/internals/has-own-property.js","webpack://tableau/../../node_modules/core-js/internals/hidden-keys.js","webpack://tableau/../../node_modules/core-js/internals/host-report-errors.js","webpack://tableau/../../node_modules/core-js/internals/html.js","webpack://tableau/../../node_modules/core-js/internals/ie8-dom-define.js","webpack://tableau/../../node_modules/core-js/internals/indexed-object.js","webpack://tableau/../../node_modules/core-js/internals/inherit-if-required.js","webpack://tableau/../../node_modules/core-js/internals/inspect-source.js","webpack://tableau/../../node_modules/core-js/internals/install-error-cause.js","webpack://tableau/../../node_modules/core-js/internals/internal-metadata.js","webpack://tableau/../../node_modules/core-js/internals/internal-state.js","webpack://tableau/../../node_modules/core-js/internals/is-array-iterator-method.js","webpack://tableau/../../node_modules/core-js/internals/is-array.js","webpack://tableau/../../node_modules/core-js/internals/is-callable.js","webpack://tableau/../../node_modules/core-js/internals/is-constructor.js","webpack://tableau/../../node_modules/core-js/internals/is-forced.js","webpack://tableau/../../node_modules/core-js/internals/is-integral-number.js","webpack://tableau/../../node_modules/core-js/internals/is-object.js","webpack://tableau/../../node_modules/core-js/internals/is-pure.js","webpack://tableau/../../node_modules/core-js/internals/is-symbol.js","webpack://tableau/../../node_modules/core-js/internals/iterate.js","webpack://tableau/../../node_modules/core-js/internals/iterator-close.js","webpack://tableau/../../node_modules/core-js/internals/iterators-core.js","webpack://tableau/../../node_modules/core-js/internals/iterators.js","webpack://tableau/../../node_modules/core-js/internals/length-of-array-like.js","webpack://tableau/../../node_modules/core-js/internals/microtask.js","webpack://tableau/../../node_modules/core-js/internals/native-promise-constructor.js","webpack://tableau/../../node_modules/core-js/internals/native-symbol.js","webpack://tableau/../../node_modules/core-js/internals/native-weak-map.js","webpack://tableau/../../node_modules/core-js/internals/new-promise-capability.js","webpack://tableau/../../node_modules/core-js/internals/normalize-string-argument.js","webpack://tableau/../../node_modules/core-js/internals/number-parse-float.js","webpack://tableau/../../node_modules/core-js/internals/number-parse-int.js","webpack://tableau/../../node_modules/core-js/internals/object-assign.js","webpack://tableau/../../node_modules/core-js/internals/object-create.js","webpack://tableau/../../node_modules/core-js/internals/object-define-properties.js","webpack://tableau/../../node_modules/core-js/internals/object-define-property.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-descriptor.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-names-external.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-names.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-symbols.js","webpack://tableau/../../node_modules/core-js/internals/object-get-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-is-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-keys-internal.js","webpack://tableau/../../node_modules/core-js/internals/object-keys.js","webpack://tableau/../../node_modules/core-js/internals/object-property-is-enumerable.js","webpack://tableau/../../node_modules/core-js/internals/object-set-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-to-array.js","webpack://tableau/../../node_modules/core-js/internals/object-to-string.js","webpack://tableau/../../node_modules/core-js/internals/ordinary-to-primitive.js","webpack://tableau/../../node_modules/core-js/internals/own-keys.js","webpack://tableau/../../node_modules/core-js/internals/path.js","webpack://tableau/../../node_modules/core-js/internals/perform.js","webpack://tableau/../../node_modules/core-js/internals/promise-resolve.js","webpack://tableau/../../node_modules/core-js/internals/redefine-all.js","webpack://tableau/../../node_modules/core-js/internals/redefine.js","webpack://tableau/../../node_modules/core-js/internals/require-object-coercible.js","webpack://tableau/../../node_modules/core-js/internals/set-global.js","webpack://tableau/../../node_modules/core-js/internals/set-species.js","webpack://tableau/../../node_modules/core-js/internals/set-to-string-tag.js","webpack://tableau/../../node_modules/core-js/internals/shared-key.js","webpack://tableau/../../node_modules/core-js/internals/shared-store.js","webpack://tableau/../../node_modules/core-js/internals/shared.js","webpack://tableau/../../node_modules/core-js/internals/species-constructor.js","webpack://tableau/../../node_modules/core-js/internals/string-multibyte.js","webpack://tableau/../../node_modules/core-js/internals/string-trim.js","webpack://tableau/../../node_modules/core-js/internals/task.js","webpack://tableau/../../node_modules/core-js/internals/to-absolute-index.js","webpack://tableau/../../node_modules/core-js/internals/to-indexed-object.js","webpack://tableau/../../node_modules/core-js/internals/to-integer-or-infinity.js","webpack://tableau/../../node_modules/core-js/internals/to-length.js","webpack://tableau/../../node_modules/core-js/internals/to-object.js","webpack://tableau/../../node_modules/core-js/internals/to-primitive.js","webpack://tableau/../../node_modules/core-js/internals/to-property-key.js","webpack://tableau/../../node_modules/core-js/internals/to-string-tag-support.js","webpack://tableau/../../node_modules/core-js/internals/to-string.js","webpack://tableau/../../node_modules/core-js/internals/try-to-string.js","webpack://tableau/../../node_modules/core-js/internals/uid.js","webpack://tableau/../../node_modules/core-js/internals/use-symbol-as-uid.js","webpack://tableau/../../node_modules/core-js/internals/well-known-symbol.js","webpack://tableau/../../node_modules/core-js/internals/whitespaces.js","webpack://tableau/../../node_modules/core-js/modules/es.aggregate-error.js","webpack://tableau/../../node_modules/core-js/modules/es.array.find.js","webpack://tableau/../../node_modules/core-js/modules/es.array.from.js","webpack://tableau/../../node_modules/core-js/modules/es.array.iterator.js","webpack://tableau/../../node_modules/core-js/modules/es.map.js","webpack://tableau/../../node_modules/core-js/modules/es.number.is-integer.js","webpack://tableau/../../node_modules/core-js/modules/es.number.is-nan.js","webpack://tableau/../../node_modules/core-js/modules/es.number.parse-float.js","webpack://tableau/../../node_modules/core-js/modules/es.number.parse-int.js","webpack://tableau/../../node_modules/core-js/modules/es.object.assign.js","webpack://tableau/../../node_modules/core-js/modules/es.object.entries.js","webpack://tableau/../../node_modules/core-js/modules/es.object.set-prototype-of.js","webpack://tableau/../../node_modules/core-js/modules/es.object.to-string.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.all-settled.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.any.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.finally.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.js","webpack://tableau/../../node_modules/core-js/modules/es.string.iterator.js","webpack://tableau/../../node_modules/guid/guid.js","webpack://tableau/./src/ExtensionsApi/Events/DashboardLayoutChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/FilterChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/MarksSelectedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/ParameterChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/SummaryDataChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/TableauEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/TableauSheetEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/TableauWorksheetEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/WorkbookFormattingChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Impl/BentonSansFontNameConstants.ts","webpack://tableau/./src/ExtensionsApi/Impl/ConnectedServer.ts","webpack://tableau/./src/ExtensionsApi/Impl/ExtensionWorkbookImpl.ts","webpack://tableau/./src/ExtensionsApi/Impl/ExtensionsImpl.ts","webpack://tableau/./src/ExtensionsApi/Impl/LegacyInternalApiDispatcherHolder.ts","webpack://tableau/./src/ExtensionsApi/Impl/SettingsImpl.ts","webpack://tableau/./src/ExtensionsApi/Impl/TableauBookFontNameConstants.ts","webpack://tableau/./src/ExtensionsApi/Impl/UIImpl.ts","webpack://tableau/./src/ExtensionsApi/Models/Dashboard.ts","webpack://tableau/./src/ExtensionsApi/Models/DashboardObject.ts","webpack://tableau/./src/ExtensionsApi/Models/Parameter.ts","webpack://tableau/./src/ExtensionsApi/Models/Sheet.ts","webpack://tableau/./src/ExtensionsApi/Models/Workbook.ts","webpack://tableau/./src/ExtensionsApi/Models/Worksheet.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/DashboardContent.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/Environment.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/Extensions.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/Settings.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/UI.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/WorkbookFormattingEnvUtil.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/WorksheetContent.ts","webpack://tableau/./src/ExtensionsApi/Services/Impl/InitializationServiceImpl.ts","webpack://tableau/./src/ExtensionsApi/Services/Impl/SettingsServiceImpl.ts","webpack://tableau/./src/ExtensionsApi/Services/Impl/UIServiceImpl.ts","webpack://tableau/./src/ExtensionsApi/Services/RegisterAllExtensionsServices.ts","webpack://tableau/./src/ExtensionsApi/Services/ServiceRegistryUtil.ts","webpack://tableau/../api-external-contract-js/src/EmbeddingApiExternalContract.ts","webpack://tableau/../api-external-contract-js/src/ExtensionsApiExternalContract.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/AskDataInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/Enums.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/PulseInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/VizInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/WebComponentInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Extensions/Namespaces/Tableau.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Shared/Enums.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Shared/Namespaces/Tableau.ts","webpack://tableau/../api-external-contract-js/src/SharedApiExternalContract.ts","webpack://tableau/../api-internal-contract-js/src/JsApiInternalContract.ts","webpack://tableau/../api-internal-contract-js/src/contract/DataTypeConverter.ts","webpack://tableau/../api-internal-contract-js/src/contract/Enums.ts","webpack://tableau/../api-internal-contract-js/src/contract/Notifications.ts","webpack://tableau/../api-internal-contract-js/src/contract/Parameters.ts","webpack://tableau/../api-internal-contract-js/src/contract/Verbs.ts","webpack://tableau/../api-internal-contract-js/src/interface/AskDataInterface.ts","webpack://tableau/../api-internal-contract-js/src/interface/PulseInterface.ts","webpack://tableau/../api-internal-contract-js/src/interface/VqlInterface.ts","webpack://tableau/../api-internal-contract-js/src/messaging/CrossFrameMessenger.ts","webpack://tableau/../api-internal-contract-js/src/messaging/CrossFramePreparedMessage.ts","webpack://tableau/../api-internal-contract-js/src/messaging/MessageTypeChecks.ts","webpack://tableau/../api-internal-contract-js/src/messaging/interface/MessageTypes.ts","webpack://tableau/../api-internal-contract-js/src/versioning/IdentityVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/StackingVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/VersionConverterFactory.ts","webpack://tableau/../api-internal-contract-js/src/versioning/VersionTranslations.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalIdentityVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalStackingVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalVersionConverterFactory.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalVersionTranslations.ts","webpack://tableau/../api-shared-js/src/ApiShared.ts","webpack://tableau/../api-shared-js/src/ApiShared/ApiVersion.ts","webpack://tableau/../api-shared-js/src/ApiShared/ConnectionSummary.ts","webpack://tableau/../api-shared-js/src/ApiShared/CrossFrame/CrossFrameBootstrap.ts","webpack://tableau/../api-shared-js/src/ApiShared/CrossFrame/CrossFrameDispatcher.ts","webpack://tableau/../api-shared-js/src/ApiShared/DataSource.ts","webpack://tableau/../api-shared-js/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.ts","webpack://tableau/../api-shared-js/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.ts","webpack://tableau/../api-shared-js/src/ApiShared/EventListenerManager.ts","webpack://tableau/../api-shared-js/src/ApiShared/Field.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/CustomViewImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/DashboardImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/DashboardObjectImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/DataSourceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/FieldImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/ParameterImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/SheetImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/SheetInfoImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/SingleEventManagerImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/StoryImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/StoryPointImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/StoryPointInfoImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/WorkbookImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/WorksheetImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/LogicalTable.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/FilterModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/GetDataModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/GetDataTableReaderModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/SelectionModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Point.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/GetDataService.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/RegisterAllSharedServices.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/ServiceRegistry.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/AnimationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/AnnotationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ClientInfoServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/DataSourceServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ExportServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ExternalContextMenuServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/FilterServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/GetDataServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/NotificationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/NotificationServiceImplBase.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ParametersServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/SelectionServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ServiceImplBase.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/SizeServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/StoryActivationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/VisualModelServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/VizServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ZoneServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/TableSummary.ts","webpack://tableau/../api-shared-js/src/ApiShared/TableauError.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/DataValueFactory.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/Deferred.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/EnumConverter.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/ErrorHelpers.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/ExportHelpers.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/Param.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/SheetUtils.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/ShortLivedDeferred.ts","webpack://tableau/../api-shared-js/src/ApiShared/VersionNumber.ts","webpack://tableau/../api-shared-js/src/VersionedExternalApiDispatcher.ts","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/index.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/md5.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/nil.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/parse.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/regex.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/rng.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/sha1.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v1.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v3.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v35.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v4.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v5.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/validate.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/version.js","webpack://tableau/webpack/bootstrap","webpack://tableau/webpack/runtime/define property getters","webpack://tableau/webpack/runtime/global","webpack://tableau/webpack/runtime/hasOwnProperty shorthand","webpack://tableau/webpack/runtime/make namespace object","webpack://tableau/./src/ExtensionsApi.ts"],"sourcesContent":["require('../../modules/es.array.find');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('Array', 'find');\n","require('../../modules/es.string.iterator');\nrequire('../../modules/es.array.from');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Array.from;\n","require('../../modules/es.array.iterator');\nrequire('../../modules/es.map');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Map;\n","require('../../modules/es.number.is-integer');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.isInteger;\n","require('../../modules/es.number.is-nan');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.isNaN;\n","require('../../modules/es.number.parse-float');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.parseFloat;\n","require('../../modules/es.number.parse-int');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.parseInt;\n","require('../../modules/es.object.assign');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.assign;\n","require('../../modules/es.object.entries');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.entries;\n","require('../../modules/es.object.set-prototype-of');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.setPrototypeOf;\n","require('../../modules/es.aggregate-error');\nrequire('../../modules/es.array.iterator');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.promise');\nrequire('../../modules/es.promise.all-settled');\nrequire('../../modules/es.promise.any');\nrequire('../../modules/es.promise.finally');\nrequire('../../modules/es.string.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Promise;\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar TypeError = global.TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n  if (isCallable(argument)) return argument;\n  throw TypeError(tryToString(argument) + ' is not a function');\n};\n","var global = require('../internals/global');\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar TypeError = global.TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n  if (isConstructor(argument)) return argument;\n  throw TypeError(tryToString(argument) + ' is not a constructor');\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar String = global.String;\nvar TypeError = global.TypeError;\n\nmodule.exports = function (argument) {\n  if (typeof argument == 'object' || isCallable(argument)) return argument;\n  throw TypeError(\"Can't set \" + String(argument) + ' as a prototype');\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","var global = require('../internals/global');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar TypeError = global.TypeError;\n\nmodule.exports = function (it, Prototype) {\n  if (isPrototypeOf(Prototype, it)) return it;\n  throw TypeError('Incorrect invocation');\n};\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar String = global.String;\nvar TypeError = global.TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n  if (isObject(argument)) return argument;\n  throw TypeError(String(argument) + ' is not an object');\n};\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar toObject = require('../internals/to-object');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar isConstructor = require('../internals/is-constructor');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar Array = global.Array;\n\n// `Array.from` method implementation\n// https://tc39.es/ecma262/#sec-array.from\nmodule.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n  var O = toObject(arrayLike);\n  var IS_CONSTRUCTOR = isConstructor(this);\n  var argumentsLength = arguments.length;\n  var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n  var mapping = mapfn !== undefined;\n  if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);\n  var iteratorMethod = getIteratorMethod(O);\n  var index = 0;\n  var length, result, step, iterator, next, value;\n  // if the target is not iterable or it's an array with the default iterator - use a simple case\n  if (iteratorMethod && !(this == Array && isArrayIteratorMethod(iteratorMethod))) {\n    iterator = getIterator(O, iteratorMethod);\n    next = iterator.next;\n    result = IS_CONSTRUCTOR ? new this() : [];\n    for (;!(step = call(next, iterator)).done; index++) {\n      value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;\n      createProperty(result, index, value);\n    }\n  } else {\n    length = lengthOfArrayLike(O);\n    result = IS_CONSTRUCTOR ? new this(length) : Array(length);\n    for (;length > index; index++) {\n      value = mapping ? mapfn(O[index], index) : O[index];\n      createProperty(result, index, value);\n    }\n  }\n  result.length = index;\n  return result;\n};\n","var toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = lengthOfArrayLike(O);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare -- NaN check\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.includes` method\n  // https://tc39.es/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.es/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n","var bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n  var IS_MAP = TYPE == 1;\n  var IS_FILTER = TYPE == 2;\n  var IS_SOME = TYPE == 3;\n  var IS_EVERY = TYPE == 4;\n  var IS_FIND_INDEX = TYPE == 6;\n  var IS_FILTER_REJECT = TYPE == 7;\n  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;\n  return function ($this, callbackfn, that, specificCreate) {\n    var O = toObject($this);\n    var self = IndexedObject(O);\n    var boundFunction = bind(callbackfn, that);\n    var length = lengthOfArrayLike(self);\n    var index = 0;\n    var create = specificCreate || arraySpeciesCreate;\n    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n    var value, result;\n    for (;length > index; index++) if (NO_HOLES || index in self) {\n      value = self[index];\n      result = boundFunction(value, index, O);\n      if (TYPE) {\n        if (IS_MAP) target[index] = result; // map\n        else if (result) switch (TYPE) {\n          case 3: return true;              // some\n          case 5: return value;             // find\n          case 6: return index;             // findIndex\n          case 2: push(target, value);      // filter\n        } else switch (TYPE) {\n          case 4: return false;             // every\n          case 7: push(target, value);      // filterReject\n        }\n      }\n    }\n    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.forEach` method\n  // https://tc39.es/ecma262/#sec-array.prototype.foreach\n  forEach: createMethod(0),\n  // `Array.prototype.map` method\n  // https://tc39.es/ecma262/#sec-array.prototype.map\n  map: createMethod(1),\n  // `Array.prototype.filter` method\n  // https://tc39.es/ecma262/#sec-array.prototype.filter\n  filter: createMethod(2),\n  // `Array.prototype.some` method\n  // https://tc39.es/ecma262/#sec-array.prototype.some\n  some: createMethod(3),\n  // `Array.prototype.every` method\n  // https://tc39.es/ecma262/#sec-array.prototype.every\n  every: createMethod(4),\n  // `Array.prototype.find` method\n  // https://tc39.es/ecma262/#sec-array.prototype.find\n  find: createMethod(5),\n  // `Array.prototype.findIndex` method\n  // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n  findIndex: createMethod(6),\n  // `Array.prototype.filterReject` method\n  // https://github.com/tc39/proposal-array-filtering\n  filterReject: createMethod(7)\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","var global = require('../internals/global');\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar Array = global.Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n  var C;\n  if (isArray(originalArray)) {\n    C = originalArray.constructor;\n    // cross-realm fallback\n    if (isConstructor(C) && (C === Array || isArray(C.prototype))) C = undefined;\n    else if (isObject(C)) {\n      C = C[SPECIES];\n      if (C === null) C = undefined;\n    }\n  } return C === undefined ? Array : C;\n};\n","var arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","var anObject = require('../internals/an-object');\nvar iteratorClose = require('../internals/iterator-close');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n  try {\n    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n  } catch (error) {\n    iteratorClose(iterator, 'throw', error);\n  }\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n  var called = 0;\n  var iteratorWithReturn = {\n    next: function () {\n      return { done: !!called++ };\n    },\n    'return': function () {\n      SAFE_CLOSING = true;\n    }\n  };\n  iteratorWithReturn[ITERATOR] = function () {\n    return this;\n  };\n  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n  Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n  var ITERATION_SUPPORT = false;\n  try {\n    var object = {};\n    object[ITERATOR] = function () {\n      return {\n        next: function () {\n          return { done: ITERATION_SUPPORT = true };\n        }\n      };\n    };\n    exec(object);\n  } catch (error) { /* empty */ }\n  return ITERATION_SUPPORT;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n  return stringSlice(toString(it), 8, -1);\n};\n","var global = require('../internals/global');\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar Object = global.Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n  var O, tag, result;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag\n    // builtinTag case\n    : CORRECT_ARGUMENTS ? classofRaw(O)\n    // ES3 arguments fallback\n    : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar arraySlice = require('../internals/array-slice');\n\nvar replace = uncurryThis(''.replace);\nvar split = uncurryThis(''.split);\nvar join = uncurryThis([].join);\n\nvar TEST = (function (arg) { return String(Error(arg).stack); })('zxcasd');\nvar V8_OR_CHAKRA_STACK_ENTRY = /\\n\\s*at [^:]*:[^\\n]*/;\nvar IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);\nvar IS_FIREFOX_OR_SAFARI_STACK = /@[^\\n]*\\n/.test(TEST) && !/zxcasd/.test(TEST);\n\nmodule.exports = function (stack, dropEntries) {\n  if (typeof stack != 'string') return stack;\n  if (IS_V8_OR_CHAKRA_STACK) {\n    while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');\n  } else if (IS_FIREFOX_OR_SAFARI_STACK) {\n    return join(arraySlice(split(stack, '\\n'), dropEntries), '\\n');\n  } return stack;\n};\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar create = require('../internals/object-create');\nvar redefineAll = require('../internals/redefine-all');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/define-iterator');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n    var Constructor = wrapper(function (that, iterable) {\n      anInstance(that, Prototype);\n      setInternalState(that, {\n        type: CONSTRUCTOR_NAME,\n        index: create(null),\n        first: undefined,\n        last: undefined,\n        size: 0\n      });\n      if (!DESCRIPTORS) that.size = 0;\n      if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n    });\n\n    var Prototype = Constructor.prototype;\n\n    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n    var define = function (that, key, value) {\n      var state = getInternalState(that);\n      var entry = getEntry(that, key);\n      var previous, index;\n      // change existing entry\n      if (entry) {\n        entry.value = value;\n      // create new entry\n      } else {\n        state.last = entry = {\n          index: index = fastKey(key, true),\n          key: key,\n          value: value,\n          previous: previous = state.last,\n          next: undefined,\n          removed: false\n        };\n        if (!state.first) state.first = entry;\n        if (previous) previous.next = entry;\n        if (DESCRIPTORS) state.size++;\n        else that.size++;\n        // add to index\n        if (index !== 'F') state.index[index] = entry;\n      } return that;\n    };\n\n    var getEntry = function (that, key) {\n      var state = getInternalState(that);\n      // fast case\n      var index = fastKey(key);\n      var entry;\n      if (index !== 'F') return state.index[index];\n      // frozen object case\n      for (entry = state.first; entry; entry = entry.next) {\n        if (entry.key == key) return entry;\n      }\n    };\n\n    redefineAll(Prototype, {\n      // `{ Map, Set }.prototype.clear()` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.clear\n      // https://tc39.es/ecma262/#sec-set.prototype.clear\n      clear: function clear() {\n        var that = this;\n        var state = getInternalState(that);\n        var data = state.index;\n        var entry = state.first;\n        while (entry) {\n          entry.removed = true;\n          if (entry.previous) entry.previous = entry.previous.next = undefined;\n          delete data[entry.index];\n          entry = entry.next;\n        }\n        state.first = state.last = undefined;\n        if (DESCRIPTORS) state.size = 0;\n        else that.size = 0;\n      },\n      // `{ Map, Set }.prototype.delete(key)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.delete\n      // https://tc39.es/ecma262/#sec-set.prototype.delete\n      'delete': function (key) {\n        var that = this;\n        var state = getInternalState(that);\n        var entry = getEntry(that, key);\n        if (entry) {\n          var next = entry.next;\n          var prev = entry.previous;\n          delete state.index[entry.index];\n          entry.removed = true;\n          if (prev) prev.next = next;\n          if (next) next.previous = prev;\n          if (state.first == entry) state.first = next;\n          if (state.last == entry) state.last = prev;\n          if (DESCRIPTORS) state.size--;\n          else that.size--;\n        } return !!entry;\n      },\n      // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.foreach\n      // https://tc39.es/ecma262/#sec-set.prototype.foreach\n      forEach: function forEach(callbackfn /* , that = undefined */) {\n        var state = getInternalState(this);\n        var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n        var entry;\n        while (entry = entry ? entry.next : state.first) {\n          boundFunction(entry.value, entry.key, this);\n          // revert to the last existing entry\n          while (entry && entry.removed) entry = entry.previous;\n        }\n      },\n      // `{ Map, Set}.prototype.has(key)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.has\n      // https://tc39.es/ecma262/#sec-set.prototype.has\n      has: function has(key) {\n        return !!getEntry(this, key);\n      }\n    });\n\n    redefineAll(Prototype, IS_MAP ? {\n      // `Map.prototype.get(key)` method\n      // https://tc39.es/ecma262/#sec-map.prototype.get\n      get: function get(key) {\n        var entry = getEntry(this, key);\n        return entry && entry.value;\n      },\n      // `Map.prototype.set(key, value)` method\n      // https://tc39.es/ecma262/#sec-map.prototype.set\n      set: function set(key, value) {\n        return define(this, key === 0 ? 0 : key, value);\n      }\n    } : {\n      // `Set.prototype.add(value)` method\n      // https://tc39.es/ecma262/#sec-set.prototype.add\n      add: function add(value) {\n        return define(this, value = value === 0 ? 0 : value, value);\n      }\n    });\n    if (DESCRIPTORS) defineProperty(Prototype, 'size', {\n      get: function () {\n        return getInternalState(this).size;\n      }\n    });\n    return Constructor;\n  },\n  setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {\n    var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n    var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n    var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n    // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods\n    // https://tc39.es/ecma262/#sec-map.prototype.entries\n    // https://tc39.es/ecma262/#sec-map.prototype.keys\n    // https://tc39.es/ecma262/#sec-map.prototype.values\n    // https://tc39.es/ecma262/#sec-map.prototype-@@iterator\n    // https://tc39.es/ecma262/#sec-set.prototype.entries\n    // https://tc39.es/ecma262/#sec-set.prototype.keys\n    // https://tc39.es/ecma262/#sec-set.prototype.values\n    // https://tc39.es/ecma262/#sec-set.prototype-@@iterator\n    defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {\n      setInternalState(this, {\n        type: ITERATOR_NAME,\n        target: iterated,\n        state: getInternalCollectionState(iterated),\n        kind: kind,\n        last: undefined\n      });\n    }, function () {\n      var state = getInternalIteratorState(this);\n      var kind = state.kind;\n      var entry = state.last;\n      // revert to the last existing entry\n      while (entry && entry.removed) entry = entry.previous;\n      // get next entry\n      if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n        // or finish the iteration\n        state.target = undefined;\n        return { value: undefined, done: true };\n      }\n      // return step by kind\n      if (kind == 'keys') return { value: entry.key, done: false };\n      if (kind == 'values') return { value: entry.value, done: false };\n      return { value: [entry.key, entry.value], done: false };\n    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n    // `{ Map, Set }.prototype[@@species]` accessors\n    // https://tc39.es/ecma262/#sec-get-map-@@species\n    // https://tc39.es/ecma262/#sec-get-set-@@species\n    setSpecies(CONSTRUCTOR_NAME);\n  }\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar redefine = require('../internals/redefine');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n  var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n  var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n  var ADDER = IS_MAP ? 'set' : 'add';\n  var NativeConstructor = global[CONSTRUCTOR_NAME];\n  var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n  var Constructor = NativeConstructor;\n  var exported = {};\n\n  var fixMethod = function (KEY) {\n    var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n    redefine(NativePrototype, KEY,\n      KEY == 'add' ? function add(value) {\n        uncurriedNativeMethod(this, value === 0 ? 0 : value);\n        return this;\n      } : KEY == 'delete' ? function (key) {\n        return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : KEY == 'get' ? function get(key) {\n        return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : KEY == 'has' ? function has(key) {\n        return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : function set(key, value) {\n        uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n        return this;\n      }\n    );\n  };\n\n  var REPLACE = isForced(\n    CONSTRUCTOR_NAME,\n    !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n      new NativeConstructor().entries().next();\n    }))\n  );\n\n  if (REPLACE) {\n    // create collection constructor\n    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n    InternalMetadataModule.enable();\n  } else if (isForced(CONSTRUCTOR_NAME, true)) {\n    var instance = new Constructor();\n    // early implementations not supports chaining\n    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n    // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n    // most early implementations doesn't supports iterables, most modern - not close it correctly\n    // eslint-disable-next-line no-new -- required for testing\n    var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n    // for early implementations -0 and +0 not the same\n    var BUGGY_ZERO = !IS_WEAK && fails(function () {\n      // V8 ~ Chromium 42- fails only with 5+ elements\n      var $instance = new NativeConstructor();\n      var index = 5;\n      while (index--) $instance[ADDER](index, index);\n      return !$instance.has(-0);\n    });\n\n    if (!ACCEPT_ITERABLES) {\n      Constructor = wrapper(function (dummy, iterable) {\n        anInstance(dummy, NativePrototype);\n        var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n        if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n        return that;\n      });\n      Constructor.prototype = NativePrototype;\n      NativePrototype.constructor = Constructor;\n    }\n\n    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n      fixMethod('delete');\n      fixMethod('has');\n      IS_MAP && fixMethod('get');\n    }\n\n    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n    // weak collections should not contains .clear method\n    if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n  }\n\n  exported[CONSTRUCTOR_NAME] = Constructor;\n  $({ global: true, forced: Constructor != NativeConstructor }, exported);\n\n  setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n  return Constructor;\n};\n","var hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n  var keys = ownKeys(source);\n  var defineProperty = definePropertyModule.f;\n  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!hasOwn(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next) {\n  var TO_STRING_TAG = NAME + ' Iterator';\n  IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });\n  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n  Iterators[TO_STRING_TAG] = returnThis;\n  return IteratorConstructor;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n  var propertyKey = toPropertyKey(key);\n  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n  else object[propertyKey] = value;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n  createIteratorConstructor(IteratorConstructor, NAME, next);\n\n  var getIterationMethod = function (KIND) {\n    if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];\n    switch (KIND) {\n      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n    } return function () { return new IteratorConstructor(this); };\n  };\n\n  var TO_STRING_TAG = NAME + ' Iterator';\n  var INCORRECT_VALUES_NAME = false;\n  var IterablePrototype = Iterable.prototype;\n  var nativeIterator = IterablePrototype[ITERATOR]\n    || IterablePrototype['@@iterator']\n    || DEFAULT && IterablePrototype[DEFAULT];\n  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n  var CurrentIteratorPrototype, methods, KEY;\n\n  // fix native\n  if (anyNativeIterator) {\n    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n    if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n        if (setPrototypeOf) {\n          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n        } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n          redefine(CurrentIteratorPrototype, ITERATOR, returnThis);\n        }\n      }\n      // Set @@toStringTag to native iterators\n      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n      if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n    }\n  }\n\n  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n  if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n    if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n      createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n    } else {\n      INCORRECT_VALUES_NAME = true;\n      defaultIterator = function values() { return call(nativeIterator, this); };\n    }\n  }\n\n  // export additional methods\n  if (DEFAULT) {\n    methods = {\n      values: getIterationMethod(VALUES),\n      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n      entries: getIterationMethod(ENTRIES)\n    };\n    if (FORCED) for (KEY in methods) {\n      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n        redefine(IterablePrototype, KEY, methods[KEY]);\n      }\n    } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n  }\n\n  // define iterator\n  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n    redefine(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n  }\n  Iterators[NAME] = defaultIterator;\n\n  return methods;\n};\n","var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n  return EXISTS ? document.createElement(it) : {};\n};\n","module.exports = typeof window == 'object';\n","var userAgent = require('../internals/engine-user-agent');\nvar global = require('../internals/global');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && global.Pebble !== undefined;\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","var classof = require('../internals/classof-raw');\nvar global = require('../internals/global');\n\nmodule.exports = classof(global.process) == 'process';\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\n","var global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n  match = v8.split('.');\n  // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n  // but their correct versions are not interesting for us\n  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n  match = userAgent.match(/Edge\\/(\\d+)/);\n  if (!match || match[1] >= 74) {\n    match = userAgent.match(/Chrome\\/(\\d+)/);\n    if (match) version = +match[1];\n  }\n}\n\nmodule.exports = version;\n","var global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (CONSTRUCTOR, METHOD) {\n  return uncurryThis(global[CONSTRUCTOR].prototype[METHOD]);\n};\n","// IE8- don't enum bug keys\nmodule.exports = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf'\n];\n","var fails = require('../internals/fails');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = !fails(function () {\n  var error = Error('a');\n  if (!('stack' in error)) return true;\n  // eslint-disable-next-line es/no-object-defineproperty -- safe\n  Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));\n  return error.stack !== 7;\n});\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n  options.target      - name of the target object\n  options.global      - target is the global object\n  options.stat        - export as static methods of target\n  options.proto       - export as prototype methods of target\n  options.real        - real prototype method for the `pure` version\n  options.forced      - export even if the native feature is available\n  options.bind        - bind methods to the target, required for the `pure` version\n  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n  options.sham        - add a flag to not completely full polyfills\n  options.enumerable  - export as enumerable property\n  options.noTargetGet - prevent calling a getter on target\n  options.name        - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global;\n  } else if (STATIC) {\n    target = global[TARGET] || setGlobal(TARGET, {});\n  } else {\n    target = (global[TARGET] || {}).prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.noTargetGet) {\n      descriptor = getOwnPropertyDescriptor(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty == typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || (targetProperty && targetProperty.sham)) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    // extend global\n    redefine(target, key, sourceProperty, options);\n  }\n};\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n  return Object.isExtensible(Object.preventExtensions({}));\n});\n","var FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar bind = FunctionPrototype.bind;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (bind ? call.bind(apply) : function () {\n  return call.apply(apply, arguments);\n});\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n  aCallable(fn);\n  return that === undefined ? fn : bind ? bind(fn, that) : function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","var call = Function.prototype.call;\n\nmodule.exports = call.bind ? call.bind(call) : function () {\n  return call.apply(call, arguments);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n  EXISTS: EXISTS,\n  PROPER: PROPER,\n  CONFIGURABLE: CONFIGURABLE\n};\n","var FunctionPrototype = Function.prototype;\nvar bind = FunctionPrototype.bind;\nvar call = FunctionPrototype.call;\nvar callBind = bind && bind.bind(call);\n\nmodule.exports = bind ? function (fn) {\n  return fn && callBind(call, fn);\n} : function (fn) {\n  return fn && function () {\n    return call.apply(fn, arguments);\n  };\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n  return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","var classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n  if (it != undefined) return getMethod(it, ITERATOR)\n    || getMethod(it, '@@iterator')\n    || Iterators[classof(it)];\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar TypeError = global.TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n  throw TypeError(tryToString(argument) + ' is not iterable');\n};\n","var aCallable = require('../internals/a-callable');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n  var func = V[P];\n  return func == null ? undefined : aCallable(func);\n};\n","var check = function (it) {\n  return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n  // eslint-disable-next-line es/no-global-this -- safe\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  // eslint-disable-next-line no-restricted-globals -- safe\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  // eslint-disable-next-line no-new-func -- fallback\n  (function () { return this; })() || Function('return this')();\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n  return hasOwnProperty(toObject(it), key);\n};\n","module.exports = {};\n","var global = require('../internals/global');\n\nmodule.exports = function (a, b) {\n  var console = global.console;\n  if (console && console.error) {\n    arguments.length == 1 ? console.error(a) : console.error(a, b);\n  }\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- requied for testing\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a != 7;\n});\n","var global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar Object = global.Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins -- safe\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) == 'String' ? split(it, '') : Object(it);\n} : Object;\n","var isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n  var NewTarget, NewTargetPrototype;\n  if (\n    // it can work only with native `setPrototypeOf`\n    setPrototypeOf &&\n    // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n    isCallable(NewTarget = dummy.constructor) &&\n    NewTarget !== Wrapper &&\n    isObject(NewTargetPrototype = NewTarget.prototype) &&\n    NewTargetPrototype !== Wrapper.prototype\n  ) setPrototypeOf($this, NewTargetPrototype);\n  return $this;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n  store.inspectSource = function (it) {\n    return functionToString(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n","var isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\n// `InstallErrorCause` abstract operation\n// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause\nmodule.exports = function (O, options) {\n  if (isObject(options) && 'cause' in options) {\n    createNonEnumerableProperty(O, 'cause', options.cause);\n  }\n};\n","var $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar isExtensible = Object.isExtensible || function () {\n  return true;\n};\n\nvar setMetadata = function (it) {\n  defineProperty(it, METADATA, { value: {\n    objectID: 'O' + id++, // object ID\n    weakData: {}          // weak collections IDs\n  } });\n};\n\nvar fastKey = function (it, create) {\n  // return a primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!hasOwn(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMetadata(it);\n  // return object ID\n  } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n  if (!hasOwn(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMetadata(it);\n  // return the store of weak collections IDs\n  } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n  return it;\n};\n\nvar enable = function () {\n  meta.enable = function () { /* empty */ };\n  REQUIRED = true;\n  var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n  var splice = uncurryThis([].splice);\n  var test = {};\n  test[METADATA] = 1;\n\n  // prevent exposing of metadata key\n  if (getOwnPropertyNames(test).length) {\n    getOwnPropertyNamesModule.f = function (it) {\n      var result = getOwnPropertyNames(it);\n      for (var i = 0, length = result.length; i < length; i++) {\n        if (result[i] === METADATA) {\n          splice(result, i, 1);\n          break;\n        }\n      } return result;\n    };\n\n    $({ target: 'Object', stat: true, forced: true }, {\n      getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n    });\n  }\n};\n\nvar meta = module.exports = {\n  enable: enable,\n  fastKey: fastKey,\n  getWeakData: getWeakData,\n  onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n  return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n    } return state;\n  };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n  var store = shared.state || (shared.state = new WeakMap());\n  var wmget = uncurryThis(store.get);\n  var wmhas = uncurryThis(store.has);\n  var wmset = uncurryThis(store.set);\n  set = function (it, metadata) {\n    if (wmhas(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    wmset(store, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget(store, it) || {};\n  };\n  has = function (it) {\n    return wmhas(store, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return hasOwn(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return hasOwn(it, STATE);\n  };\n}\n\nmodule.exports = {\n  set: set,\n  get: get,\n  has: has,\n  enforce: enforce,\n  getterFor: getterFor\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","var classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n  return classof(argument) == 'Array';\n};\n","// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = function (argument) {\n  return typeof argument == 'function';\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.exec(noop);\n\nvar isConstructorModern = function (argument) {\n  if (!isCallable(argument)) return false;\n  try {\n    construct(noop, empty, argument);\n    return true;\n  } catch (error) {\n    return false;\n  }\n};\n\nvar isConstructorLegacy = function (argument) {\n  if (!isCallable(argument)) return false;\n  switch (classof(argument)) {\n    case 'AsyncFunction':\n    case 'GeneratorFunction':\n    case 'AsyncGeneratorFunction': return false;\n    // we can't check .prototype since constructors produced by .bind haven't it\n  } return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n};\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n  var called;\n  return isConstructorModern(isConstructorModern.call)\n    || !isConstructorModern(Object)\n    || !isConstructorModern(function () { called = true; })\n    || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","var fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value == POLYFILL ? true\n    : value == NATIVE ? false\n    : isCallable(detection) ? fails(detection)\n    : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","var isObject = require('../internals/is-object');\n\nvar floor = Math.floor;\n\n// `IsIntegralNumber` abstract operation\n// https://tc39.es/ecma262/#sec-isintegralnumber\n// eslint-disable-next-line es/no-number-isinteger -- safe\nmodule.exports = Number.isInteger || function isInteger(it) {\n  return !isObject(it) && isFinite(it) && floor(it) === it;\n};\n","var isCallable = require('../internals/is-callable');\n\nmodule.exports = function (it) {\n  return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","module.exports = false;\n","var global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Object = global.Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n  return typeof it == 'symbol';\n} : function (it) {\n  var $Symbol = getBuiltIn('Symbol');\n  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, Object(it));\n};\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar TypeError = global.TypeError;\n\nvar Result = function (stopped, result) {\n  this.stopped = stopped;\n  this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n  var that = options && options.that;\n  var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n  var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n  var INTERRUPTED = !!(options && options.INTERRUPTED);\n  var fn = bind(unboundFunction, that);\n  var iterator, iterFn, index, length, result, next, step;\n\n  var stop = function (condition) {\n    if (iterator) iteratorClose(iterator, 'normal', condition);\n    return new Result(true, condition);\n  };\n\n  var callFn = function (value) {\n    if (AS_ENTRIES) {\n      anObject(value);\n      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n    } return INTERRUPTED ? fn(value, stop) : fn(value);\n  };\n\n  if (IS_ITERATOR) {\n    iterator = iterable;\n  } else {\n    iterFn = getIteratorMethod(iterable);\n    if (!iterFn) throw TypeError(tryToString(iterable) + ' is not iterable');\n    // optimisation for array iterators\n    if (isArrayIteratorMethod(iterFn)) {\n      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n        result = callFn(iterable[index]);\n        if (result && isPrototypeOf(ResultPrototype, result)) return result;\n      } return new Result(false);\n    }\n    iterator = getIterator(iterable, iterFn);\n  }\n\n  next = iterator.next;\n  while (!(step = call(next, iterator)).done) {\n    try {\n      result = callFn(step.value);\n    } catch (error) {\n      iteratorClose(iterator, 'throw', error);\n    }\n    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n  } return new Result(false);\n};\n","var call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n  var innerResult, innerError;\n  anObject(iterator);\n  try {\n    innerResult = getMethod(iterator, 'return');\n    if (!innerResult) {\n      if (kind === 'throw') throw value;\n      return value;\n    }\n    innerResult = call(innerResult, iterator);\n  } catch (error) {\n    innerError = true;\n    innerResult = error;\n  }\n  if (kind === 'throw') throw value;\n  if (innerError) throw innerResult;\n  anObject(innerResult);\n  return value;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n  arrayIterator = [].keys();\n  // Safari 8 has buggy iterators w/o `next`\n  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n  else {\n    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n  }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () {\n  var test = {};\n  // FF44- legacy iterators case\n  return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n  redefine(IteratorPrototype, ITERATOR, function () {\n    return this;\n  });\n}\n\nmodule.exports = {\n  IteratorPrototype: IteratorPrototype,\n  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","module.exports = {};\n","var toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n  return toLength(obj.length);\n};\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\n\nvar flush, head, last, notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!queueMicrotask) {\n  flush = function () {\n    var parent, fn;\n    if (IS_NODE && (parent = process.domain)) parent.exit();\n    while (head) {\n      fn = head.fn;\n      head = head.next;\n      try {\n        fn();\n      } catch (error) {\n        if (head) notify();\n        else last = undefined;\n        throw error;\n      }\n    } last = undefined;\n    if (parent) parent.enter();\n  };\n\n  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n  if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n    toggle = true;\n    node = document.createTextNode('');\n    new MutationObserver(flush).observe(node, { characterData: true });\n    notify = function () {\n      node.data = toggle = !toggle;\n    };\n  // environments with maybe non-completely correct, but existent Promise\n  } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n    // Promise.resolve without an argument throws an error in LG WebOS 2\n    promise = Promise.resolve(undefined);\n    // workaround of WebKit ~ iOS Safari 10.1 bug\n    promise.constructor = Promise;\n    then = bind(promise.then, promise);\n    notify = function () {\n      then(flush);\n    };\n  // Node.js without promises\n  } else if (IS_NODE) {\n    notify = function () {\n      process.nextTick(flush);\n    };\n  // for other environments - macrotask based on:\n  // - setImmediate\n  // - MessageChannel\n  // - window.postMessag\n  // - onreadystatechange\n  // - setTimeout\n  } else {\n    // strange IE + webpack dev server bug - use .bind(global)\n    macrotask = bind(macrotask, global);\n    notify = function () {\n      macrotask(flush);\n    };\n  }\n}\n\nmodule.exports = queueMicrotask || function (fn) {\n  var task = { fn: fn, next: undefined };\n  if (last) last.next = task;\n  if (!head) {\n    head = task;\n    notify();\n  } last = task;\n};\n","var global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  var symbol = Symbol();\n  // Chrome 38 Symbol has incorrect toString conversion\n  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n  return !String(symbol) || !(Object(symbol) instanceof Symbol) ||\n    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n    !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(inspectSource(WeakMap));\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar PromiseCapability = function (C) {\n  var resolve, reject;\n  this.promise = new C(function ($$resolve, $$reject) {\n    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');\n    resolve = $$resolve;\n    reject = $$reject;\n  });\n  this.resolve = aCallable(resolve);\n  this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n  return new PromiseCapability(C);\n};\n","var toString = require('../internals/to-string');\n\nmodule.exports = function (argument, $default) {\n  return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);\n};\n","var global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toString = require('../internals/to-string');\nvar trim = require('../internals/string-trim').trim;\nvar whitespaces = require('../internals/whitespaces');\n\nvar charAt = uncurryThis(''.charAt);\nvar n$ParseFloat = global.parseFloat;\nvar Symbol = global.Symbol;\nvar ITERATOR = Symbol && Symbol.iterator;\nvar FORCED = 1 / n$ParseFloat(whitespaces + '-0') !== -Infinity\n  // MS Edge 18- broken with boxed symbols\n  || (ITERATOR && !fails(function () { n$ParseFloat(Object(ITERATOR)); }));\n\n// `parseFloat` method\n// https://tc39.es/ecma262/#sec-parsefloat-string\nmodule.exports = FORCED ? function parseFloat(string) {\n  var trimmedString = trim(toString(string));\n  var result = n$ParseFloat(trimmedString);\n  return result === 0 && charAt(trimmedString, 0) == '-' ? -0 : result;\n} : n$ParseFloat;\n","var global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toString = require('../internals/to-string');\nvar trim = require('../internals/string-trim').trim;\nvar whitespaces = require('../internals/whitespaces');\n\nvar $parseInt = global.parseInt;\nvar Symbol = global.Symbol;\nvar ITERATOR = Symbol && Symbol.iterator;\nvar hex = /^[+-]?0x/i;\nvar exec = uncurryThis(hex.exec);\nvar FORCED = $parseInt(whitespaces + '08') !== 8 || $parseInt(whitespaces + '0x16') !== 22\n  // MS Edge 18- broken with boxed symbols\n  || (ITERATOR && !fails(function () { $parseInt(Object(ITERATOR)); }));\n\n// `parseInt` method\n// https://tc39.es/ecma262/#sec-parseint-string-radix\nmodule.exports = FORCED ? function parseInt(string, radix) {\n  var S = trim(toString(string));\n  return $parseInt(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10));\n} : $parseInt;\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n  // should have correct order of operations (Edge bug)\n  if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n    enumerable: true,\n    get: function () {\n      defineProperty(this, 'b', {\n        value: 3,\n        enumerable: false\n      });\n    }\n  }), { b: 2 })).b !== 1) return true;\n  // should work with symbols and should have deterministic property order (V8 bug)\n  var A = {};\n  var B = {};\n  // eslint-disable-next-line es/no-symbol -- safe\n  var symbol = Symbol();\n  var alphabet = 'abcdefghijklmnopqrst';\n  A[symbol] = 7;\n  alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n  return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n  var T = toObject(target);\n  var argumentsLength = arguments.length;\n  var index = 1;\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  var propertyIsEnumerable = propertyIsEnumerableModule.f;\n  while (argumentsLength > index) {\n    var S = IndexedObject(arguments[index++]);\n    var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n    var length = keys.length;\n    var j = 0;\n    var key;\n    while (length > j) {\n      key = keys[j++];\n      if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n    }\n  } return T;\n} : $assign;\n","/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar defineProperties = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    activeXDocument = new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = typeof document != 'undefined'\n    ? document.domain && activeXDocument\n      ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n      : NullProtoObjectViaIFrame()\n    : NullProtoObjectViaActiveX(activeXDocument); // WSH\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : defineProperties(result, Properties);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var props = toIndexedObject(Properties);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n  return O;\n};\n","var global = require('../internals/global');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar TypeError = global.TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPropertyKey(P);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return $defineProperty(O, P, Attributes);\n  } catch (error) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPropertyKey(P);\n  if (IE8_DOM_DEFINE) try {\n    return $getOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n  try {\n    return $getOwnPropertyNames(it);\n  } catch (error) {\n    return arraySlice(windowNames);\n  }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n  return windowNames && classof(it) == 'Window'\n    ? getWindowNames(it)\n    : $getOwnPropertyNames(toIndexedObject(it));\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","var global = require('../internals/global');\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar Object = global.Object;\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n  var object = toObject(O);\n  if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n  var constructor = object.constructor;\n  if (isCallable(constructor) && object instanceof constructor) {\n    return constructor.prototype;\n  } return object instanceof Object ? ObjectPrototype : null;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (hasOwn(O, key = names[i++])) {\n    ~indexOf(result, key) || push(result, key);\n  }\n  return result;\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","/* eslint-disable no-proto -- safe */\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n  var CORRECT_SETTER = false;\n  var test = {};\n  var setter;\n  try {\n    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n    setter = uncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);\n    setter(test, []);\n    CORRECT_SETTER = test instanceof Array;\n  } catch (error) { /* empty */ }\n  return function setPrototypeOf(O, proto) {\n    anObject(O);\n    aPossiblePrototype(proto);\n    if (CORRECT_SETTER) setter(O, proto);\n    else O.__proto__ = proto;\n    return O;\n  };\n}() : undefined);\n","var DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\nvar propertyIsEnumerable = uncurryThis($propertyIsEnumerable);\nvar push = uncurryThis([].push);\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n  return function (it) {\n    var O = toIndexedObject(it);\n    var keys = objectKeys(O);\n    var length = keys.length;\n    var i = 0;\n    var result = [];\n    var key;\n    while (length > i) {\n      key = keys[i++];\n      if (!DESCRIPTORS || propertyIsEnumerable(O, key)) {\n        push(result, TO_ENTRIES ? [key, O[key]] : O[key]);\n      }\n    }\n    return result;\n  };\n};\n\nmodule.exports = {\n  // `Object.entries` method\n  // https://tc39.es/ecma262/#sec-object.entries\n  entries: createMethod(true),\n  // `Object.values` method\n  // https://tc39.es/ecma262/#sec-object.values\n  values: createMethod(false)\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n  return '[object ' + classof(this) + ']';\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar TypeError = global.TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n  var fn, val;\n  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","var getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = getOwnPropertyNamesModule.f(anObject(it));\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","module.exports = function (exec) {\n  try {\n    return { error: false, value: exec() };\n  } catch (error) {\n    return { error: true, value: error };\n  }\n};\n","var anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n  anObject(C);\n  if (isObject(x) && x.constructor === C) return x;\n  var promiseCapability = newPromiseCapability.f(C);\n  var resolve = promiseCapability.resolve;\n  resolve(x);\n  return promiseCapability.promise;\n};\n","var redefine = require('../internals/redefine');\n\nmodule.exports = function (target, src, options) {\n  for (var key in src) redefine(target, key, src[key], options);\n  return target;\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n  var unsafe = options ? !!options.unsafe : false;\n  var simple = options ? !!options.enumerable : false;\n  var noTargetGet = options ? !!options.noTargetGet : false;\n  var name = options && options.name !== undefined ? options.name : key;\n  var state;\n  if (isCallable(value)) {\n    if (String(name).slice(0, 7) === 'Symbol(') {\n      name = '[' + String(name).replace(/^Symbol\\(([^)]*)\\)/, '$1') + ']';\n    }\n    if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n      createNonEnumerableProperty(value, 'name', name);\n    }\n    state = enforceInternalState(value);\n    if (!state.source) {\n      state.source = TEMPLATE.join(typeof name == 'string' ? name : '');\n    }\n  }\n  if (O === global) {\n    if (simple) O[key] = value;\n    else setGlobal(key, value);\n    return;\n  } else if (!unsafe) {\n    delete O[key];\n  } else if (!noTargetGet && O[key]) {\n    simple = true;\n  }\n  if (simple) O[key] = value;\n  else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n  return isCallable(this) && getInternalState(this).source || inspectSource(this);\n});\n","var global = require('../internals/global');\n\nvar TypeError = global.TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n  return it;\n};\n","var global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n  try {\n    defineProperty(global, key, { value: value, configurable: true, writable: true });\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar definePropertyModule = require('../internals/object-define-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n  var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n  var defineProperty = definePropertyModule.f;\n\n  if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n    defineProperty(Constructor, SPECIES, {\n      configurable: true,\n      get: function () { return this; }\n    });\n  }\n};\n","var defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (it, TAG, STATIC) {\n  if (it && !hasOwn(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {\n    defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });\n  }\n};\n","var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\n","var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n","var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: '3.19.0',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\n});\n","var anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n  var C = anObject(O).constructor;\n  var S;\n  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aConstructor(S);\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n  return function ($this, pos) {\n    var S = toString(requireObjectCoercible($this));\n    var position = toIntegerOrInfinity(pos);\n    var size = S.length;\n    var first, second;\n    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n    first = charCodeAt(S, position);\n    return first < 0xD800 || first > 0xDBFF || position + 1 === size\n      || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n        ? CONVERT_TO_STRING\n          ? charAt(S, position)\n          : first\n        : CONVERT_TO_STRING\n          ? stringSlice(S, position, position + 2)\n          : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.codePointAt` method\n  // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n  codeAt: createMethod(false),\n  // `String.prototype.at` method\n  // https://github.com/mathiasbynens/String.prototype.at\n  charAt: createMethod(true)\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\nvar whitespaces = require('../internals/whitespaces');\n\nvar replace = uncurryThis(''.replace);\nvar whitespace = '[' + whitespaces + ']';\nvar ltrim = RegExp('^' + whitespace + whitespace + '*');\nvar rtrim = RegExp(whitespace + whitespace + '*$');\n\n// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation\nvar createMethod = function (TYPE) {\n  return function ($this) {\n    var string = toString(requireObjectCoercible($this));\n    if (TYPE & 1) string = replace(string, ltrim, '');\n    if (TYPE & 2) string = replace(string, rtrim, '');\n    return string;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.{ trimLeft, trimStart }` methods\n  // https://tc39.es/ecma262/#sec-string.prototype.trimstart\n  start: createMethod(1),\n  // `String.prototype.{ trimRight, trimEnd }` methods\n  // https://tc39.es/ecma262/#sec-string.prototype.trimend\n  end: createMethod(2),\n  // `String.prototype.trim` method\n  // https://tc39.es/ecma262/#sec-string.prototype.trim\n  trim: createMethod(3)\n};\n","var global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar location, defer, channel, port;\n\ntry {\n  // Deno throws a ReferenceError on `location` access without `--location` flag\n  location = global.location;\n} catch (error) { /* empty */ }\n\nvar run = function (id) {\n  if (hasOwn(queue, id)) {\n    var fn = queue[id];\n    delete queue[id];\n    fn();\n  }\n};\n\nvar runner = function (id) {\n  return function () {\n    run(id);\n  };\n};\n\nvar listener = function (event) {\n  run(event.data);\n};\n\nvar post = function (id) {\n  // old engines have not location.origin\n  global.postMessage(String(id), location.protocol + '//' + location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n  set = function setImmediate(fn) {\n    var args = arraySlice(arguments, 1);\n    queue[++counter] = function () {\n      apply(isCallable(fn) ? fn : Function(fn), undefined, args);\n    };\n    defer(counter);\n    return counter;\n  };\n  clear = function clearImmediate(id) {\n    delete queue[id];\n  };\n  // Node.js 0.8-\n  if (IS_NODE) {\n    defer = function (id) {\n      process.nextTick(runner(id));\n    };\n  // Sphere (JS game engine) Dispatch API\n  } else if (Dispatch && Dispatch.now) {\n    defer = function (id) {\n      Dispatch.now(runner(id));\n    };\n  // Browsers with MessageChannel, includes WebWorkers\n  // except iOS - https://github.com/zloirock/core-js/issues/624\n  } else if (MessageChannel && !IS_IOS) {\n    channel = new MessageChannel();\n    port = channel.port2;\n    channel.port1.onmessage = listener;\n    defer = bind(port.postMessage, port);\n  // Browsers with postMessage, skip WebWorkers\n  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n  } else if (\n    global.addEventListener &&\n    isCallable(global.postMessage) &&\n    !global.importScripts &&\n    location && location.protocol !== 'file:' &&\n    !fails(post)\n  ) {\n    defer = post;\n    global.addEventListener('message', listener, false);\n  // IE8-\n  } else if (ONREADYSTATECHANGE in createElement('script')) {\n    defer = function (id) {\n      html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n        html.removeChild(this);\n        run(id);\n      };\n    };\n  // Rest old browsers\n  } else {\n    defer = function (id) {\n      setTimeout(runner(id), 0);\n    };\n  }\n}\n\nmodule.exports = {\n  set: set,\n  clear: clear\n};\n","var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n  var integer = toIntegerOrInfinity(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n  return IndexedObject(requireObjectCoercible(it));\n};\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n  var number = +argument;\n  // eslint-disable-next-line no-self-compare -- safe\n  return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number);\n};\n","var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","var global = require('../internals/global');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar Object = global.Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n  return Object(requireObjectCoercible(argument));\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TypeError = global.TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n  if (!isObject(input) || isSymbol(input)) return input;\n  var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n  var result;\n  if (exoticToPrim) {\n    if (pref === undefined) pref = 'default';\n    result = call(exoticToPrim, input, pref);\n    if (!isObject(result) || isSymbol(result)) return result;\n    throw TypeError(\"Can't convert object to primitive value\");\n  }\n  if (pref === undefined) pref = 'number';\n  return ordinaryToPrimitive(input, pref);\n};\n","var toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n  var key = toPrimitive(argument, 'string');\n  return isSymbol(key) ? key : key + '';\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","var global = require('../internals/global');\nvar classof = require('../internals/classof');\n\nvar String = global.String;\n\nmodule.exports = function (argument) {\n  if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');\n  return String(argument);\n};\n","var global = require('../internals/global');\n\nvar String = global.String;\n\nmodule.exports = function (argument) {\n  try {\n    return String(argument);\n  } catch (error) {\n    return 'Object';\n  }\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  && !Symbol.sham\n  && typeof Symbol.iterator == 'symbol';\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar symbolFor = Symbol && Symbol['for'];\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!hasOwn(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {\n    var description = 'Symbol.' + name;\n    if (NATIVE_SYMBOL && hasOwn(Symbol, name)) {\n      WellKnownSymbolsStore[name] = Symbol[name];\n    } else if (USE_SYMBOL_AS_UID && symbolFor) {\n      WellKnownSymbolsStore[name] = symbolFor(description);\n    } else {\n      WellKnownSymbolsStore[name] = createWellKnownSymbol(description);\n    }\n  } return WellKnownSymbolsStore[name];\n};\n","// a string of all valid unicode whitespaces\nmodule.exports = '\\u0009\\u000A\\u000B\\u000C\\u000D\\u0020\\u00A0\\u1680\\u2000\\u2001\\u2002' +\n  '\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF';\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar create = require('../internals/object-create');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar clearErrorStack = require('../internals/clear-error-stack');\nvar installErrorCause = require('../internals/install-error-cause');\nvar iterate = require('../internals/iterate');\nvar normalizeStringArgument = require('../internals/normalize-string-argument');\nvar ERROR_STACK_INSTALLABLE = require('../internals/error-stack-installable');\n\nvar Error = global.Error;\nvar push = [].push;\n\nvar $AggregateError = function AggregateError(errors, message /* , options */) {\n  var that = isPrototypeOf(AggregateErrorPrototype, this) ? this : create(AggregateErrorPrototype);\n  var options = arguments.length > 2 ? arguments[2] : undefined;\n  if (setPrototypeOf) {\n    that = setPrototypeOf(new Error(undefined), getPrototypeOf(that));\n  }\n  createNonEnumerableProperty(that, 'message', normalizeStringArgument(message, ''));\n  if (ERROR_STACK_INSTALLABLE) createNonEnumerableProperty(that, 'stack', clearErrorStack(that.stack, 1));\n  installErrorCause(that, options);\n  var errorsArray = [];\n  iterate(errors, push, { that: errorsArray });\n  createNonEnumerableProperty(that, 'errors', errorsArray);\n  return that;\n};\n\nif (setPrototypeOf) setPrototypeOf($AggregateError, Error);\nelse copyConstructorProperties($AggregateError, Error);\n\nvar AggregateErrorPrototype = $AggregateError.prototype = create(Error.prototype, {\n  constructor: createPropertyDescriptor(1, $AggregateError),\n  message: createPropertyDescriptor(1, ''),\n  name: createPropertyDescriptor(1, 'AggregateError')\n});\n\n// `AggregateError` constructor\n// https://tc39.es/ecma262/#sec-aggregate-error-constructor\n$({ global: true }, {\n  AggregateError: $AggregateError\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar $find = require('../internals/array-iteration').find;\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\nvar FIND = 'find';\nvar SKIPS_HOLES = true;\n\n// Shouldn't skip holes\nif (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });\n\n// `Array.prototype.find` method\n// https://tc39.es/ecma262/#sec-array.prototype.find\n$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {\n  find: function find(callbackfn /* , that = undefined */) {\n    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables(FIND);\n","var $ = require('../internals/export');\nvar from = require('../internals/array-from');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\n\nvar INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {\n  // eslint-disable-next-line es/no-array-from -- required for testing\n  Array.from(iterable);\n});\n\n// `Array.from` method\n// https://tc39.es/ecma262/#sec-array.from\n$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {\n  from: from\n});\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n  setInternalState(this, {\n    type: ARRAY_ITERATOR,\n    target: toIndexedObject(iterated), // target\n    index: 0,                          // next index\n    kind: kind                         // kind\n  });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n  var state = getInternalState(this);\n  var target = state.target;\n  var kind = state.kind;\n  var index = state.index++;\n  if (!target || index >= target.length) {\n    state.target = undefined;\n    return { value: undefined, done: true };\n  }\n  if (kind == 'keys') return { value: index, done: false };\n  if (kind == 'values') return { value: target[index], done: false };\n  return { value: [index, target[index]], done: false };\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.es/ecma262/#sec-map-objects\ncollection('Map', function (init) {\n  return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","var $ = require('../internals/export');\nvar isIntegralNumber = require('../internals/is-integral-number');\n\n// `Number.isInteger` method\n// https://tc39.es/ecma262/#sec-number.isinteger\n$({ target: 'Number', stat: true }, {\n  isInteger: isIntegralNumber\n});\n","var $ = require('../internals/export');\n\n// `Number.isNaN` method\n// https://tc39.es/ecma262/#sec-number.isnan\n$({ target: 'Number', stat: true }, {\n  isNaN: function isNaN(number) {\n    // eslint-disable-next-line no-self-compare -- NaN check\n    return number != number;\n  }\n});\n","var $ = require('../internals/export');\nvar parseFloat = require('../internals/number-parse-float');\n\n// `Number.parseFloat` method\n// https://tc39.es/ecma262/#sec-number.parseFloat\n// eslint-disable-next-line es/no-number-parsefloat -- required for testing\n$({ target: 'Number', stat: true, forced: Number.parseFloat != parseFloat }, {\n  parseFloat: parseFloat\n});\n","var $ = require('../internals/export');\nvar parseInt = require('../internals/number-parse-int');\n\n// `Number.parseInt` method\n// https://tc39.es/ecma262/#sec-number.parseint\n// eslint-disable-next-line es/no-number-parseint -- required for testing\n$({ target: 'Number', stat: true, forced: Number.parseInt != parseInt }, {\n  parseInt: parseInt\n});\n","var $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, forced: Object.assign !== assign }, {\n  assign: assign\n});\n","var $ = require('../internals/export');\nvar $entries = require('../internals/object-to-array').entries;\n\n// `Object.entries` method\n// https://tc39.es/ecma262/#sec-object.entries\n$({ target: 'Object', stat: true }, {\n  entries: function entries(O) {\n    return $entries(O);\n  }\n});\n","var $ = require('../internals/export');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n$({ target: 'Object', stat: true }, {\n  setPrototypeOf: setPrototypeOf\n});\n","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar redefine = require('../internals/redefine');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n  redefine(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-promise.allsettled\n$({ target: 'Promise', stat: true }, {\n  allSettled: function allSettled(iterable) {\n    var C = this;\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aCallable(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        remaining++;\n        call(promiseResolve, C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'fulfilled', value: value };\n          --remaining || resolve(values);\n        }, function (error) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'rejected', reason: error };\n          --remaining || resolve(values);\n        });\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar aCallable = require('../internals/a-callable');\nvar getBuiltIn = require('../internals/get-built-in');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\nvar PROMISE_ANY_ERROR = 'No one promise resolved';\n\n// `Promise.any` method\n// https://tc39.es/ecma262/#sec-promise.any\n$({ target: 'Promise', stat: true }, {\n  any: function any(iterable) {\n    var C = this;\n    var AggregateError = getBuiltIn('AggregateError');\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aCallable(C.resolve);\n      var errors = [];\n      var counter = 0;\n      var remaining = 1;\n      var alreadyResolved = false;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyRejected = false;\n        remaining++;\n        call(promiseResolve, C, promise).then(function (value) {\n          if (alreadyRejected || alreadyResolved) return;\n          alreadyResolved = true;\n          resolve(value);\n        }, function (error) {\n          if (alreadyRejected || alreadyResolved) return;\n          alreadyRejected = true;\n          errors[index] = error;\n          --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));\n        });\n      });\n      --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar fails = require('../internals/fails');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar speciesConstructor = require('../internals/species-constructor');\nvar promiseResolve = require('../internals/promise-resolve');\nvar redefine = require('../internals/redefine');\n\n// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829\nvar NON_GENERIC = !!NativePromise && fails(function () {\n  NativePromise.prototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });\n});\n\n// `Promise.prototype.finally` method\n// https://tc39.es/ecma262/#sec-promise.prototype.finally\n$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {\n  'finally': function (onFinally) {\n    var C = speciesConstructor(this, getBuiltIn('Promise'));\n    var isFunction = isCallable(onFinally);\n    return this.then(\n      isFunction ? function (x) {\n        return promiseResolve(C, onFinally()).then(function () { return x; });\n      } : onFinally,\n      isFunction ? function (e) {\n        return promiseResolve(C, onFinally()).then(function () { throw e; });\n      } : onFinally\n    );\n  }\n});\n\n// makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromise)) {\n  var method = getBuiltIn('Promise').prototype['finally'];\n  if (NativePromise.prototype['finally'] !== method) {\n    redefine(NativePromise.prototype, 'finally', method, { unsafe: true });\n  }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar call = require('../internals/function-call');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar redefine = require('../internals/redefine');\nvar redefineAll = require('../internals/redefine-all');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar inspectSource = require('../internals/inspect-source');\nvar iterate = require('../internals/iterate');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar promiseResolve = require('../internals/promise-resolve');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar InternalStateModule = require('../internals/internal-state');\nvar isForced = require('../internals/is-forced');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_NODE = require('../internals/engine-is-node');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\nvar PROMISE = 'Promise';\n\nvar getInternalState = InternalStateModule.get;\nvar setInternalState = InternalStateModule.set;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar NativePromisePrototype = NativePromise && NativePromise.prototype;\nvar PromiseConstructor = NativePromise;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar NATIVE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\nvar SUBCLASSING = false;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\nvar FORCED = isForced(PROMISE, function () {\n  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);\n  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);\n  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n  // We can't detect it synchronously, so just check versions\n  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n  // We need Promise#finally in the pure version for preventing prototype pollution\n  if (IS_PURE && !PromisePrototype['finally']) return true;\n  // We can't use @@species feature detection in V8 since it causes\n  // deoptimization and performance degradation\n  // https://github.com/zloirock/core-js/issues/679\n  if (V8_VERSION >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false;\n  // Detect correctness of subclassing with @@species support\n  var promise = new PromiseConstructor(function (resolve) { resolve(1); });\n  var FakePromise = function (exec) {\n    exec(function () { /* empty */ }, function () { /* empty */ });\n  };\n  var constructor = promise.constructor = {};\n  constructor[SPECIES] = FakePromise;\n  SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n  if (!SUBCLASSING) return true;\n  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n  return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;\n});\n\nvar INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {\n  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });\n});\n\n// helpers\nvar isThenable = function (it) {\n  var then;\n  return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar notify = function (state, isReject) {\n  if (state.notified) return;\n  state.notified = true;\n  var chain = state.reactions;\n  microtask(function () {\n    var value = state.value;\n    var ok = state.state == FULFILLED;\n    var index = 0;\n    // variable length - can't use forEach\n    while (chain.length > index) {\n      var reaction = chain[index++];\n      var handler = ok ? reaction.ok : reaction.fail;\n      var resolve = reaction.resolve;\n      var reject = reaction.reject;\n      var domain = reaction.domain;\n      var result, then, exited;\n      try {\n        if (handler) {\n          if (!ok) {\n            if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n            state.rejection = HANDLED;\n          }\n          if (handler === true) result = value;\n          else {\n            if (domain) domain.enter();\n            result = handler(value); // can throw\n            if (domain) {\n              domain.exit();\n              exited = true;\n            }\n          }\n          if (result === reaction.promise) {\n            reject(TypeError('Promise-chain cycle'));\n          } else if (then = isThenable(result)) {\n            call(then, result, resolve, reject);\n          } else resolve(result);\n        } else reject(value);\n      } catch (error) {\n        if (domain && !exited) domain.exit();\n        reject(error);\n      }\n    }\n    state.reactions = [];\n    state.notified = false;\n    if (isReject && !state.rejection) onUnhandled(state);\n  });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n  var event, handler;\n  if (DISPATCH_EVENT) {\n    event = document.createEvent('Event');\n    event.promise = promise;\n    event.reason = reason;\n    event.initEvent(name, false, true);\n    global.dispatchEvent(event);\n  } else event = { promise: promise, reason: reason };\n  if (!NATIVE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n  call(task, global, function () {\n    var promise = state.facade;\n    var value = state.value;\n    var IS_UNHANDLED = isUnhandled(state);\n    var result;\n    if (IS_UNHANDLED) {\n      result = perform(function () {\n        if (IS_NODE) {\n          process.emit('unhandledRejection', value, promise);\n        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n      });\n      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n      state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n      if (result.error) throw result.value;\n    }\n  });\n};\n\nvar isUnhandled = function (state) {\n  return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n  call(task, global, function () {\n    var promise = state.facade;\n    if (IS_NODE) {\n      process.emit('rejectionHandled', promise);\n    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n  });\n};\n\nvar bind = function (fn, state, unwrap) {\n  return function (value) {\n    fn(state, value, unwrap);\n  };\n};\n\nvar internalReject = function (state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  state.value = value;\n  state.state = REJECTED;\n  notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  try {\n    if (state.facade === value) throw TypeError(\"Promise can't be resolved itself\");\n    var then = isThenable(value);\n    if (then) {\n      microtask(function () {\n        var wrapper = { done: false };\n        try {\n          call(then, value,\n            bind(internalResolve, wrapper, state),\n            bind(internalReject, wrapper, state)\n          );\n        } catch (error) {\n          internalReject(wrapper, error, state);\n        }\n      });\n    } else {\n      state.value = value;\n      state.state = FULFILLED;\n      notify(state, false);\n    }\n  } catch (error) {\n    internalReject({ done: false }, error, state);\n  }\n};\n\n// constructor polyfill\nif (FORCED) {\n  // 25.4.3.1 Promise(executor)\n  PromiseConstructor = function Promise(executor) {\n    anInstance(this, PromisePrototype);\n    aCallable(executor);\n    call(Internal, this);\n    var state = getInternalState(this);\n    try {\n      executor(bind(internalResolve, state), bind(internalReject, state));\n    } catch (error) {\n      internalReject(state, error);\n    }\n  };\n  PromisePrototype = PromiseConstructor.prototype;\n  // eslint-disable-next-line no-unused-vars -- required for `.length`\n  Internal = function Promise(executor) {\n    setInternalState(this, {\n      type: PROMISE,\n      done: false,\n      notified: false,\n      parent: false,\n      reactions: [],\n      rejection: false,\n      state: PENDING,\n      value: undefined\n    });\n  };\n  Internal.prototype = redefineAll(PromisePrototype, {\n    // `Promise.prototype.then` method\n    // https://tc39.es/ecma262/#sec-promise.prototype.then\n    then: function then(onFulfilled, onRejected) {\n      var state = getInternalPromiseState(this);\n      var reactions = state.reactions;\n      var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n      reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n      reaction.fail = isCallable(onRejected) && onRejected;\n      reaction.domain = IS_NODE ? process.domain : undefined;\n      state.parent = true;\n      reactions[reactions.length] = reaction;\n      if (state.state != PENDING) notify(state, false);\n      return reaction.promise;\n    },\n    // `Promise.prototype.catch` method\n    // https://tc39.es/ecma262/#sec-promise.prototype.catch\n    'catch': function (onRejected) {\n      return this.then(undefined, onRejected);\n    }\n  });\n  OwnPromiseCapability = function () {\n    var promise = new Internal();\n    var state = getInternalState(promise);\n    this.promise = promise;\n    this.resolve = bind(internalResolve, state);\n    this.reject = bind(internalReject, state);\n  };\n  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n    return C === PromiseConstructor || C === PromiseWrapper\n      ? new OwnPromiseCapability(C)\n      : newGenericPromiseCapability(C);\n  };\n\n  if (!IS_PURE && isCallable(NativePromise) && NativePromisePrototype !== Object.prototype) {\n    nativeThen = NativePromisePrototype.then;\n\n    if (!SUBCLASSING) {\n      // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n      redefine(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n        var that = this;\n        return new PromiseConstructor(function (resolve, reject) {\n          call(nativeThen, that, resolve, reject);\n        }).then(onFulfilled, onRejected);\n      // https://github.com/zloirock/core-js/issues/640\n      }, { unsafe: true });\n\n      // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\n      redefine(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });\n    }\n\n    // make `.constructor === Promise` work for native promise-based APIs\n    try {\n      delete NativePromisePrototype.constructor;\n    } catch (error) { /* empty */ }\n\n    // make `instanceof Promise` work for native promise-based APIs\n    if (setPrototypeOf) {\n      setPrototypeOf(NativePromisePrototype, PromisePrototype);\n    }\n  }\n}\n\n$({ global: true, wrap: true, forced: FORCED }, {\n  Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n\nPromiseWrapper = getBuiltIn(PROMISE);\n\n// statics\n$({ target: PROMISE, stat: true, forced: FORCED }, {\n  // `Promise.reject` method\n  // https://tc39.es/ecma262/#sec-promise.reject\n  reject: function reject(r) {\n    var capability = newPromiseCapability(this);\n    call(capability.reject, undefined, r);\n    return capability.promise;\n  }\n});\n\n$({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, {\n  // `Promise.resolve` method\n  // https://tc39.es/ecma262/#sec-promise.resolve\n  resolve: function resolve(x) {\n    return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);\n  }\n});\n\n$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {\n  // `Promise.all` method\n  // https://tc39.es/ecma262/#sec-promise.all\n  all: function all(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var $promiseResolve = aCallable(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        remaining++;\n        call($promiseResolve, C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = value;\n          --remaining || resolve(values);\n        }, reject);\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  },\n  // `Promise.race` method\n  // https://tc39.es/ecma262/#sec-promise.race\n  race: function race(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var reject = capability.reject;\n    var result = perform(function () {\n      var $promiseResolve = aCallable(C.resolve);\n      iterate(iterable, function (promise) {\n        call($promiseResolve, C, promise).then(capability.resolve, reject);\n      });\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n  setInternalState(this, {\n    type: STRING_ITERATOR,\n    string: toString(iterated),\n    index: 0\n  });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n  var state = getInternalState(this);\n  var string = state.string;\n  var index = state.index;\n  var point;\n  if (index >= string.length) return { value: undefined, done: true };\n  point = charAt(string, index);\n  state.index += point.length;\n  return { value: point, done: false };\n});\n","(function () {\n  var validator = new RegExp(\"^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$\", \"i\");\n\n  function gen(count) {\n    var out = \"\";\n    for (var i=0; i<count; i++) {\n      out += (((1+Math.random())*0x10000)|0).toString(16).substring(1);\n    }\n    return out;\n  }\n\n  function Guid(guid) {\n    if (!guid) throw new TypeError(\"Invalid argument; `value` has no value.\");\n      \n    this.value = Guid.EMPTY;\n    \n    if (guid && guid instanceof Guid) {\n      this.value = guid.toString();\n\n    } else if (guid && Object.prototype.toString.call(guid) === \"[object String]\" && Guid.isGuid(guid)) {\n      this.value = guid;\n    }\n    \n    this.equals = function(other) {\n      // Comparing string `value` against provided `guid` will auto-call\n      // toString on `guid` for comparison\n      return Guid.isGuid(other) && this.value == other;\n    };\n\n    this.isEmpty = function() {\n      return this.value === Guid.EMPTY;\n    };\n    \n    this.toString = function() {\n      return this.value;\n    };\n    \n    this.toJSON = function() {\n      return this.value;\n    };\n  };\n\n  Guid.EMPTY = \"00000000-0000-0000-0000-000000000000\";\n\n  Guid.isGuid = function(value) {\n    return value && (value instanceof Guid || validator.test(value.toString()));\n  };\n\n  Guid.create = function() {\n    return new Guid([gen(2), gen(1), gen(1), gen(1), gen(3)].join(\"-\"));\n  };\n\n  Guid.raw = function() {\n    return [gen(2), gen(1), gen(1), gen(1), gen(3)].join(\"-\");\n  };\n\n  if(typeof module != 'undefined' && module.exports) {\n    module.exports = Guid;\n  }\n  else if (typeof window != 'undefined') {\n    window.Guid = Guid;\n  }\n})();\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEvent } from './TableauEvent';\n\nexport class DashboardLayoutChangedEvent extends TableauEvent implements Contract.DashboardLayoutChangedEvent {\n  public constructor(public _dashboardLayoutChangeDetails: Contract.DashboardLayoutChangeDetails) {\n    super(Contract.TableauEventType.DashboardLayoutChanged);\n  }\n\n  public get dashboardLayoutChangeDetails(): Contract.DashboardLayoutChangeDetails {\n    return this._dashboardLayoutChangeDetails;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauError } from '@tableau/api-shared-js';\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\n\nexport class FilterChangedEvent extends TableauWorksheetEvent implements Contract.FilterChangedEvent {\n  public constructor(worksheet: Contract.ExtensionWorksheet, private _fieldName: string, private _fieldId?: string) {\n    super(TableauEventType.FilterChanged, worksheet);\n  }\n\n  public get fieldName(): string {\n    return this._fieldName;\n  }\n\n  public get fieldId(): string | undefined {\n    return this._fieldId;\n  }\n\n  public getFilterAsync(): Promise<Contract.Filter> {\n    return this._worksheet.getFiltersAsync().then<Contract.Filter>((filters) => {\n      // TODO: Filtering of the filters should eventually be done platform side.\n      const eventedFilter = this.fieldId\n        ? filters.find((filter) => filter.fieldId === this.fieldId, this)\n        : filters.find((filter) => filter.fieldName === this.fieldName, this);\n\n      if (!eventedFilter) {\n        // We shouldn't hit this unless the filter was removed from the worksheet\n        // after the event was raised.\n        throw new TableauError(ErrorCodes.MissingFilter, `cannot find filter: ${this._fieldName}`);\n      }\n\n      return eventedFilter;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\n\nexport class MarksSelectedEvent extends TableauWorksheetEvent implements Contract.MarksSelectedEvent {\n  public constructor(worksheet: Contract.ExtensionWorksheet) {\n    super(TableauEventType.MarkSelectionChanged, worksheet);\n  }\n\n  public getMarksAsync(): Promise<Contract.MarksCollection> {\n    return this.worksheet.getSelectedMarksAsync();\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, TableauEventType } from '@tableau/api-external-contract-js';\nimport { ApiServiceRegistry, ParametersService, ServiceNames, TableauError } from '@tableau/api-shared-js';\nimport { Parameter } from '../Models/Parameter';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { TableauSheetEvent } from './TableauSheetEvent';\n\nexport class ParameterChangedEvent extends TableauSheetEvent implements Contract.ParameterChangedEvent {\n  public constructor(private _globalFieldName: string, sheet: Contract.ExtensionSheet) {\n    super(TableauEventType.ParameterChanged, sheet);\n  }\n\n  public getParameterAsync(): Promise<Contract.Parameter> {\n    // Call down to our service to get the parameter back via its field name\n    const service = ApiServiceRegistry.get(ExtensionsRegistryId).getService<ParametersService>(ServiceNames.Parameters);\n    return service.findParameterByGlobalFieldNameAsync(this._globalFieldName).then((parameterImpl) => {\n      if (parameterImpl === undefined) {\n        throw new TableauError(ErrorCodes.MissingParameter, `Cannot find parameter: ${this._globalFieldName}`);\n      }\n\n      return new Parameter(parameterImpl, this.sheet);\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\n\nexport class SummaryDataChangedEvent extends TableauWorksheetEvent implements Contract.SummaryDataChangedEvent {\n  public constructor(worksheet: Contract.ExtensionWorksheet) {\n    super(TableauEventType.SummaryDataChanged, worksheet);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\n\nexport class TableauEvent implements Contract.TableauEvent {\n  private _type: TableauEventType;\n\n  public constructor(type: TableauEventType) {\n    this._type = type;\n  }\n\n  public get type(): TableauEventType {\n    return this._type;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauEvent } from './TableauEvent';\n\nexport class TableauSheetEvent extends TableauEvent implements Contract.TableauSheetEvent {\n  private _sheet: Contract.ExtensionSheet;\n\n  public get sheet(): Contract.ExtensionSheet {\n    return this._sheet;\n  }\n\n  public constructor(type: TableauEventType, sheet: Contract.ExtensionSheet) {\n    super(type);\n\n    this._sheet = sheet;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauSheetEvent } from './TableauSheetEvent';\n\nexport class TableauWorksheetEvent extends TableauSheetEvent implements Contract.TableauWorksheetEvent {\n  public get worksheet(): Contract.ExtensionWorksheet {\n    return this._worksheet;\n  }\n\n  public constructor(type: TableauEventType, protected _worksheet: Contract.ExtensionWorksheet) {\n    super(type, _worksheet);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEvent } from './TableauEvent';\n\nexport class WorkbookFormattingChangedEvent extends TableauEvent implements Contract.WorkbookFormattingChangedEvent {\n  public constructor(private _formatting: Contract.WorkbookFormatting) {\n    super(Contract.TableauEventType.WorkbookFormattingChanged);\n  }\n\n  public get formatting(): Contract.WorkbookFormatting {\n    return this._formatting;\n  }\n}\n","import { Model } from '@tableau/api-internal-contract-js';\n\nexport const BentonSansFontFamilyName = 'Benton Sans';\nexport const BentonSansLowDPIFontFamilyName = 'Benton Sans Low-DPI';\n\nexport const BentonSansBookFontFaceName = 'Benton Sans Book';\nexport const BentonSansBookItalicFontFaceName = 'Benton Sans Book Italic';\nexport const BentonSansSemiDemiFontFaceName = 'Benton Sans SemiDemi';\nexport const BentonSansSemiDemiItalicFontFaceName = 'Benton Sans SemiDemi Italic';\nexport const BentonSansLightFontFaceName = 'Benton Sans Light';\nexport const BentonSansMediumFontFaceName = 'Benton Sans Medium';\n\nexport const SupportedBentonSansFontFaces: Model[] = [\n  BentonSansBookFontFaceName,\n  BentonSansBookItalicFontFaceName,\n  BentonSansSemiDemiFontFaceName,\n  BentonSansSemiDemiItalicFontFaceName,\n  BentonSansLightFontFaceName,\n  BentonSansMediumFontFaceName,\n];\n","import * as Contract from '@tableau/api-external-contract-js';\n\nexport class ConnectedServer implements Contract.ConnectedServer {\n  public constructor(\n    protected _userId?: string,\n    protected _siteId?: string,\n    protected _siteNamespace?: string,\n    protected _workbookId?: string,\n  ) {}\n\n  public get userId(): string | undefined {\n    return this._userId;\n  }\n\n  public get siteId(): string | undefined {\n    return this._siteId;\n  }\n\n  public get siteNamespace(): string | undefined {\n    return this._siteNamespace;\n  }\n\n  public get workbookId(): string | undefined {\n    return this._workbookId;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataSchema, DataSource as DataSourceInfo } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, DataSource, DataSourceImpl, DataSourceService, ServiceNames, WorkbookImpl } from '@tableau/api-shared-js';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\n\nexport class ExtensionWorkbookImpl extends WorkbookImpl {\n  public getAllDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    const service = ApiServiceRegistry.get(ExtensionsRegistryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return service.getAllDataSourcesAsync().then<Array<Contract.DataSource>>((result) => {\n      const dataSchema: DataSchema = result;\n      const dataSources: Array<Contract.DataSource> = [];\n\n      // Loop through all data sources and add them.\n      Object.values(dataSchema.dataSources).forEach((ds) => {\n        dataSources.push(this.createDataSourceFromInfo(ds));\n      });\n\n      return dataSources;\n    });\n  }\n\n  private createDataSourceFromInfo(dataSourceInfo: DataSourceInfo): DataSource {\n    const dataSourceImpl = new DataSourceImpl(dataSourceInfo, ExtensionsRegistryId);\n    const dataSource = new DataSource(dataSourceImpl);\n    dataSourceImpl.initializeWithPublicInterfaces(dataSource);\n    return dataSource;\n  }\n}\n","import { ErrorCodes, SheetType } from '@tableau/api-external-contract-js';\nimport {\n  ContextMenuEvent,\n  DashboardExtensionLocator,\n  ExecuteParameters,\n  ExtensionDashboardInfo,\n  ExtensionLocator,\n  ExtensionSettingsInfo,\n  ExtensionWorksheetInfo,\n  FontNameAndInfo,\n  FormattingSheet,\n  INTERNAL_CONTRACT_VERSION,\n  InitializationOptions,\n  InternalApiDispatcher,\n  InternalApiDispatcherFactory,\n  Model,\n  NotificationId,\n  ParameterId,\n  SheetPath,\n  VerbId,\n  WorkbookFormatting,\n} from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  ApiVersion,\n  DashboardImpl,\n  NotificationService,\n  ServiceNames,\n  SheetInfoImpl,\n  TableauError,\n  VersionedExternalApiDispatcher,\n  VizService,\n  WorksheetImpl,\n  doCrossFrameBootstrap,\n  registerAllSharedServices,\n} from '@tableau/api-shared-js';\nimport { Dashboard } from '../Models/Dashboard';\nimport { Workbook } from '../Models/Workbook';\nimport { Worksheet } from '../Models/Worksheet';\nimport { DashboardContent } from '../Namespaces/DashboardContent';\nimport { Environment } from '../Namespaces/Environment';\nimport { Settings } from '../Namespaces/Settings';\nimport { UI } from '../Namespaces/UI';\nimport { WorksheetContent } from '../Namespaces/WorksheetContent';\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\nimport { InitializationService } from '../Services/InitializationService';\nimport { registerAllExtensionsServices, registerInitializationExtensionsServices } from '../Services/RegisterAllExtensionsServices';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { UIService } from '../Services/UIService';\nimport {\n  BentonSansBookFontFaceName,\n  BentonSansBookItalicFontFaceName,\n  BentonSansFontFamilyName,\n  BentonSansLightFontFaceName,\n  BentonSansLowDPIFontFamilyName,\n  BentonSansMediumFontFaceName,\n  BentonSansSemiDemiFontFaceName,\n  BentonSansSemiDemiItalicFontFaceName,\n  SupportedBentonSansFontFaces,\n} from './BentonSansFontNameConstants';\nimport { ExtensionWorkbookImpl } from './ExtensionWorkbookImpl';\nimport { LegacyInternalApiDispatcherHolder } from './LegacyInternalApiDispatcherHolder';\nimport { SettingsImpl } from './SettingsImpl';\nimport {\n  SupportedTableauFontFaces,\n  TableauBoldFontFaceName,\n  TableauBoldFontFamilyName,\n  TableauBookFontFaceName,\n  TableauBookFontFamilyName,\n  TableauLightFontFaceName,\n  TableauLightFontFamilyName,\n  TableauMediumFontFaceName,\n  TableauMediumFontFamilyName,\n  TableauRegularFontFaceName,\n  TableauRegularFontFamilyName,\n  TableauSemiBoldFontFaceName,\n  TableauSemiboldFontFamilyName,\n} from './TableauBookFontNameConstants';\nimport { UIImpl } from './UIImpl';\n\nexport type CallbackMap = { [key: string]: () => Record<string, unknown> };\n\nexport class ExtensionsImpl {\n  private _initializationPromise: Promise<string>;\n  private _styleElement: HTMLStyleElement;\n  public dashboardContent?: DashboardContent;\n  public worksheetContent?: WorksheetContent;\n  public environment: Environment;\n  public settings: Settings;\n  public ui: UI;\n  public workbook: Workbook;\n  public extensionZoneId: number;\n\n  public initializeAsync(isExtensionDialog: boolean, contextMenuCallbacks?: CallbackMap): Promise<string> {\n    if (!this._initializationPromise) {\n      this._initializationPromise = new Promise<string>((resolve, reject) => {\n        const initOptions: InitializationOptions = { isAlpha: ApiVersion.Instance.isAlpha };\n        // First thing we want to do is check to see if there is a desktop dispatcher already registered for us\n        if (LegacyInternalApiDispatcherHolder.hasDesktopApiDispatcherPromise(initOptions)) {\n          // Running in a pre-2019.3 desktop, use our legacy dispatcher promise\n          const desktopDispatcherPromise = LegacyInternalApiDispatcherHolder.getDesktopDispatcherPromise(initOptions);\n          desktopDispatcherPromise\n            ?.then((dispatcherFactory) => this.onDispatcherReceived(dispatcherFactory, isExtensionDialog, contextMenuCallbacks))\n            .then((openPayload) => {\n              resolve(openPayload);\n            })\n            .catch((error) => {\n              reject(error);\n            });\n        } else {\n          // We must be running in server, so we should try to kick of the server dispatcher bootstrapping\n          const onDispatcherReceivedCallback = this.onDispatcherReceived.bind(this);\n          doCrossFrameBootstrap(window, INTERNAL_CONTRACT_VERSION, initOptions)\n            .then((factory: InternalApiDispatcherFactory) => {\n              return onDispatcherReceivedCallback(factory, isExtensionDialog, contextMenuCallbacks);\n            })\n            .then((openPayload) => {\n              resolve(openPayload);\n            })\n            .catch((error) => {\n              reject(error);\n            });\n        }\n      });\n    }\n\n    return this._initializationPromise;\n  }\n\n  public createVizImageAsync(inputSpec: object): Promise<string> {\n    const vizService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<VizService>(ServiceNames.Viz);\n\n    return vizService.createVizImageAsync(inputSpec);\n  }\n\n  public setClickThroughAsync(clickThroughEnabled: boolean): Promise<void> {\n    const uiService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<UIService>(ExtensionsServiceNames.UIService);\n\n    return uiService.setClickThroughAsync(clickThroughEnabled, this.extensionZoneId);\n  }\n\n  private isDashboardExtensionLocator(locator: ExtensionLocator): locator is DashboardExtensionLocator {\n    const dashboardExtensionLocator = locator as DashboardExtensionLocator;\n    if (!dashboardExtensionLocator.dashboardPath) {\n      throw new TableauError(ErrorCodes.InternalError, 'Unexpected error during initialization.');\n    }\n    return true;\n  }\n\n  private onDispatcherReceived(\n    dispatcherFactory: InternalApiDispatcherFactory,\n    isExtensionDialog: boolean,\n    contextMenuFunctions?: CallbackMap,\n  ): Promise<string> {\n    let dispatcher: InternalApiDispatcher = dispatcherFactory(INTERNAL_CONTRACT_VERSION);\n\n    // Call to register all the services which will use the newly initialized dispatcher\n    registerInitializationExtensionsServices(dispatcher);\n\n    // Get the initialization service and initialize this extension\n    const initializationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<InitializationService>(\n      ExtensionsServiceNames.InitializationService,\n    );\n\n    const callbackMapKeys = contextMenuFunctions ? Object.keys(contextMenuFunctions) : [];\n    return initializationService.initializeDashboardExtensionsAsync(isExtensionDialog, callbackMapKeys).then<string>((result) => {\n      // If we receive an invalid plaform version, this means that platform is runnning 1.4 or 2.1 and\n      // doesn't pass the platform version to external. In this case we assume the platform version to be 1.9\n      const platformVersion = result.extensionEnvironment.platformVersion\n        ? result.extensionEnvironment.platformVersion\n        : { major: 1, minor: 9, fix: 0 };\n\n      // Wrap our existing dispatcher in a dispatcher that can downgrade/upgrade for an older platform.\n      if (VersionedExternalApiDispatcher.needsVersionConverter(platformVersion)) {\n        dispatcher = new VersionedExternalApiDispatcher(dispatcher, platformVersion);\n      }\n      // Registration of services must happen before initializing content and environment\n      // Extensions doesn't need to pass in a registryId. By default, the service registry instance is associated with registryId=0.\n      registerAllSharedServices(dispatcher, ExtensionsRegistryId, platformVersion);\n      registerAllExtensionsServices(dispatcher);\n\n      if (result.extensionDashboardInfo && this.isDashboardExtensionLocator(result.extensionInstance.locator)) {\n        this.dashboardContent = this.initializeDashboardContent(\n          result.extensionDashboardInfo,\n          result.extensionInstance.locator.dashboardPath,\n        );\n        this.extensionZoneId = result.extensionDashboardInfo.extensionZoneId;\n      }\n\n      if (result.extensionWorksheetInfo) {\n        this.worksheetContent = this.initializeWorksheetContent(result.extensionWorksheetInfo);\n      }\n\n      this.environment = new Environment(result.extensionEnvironment);\n      this.settings = this.initializeSettings(result.extensionSettingsInfo);\n      this.ui = new UI(new UIImpl());\n      this.workbook = new Workbook(new ExtensionWorkbookImpl());\n\n      if (result.extensionEnvironment.workbookFormatting) {\n        this.initializeTableauFonts(dispatcher, result.extensionEnvironment.workbookFormatting);\n        this.applyAllFormatting(result.extensionEnvironment.workbookFormatting);\n      }\n\n      // After initialization has completed, setup listeners for the callback functions that\n      // are meant to be triggered whenever a context menu item is clicked.\n      this.initializeContextMenuCallbacks(contextMenuFunctions);\n\n      // Also set up listeners for ExtensionStylesChangedEvent\n      this.initializeWorkbookFormattingChangedEventCallback(dispatcher);\n\n      // In the normal initialization case, this will be an empty string.  When returning from initializeAsync to the\n      // developer, we just ingore that string.  In the case of initializing from an extension dialog, this string\n      // is an optional payload sent from the parent extension.\n      return result.extensionDialogPayload;\n    });\n  }\n\n  public applyAllFormatting(formattingModel: WorkbookFormatting | undefined): void {\n    if (!this._styleElement) {\n      this._styleElement = document.createElement('style');\n      this._styleElement.id = 'Tableau-Extension-Formatting';\n      document.head.appendChild(this._styleElement);\n    }\n\n    if (!this._styleElement.sheet || !formattingModel) {\n      return;\n    }\n\n    const stylesheet: CSSStyleSheet = this._styleElement.sheet as CSSStyleSheet;\n    while (stylesheet.cssRules.length > 0) {\n      stylesheet.deleteRule(stylesheet.cssRules.length - 1);\n    }\n    formattingModel.formattingSheets.map((currentFormattingSheet) => {\n      this.applyFormattingSheetToStyleSheet(currentFormattingSheet, stylesheet);\n    });\n  }\n\n  private applyFormattingSheetToStyleSheet(currentFormattingSheet: FormattingSheet, stylesheet: CSSStyleSheet): void {\n    let styleInfo = '';\n\n    const cssProperties = currentFormattingSheet.cssProperties;\n    if (cssProperties.fontFamily) {\n      styleInfo += 'font-family: ' + cssProperties.fontFamily.toString() + '; ';\n    }\n\n    if (cssProperties.fontSize) {\n      styleInfo += 'font-size: ' + cssProperties.fontSize.toString() + '; ';\n    }\n\n    if (cssProperties.fontWeight) {\n      styleInfo += 'font-weight: ' + cssProperties.fontWeight.toString() + '; ';\n    }\n\n    if (cssProperties.fontStyle) {\n      styleInfo += 'font-style: ' + cssProperties.fontStyle.toString() + '; ';\n    }\n\n    if (cssProperties.textDecoration) {\n      styleInfo += 'text-decoration: ' + cssProperties.textDecoration.toString() + '; ';\n    }\n\n    if (cssProperties.color) {\n      styleInfo += 'color: ' + cssProperties.color + '; ';\n    }\n\n    const selector: string = '.' + currentFormattingSheet.classNameKey;\n    const rule: string = selector + ' { ' + styleInfo + ' }';\n    stylesheet.insertRule(rule, stylesheet.cssRules.length);\n  }\n\n  private initializeWorkbookFormattingChangedEventCallback(dispatcher: InternalApiDispatcher): void {\n    const notificationService: NotificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(\n      ServiceNames.Notification,\n    );\n    // Unregister function not used since these notifications should be\n    // observed for the full lifetime of the extension.\n    notificationService.registerHandler(\n      NotificationId.WorkbookFormattingChanged,\n      () => true,\n      (eventFormatting: WorkbookFormatting) => {\n        if (eventFormatting) {\n          this.initializeTableauFonts(dispatcher, eventFormatting);\n          this.applyAllFormatting(eventFormatting);\n        }\n      },\n    );\n  }\n\n  private initializeTableauFonts(dispatcher: InternalApiDispatcher, workbookFormatting: WorkbookFormatting): void {\n    const fontNames: Model[] = [...SupportedBentonSansFontFaces, ...SupportedTableauFontFaces];\n    workbookFormatting.formattingSheets.forEach((formattingSheet) => {\n      if (formattingSheet.cssProperties.fontFamily) {\n        fontNames.push(formattingSheet.cssProperties.fontFamily);\n      }\n    });\n\n    if (fontNames.length > 0) {\n      const parameters: ExecuteParameters = { [ParameterId.FontNameListItems]: fontNames };\n      dispatcher\n        .execute(VerbId.GetFonts, parameters)\n        .then((response) => {\n          this.loadFonts(response.result as Array<FontNameAndInfo>);\n        })\n        .catch();\n    }\n  }\n\n  private loadFonts(fonts: Array<FontNameAndInfo>): void {\n    fonts.forEach((fontNameAndInfo) => {\n      if (SupportedTableauFontFaces.includes(fontNameAndInfo.fontName)) {\n        this.loadTableauFonts(fontNameAndInfo);\n      } else if (SupportedBentonSansFontFaces.includes(fontNameAndInfo.fontName)) {\n        this.loadBentonSansFonts(fontNameAndInfo);\n      } else {\n        document.fonts.add(new FontFace(fontNameAndInfo.fontName, fontNameAndInfo.fontBinaryInfo));\n      }\n    });\n  }\n\n  private initializeDashboardContent(info: ExtensionDashboardInfo, sheetPath: SheetPath): DashboardContent {\n    // sheets are always active for Extensions\n    const sheetInfoImpl = new SheetInfoImpl(info.name, SheetType.Dashboard, { width: info.size.w, height: info.size.h }, undefined, true);\n    const dashboardImpl = new DashboardImpl(sheetInfoImpl, info.zones, sheetPath, ExtensionsRegistryId, null, info.activeDashboardObjectId);\n    const dashboard = new Dashboard(dashboardImpl);\n    return new DashboardContent(dashboard);\n  }\n\n  private initializeWorksheetContent(info: ExtensionWorksheetInfo): WorksheetContent {\n    const sheetInfoImpl = new SheetInfoImpl(\n      info.visualId.worksheet,\n      SheetType.Worksheet,\n      { width: info.size.w, height: info.size.h },\n      undefined, // index property is embedding specific\n      true, // sheets are always active for Extensions\n    );\n\n    const worksheetImpl = new WorksheetImpl(\n      sheetInfoImpl,\n      ExtensionsRegistryId,\n      info.visualId,\n      null, // parentDashboard is always null for worksheet in WorksheetContent\n      null, // parentStoryPoint is only used for embedding\n    );\n    const worksheet = new Worksheet(worksheetImpl);\n    return new WorksheetContent(worksheet);\n  }\n\n  private initializeSettings(settingsInfo: ExtensionSettingsInfo): Settings {\n    const settingsImpl = new SettingsImpl(settingsInfo);\n    return new Settings(settingsImpl);\n  }\n\n  private initializeContextMenuCallbacks(contextMenuFunctions?: CallbackMap): void {\n    const notificationService: NotificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(\n      ServiceNames.Notification,\n    );\n\n    // Unregister function not used since these notifications should be\n    // observed for the full lifetime of the extension.\n    notificationService.registerHandler(\n      NotificationId.ContextMenuClick,\n      () => {\n        // Let through any context menu event, these are already filtered on api-core\n        // based on the extension locator.\n        return true;\n      },\n      (event: ContextMenuEvent) => {\n        // Execute the function associated with this context menu ID\n        if (contextMenuFunctions) {\n          if (!contextMenuFunctions[event.id]) {\n            throw new TableauError(ErrorCodes.InternalError, `Received unexpected context menu Id from event: ${event.id}`);\n          }\n\n          contextMenuFunctions[event.id]();\n        }\n      },\n    );\n  }\n\n  private loadTableauFonts(fontNameAndInfo: FontNameAndInfo): void {\n    switch (fontNameAndInfo.fontName) {\n      case TableauBookFontFaceName:\n        document.fonts.add(new FontFace(TableauBookFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        break;\n\n      case TableauLightFontFaceName:\n        document.fonts.add(new FontFace(TableauLightFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        break;\n\n      case TableauRegularFontFaceName:\n        document.fonts.add(\n          new FontFace(TableauRegularFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        break;\n\n      case TableauSemiBoldFontFaceName:\n        document.fonts.add(\n          new FontFace(TableauSemiboldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        document.fonts.add(new FontFace(TableauRegularFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        break;\n\n      case TableauBoldFontFaceName:\n        document.fonts.add(new FontFace(TableauBoldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        document.fonts.add(new FontFace(TableauBoldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(new FontFace(TableauMediumFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(\n          new FontFace(TableauSemiboldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }),\n        );\n        break;\n\n      case TableauMediumFontFaceName:\n        document.fonts.add(\n          new FontFace(TableauMediumFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        document.fonts.add(new FontFace(TableauLightFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(new FontFace(TableauBookFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        break;\n\n      default:\n        throw new TableauError(ErrorCodes.InternalError, `'attempted to load unsupported font: ${fontNameAndInfo.fontName}.'`);\n    }\n  }\n\n  private loadBentonSansFonts(fontNameAndInfo: FontNameAndInfo): void {\n    switch (fontNameAndInfo.fontName) {\n      case BentonSansBookFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        document.fonts.add(\n          new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: '100', style: 'normal' }),\n        );\n        break;\n\n      case BentonSansLightFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: '100', style: 'normal' }));\n        break;\n\n      case BentonSansMediumFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(\n          new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }),\n        );\n        break;\n\n      case BentonSansSemiDemiFontFaceName:\n        document.fonts.add(\n          new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        break;\n\n      case BentonSansBookItalicFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { style: 'italic' }));\n        break;\n\n      case BentonSansSemiDemiItalicFontFaceName:\n        document.fonts.add(new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { style: 'italic' }));\n        break;\n\n      default:\n        throw new TableauError(ErrorCodes.InternalError, `'attempted to load unsupported font: ${fontNameAndInfo.fontName}.'`);\n    }\n  }\n}\n","import { InitializationOptions, InternalApiDispatcherFactory, INTERNAL_CONTRACT_VERSION, VerbId } from '@tableau/api-internal-contract-js';\n\n/**\n * LegacyInternalApiDispatcherHolder has been moved (and renamed) from api-internal-contract.\n * It supports running a newer external library against a pre 2019.3 desktop.\n * Starting in 2019.3, we have a merged bootstrap style for both desktop and server.\n * In addition, the alpha checking that is happening here is not necessary in external-api-js\n *  after 2019.3 because that checking happens in api-platform-js (ApiDispatcherTest.ts)\n * TFSID: 1091561 tracks an improvement to this system to make it less complex and tie it directly to\n *  tableau beta release versions.\n * @deprecated\n */\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport namespace LegacyInternalApiDispatcherHolder {\n  /**\n   * @param options\n   */\n  export function getDesktopDispatcherPromise(options?: InitializationOptions): Promise<InternalApiDispatcherFactory> | undefined {\n    if ((!options || typeof options.isAlpha === 'undefined') && !window.__warningIssued) {\n      // tslint:disable-next-line:no-console\n      console.warn('This is a beta version of the Extensions API. Please upgrade to an official release.');\n      window.__warningIssued = true;\n    } else if (options?.isAlpha && window.__platformIsOfficialRelease) {\n      window.__tableauDesktopDispatcher\n        .then((dispatcherFactory) => {\n          const dispatcher = dispatcherFactory(INTERNAL_CONTRACT_VERSION);\n          dispatcher.execute(VerbId.BlockExtension, {}).catch();\n        })\n        .catch();\n    }\n\n    // this will be undefined if promise is rejected or throws\n    return window.__tableauDesktopDispatcher;\n  }\n\n  /**\n   * @param options\n   */\n  export function hasDesktopApiDispatcherPromise(options?: InitializationOptions): boolean {\n    return !!getDesktopDispatcherPromise(options);\n  }\n}\n\ndeclare global {\n  interface Window {\n    __tableauDesktopDispatcher: Promise<InternalApiDispatcherFactory>;\n    __platformIsOfficialRelease: boolean;\n    __warningIssued: boolean;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExtensionSettingsInfo, NotificationId, SettingsEvent } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  ErrorHelpers,\n  NotificationService,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n  TableauError,\n} from '@tableau/api-shared-js';\nimport { TableauEvent } from '../Events/TableauEvent';\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { SettingsCollection, SettingsService } from '../Services/SettingsService';\n\nclass SettingsChangedEvent extends TableauEvent implements Contract.SettingsChangedEvent {\n  public constructor(private _newSettings: { [key: string]: string }) {\n    super(Contract.TableauEventType.SettingsChanged);\n  }\n\n  public get newSettings(): SettingsCollection {\n    return this._newSettings;\n  }\n}\n\nexport class SettingsImpl {\n  private static ASYNC_SAVE_IN_PROGRESS = 'Async Save is in progress, updating settings is not allowed.';\n  private _isModified: boolean;\n  private _currentSettings: SettingsCollection;\n\n  // Since promises can't be introspected for state, keep a variable that\n  // indicates a save is in progress, so that set/erase can't be called during a save.\n  private _saveInProgress = false;\n\n  public constructor(settingsInfo: ExtensionSettingsInfo) {\n    this.initializeSettings(settingsInfo);\n  }\n\n  public erase(key: string): void {\n    ErrorHelpers.verifyParameter(key, 'key');\n\n    // Only make a modification if we have the key already\n    if (this._currentSettings[key]) {\n      this.verifySettingsAreUnlocked();\n\n      delete this._currentSettings[key];\n      this._isModified = true;\n    }\n  }\n\n  public get(key: string): string | undefined {\n    ErrorHelpers.verifyParameter(key, 'key');\n\n    return this._currentSettings[key];\n  }\n\n  public getAll(): SettingsCollection {\n    // Returns a mutable copy of the settings\n    return Object.assign({}, this._currentSettings);\n  }\n\n  public get isModified(): boolean {\n    return this._isModified;\n  }\n\n  public saveAsync(): Promise<SettingsCollection> {\n    this.verifySettingsAreUnlocked();\n\n    // Just resolve immediately if settings are unchanged\n    if (!this._isModified) {\n      return Promise.resolve<SettingsCollection>(this._currentSettings);\n    }\n\n    this._saveInProgress = true;\n\n    // Use the settings service to save settings to twb\n    const settingsService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<SettingsService>(\n      ExtensionsServiceNames.SettingsService,\n    );\n\n    return settingsService.saveSettingsAsync(this._currentSettings).then<SettingsCollection>(\n      (newSettings) => {\n        this._saveInProgress = false;\n        this._isModified = false;\n        if (this._currentSettings === undefined) {\n          this._currentSettings = newSettings;\n        } else {\n          Object.assign(this._currentSettings, newSettings);\n        }\n        return newSettings;\n      },\n      (reason) => {\n        this._saveInProgress = false;\n        return Promise.reject(reason);\n      },\n    );\n  }\n\n  public set(key: string, value: string): void {\n    ErrorHelpers.verifyStringParameter(key, 'key'); // Key shouldn't be an empty string.\n    ErrorHelpers.verifyParameter(value, 'value'); // Empty string value is allowed.\n    this.verifySettingsAreUnlocked();\n\n    this._currentSettings[key] = value;\n    this._isModified = true;\n  }\n\n  /**\n   * Initializes all events relevant to settings object.  This is only a settingsUpdate event currently.\n   *\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager.\n   */\n  public initializeEvents(): Array<SingleEventManager> {\n    const results = new Array<SingleEventManager>();\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return\n      return results;\n    }\n\n    const settingsChangedEvent = new SingleEventManagerImpl<SettingsChangedEvent>(Contract.TableauEventType.SettingsChanged);\n    notificationService.registerHandler(\n      NotificationId.SettingsChanged,\n      () => true,\n      (event: SettingsEvent) => {\n        this._currentSettings = event.newSettings;\n        settingsChangedEvent.triggerEvent(() => new SettingsChangedEvent(event.newSettings));\n      },\n    );\n\n    results.push(settingsChangedEvent);\n\n    return results;\n  }\n\n  private initializeSettings(settingsInfo: ExtensionSettingsInfo): void {\n    ErrorHelpers.verifyParameter(settingsInfo, 'settingsInfo');\n    ErrorHelpers.verifyParameter(settingsInfo.settingsValues, 'settingsInfo.SettingsValues');\n\n    this._currentSettings = settingsInfo.settingsValues;\n\n    // Reset the isModified flag\n    this._isModified = false;\n  }\n\n  /**\n   * This helper should be called before any local update to this.currentSettings.\n   * Checks if a current save call is still in progress and throws an error if so.\n   */\n  private verifySettingsAreUnlocked(): void {\n    if (this._saveInProgress) {\n      throw new TableauError(Contract.ErrorCodes.SettingSaveInProgress, SettingsImpl.ASYNC_SAVE_IN_PROGRESS);\n    }\n  }\n}\n","import { Model } from '@tableau/api-internal-contract-js';\n\nexport const TableauBookFontFamilyName = 'Tableau Book';\nexport const TableauLightFontFamilyName = 'Tableau Light';\nexport const TableauRegularFontFamilyName = 'Tableau Regular';\nexport const TableauMediumFontFamilyName = 'Tableau Medium';\nexport const TableauSemiboldFontFamilyName = 'Tableau Semibold';\nexport const TableauBoldFontFamilyName = 'Tableau Bold';\n\nexport const TableauBookFontFaceName = 'Tableau Book';\nexport const TableauBoldFontFaceName = 'Tableau Bold';\nexport const TableauLightFontFaceName = 'Tableau Light';\nexport const TableauMediumFontFaceName = 'Tableau Medium';\nexport const TableauRegularFontFaceName = 'Tableau Regular';\nexport const TableauSemiBoldFontFaceName = 'Tableau Semi Bold';\n\nexport const SupportedTableauFontFaces: Model[] = [\n  TableauBookFontFaceName,\n  TableauBoldFontFaceName,\n  TableauLightFontFaceName,\n  TableauMediumFontFaceName,\n  TableauRegularFontFaceName,\n  TableauSemiBoldFontFaceName,\n];\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { DialogUpdateEvent, NotificationId } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, NotificationService, ServiceNames, TableauError } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { UIService } from '../Services/UIService';\n\nexport class UIImpl {\n  public displayDialogAsync(url: string, payload?: string, options?: Contract.DialogOptions): Promise<string> {\n    const uiService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<UIService>(ExtensionsServiceNames.UIService);\n    const notificationService: NotificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(\n      ServiceNames.Notification,\n    );\n\n    return new Promise((resolve, reject) => {\n      uiService\n        .displayDialogAsync(url, payload || '', options)\n        .then(() => {\n          const unregisterFn = notificationService.registerHandler(\n            NotificationId.ExtensionDialogUpdate,\n            () => {\n              // Let through any dialog update event\n              return true;\n            },\n            (event: DialogUpdateEvent) => {\n              if (event.isCloseEvent) {\n                if (event.closePayload === undefined) {\n                  throw new TableauError(Contract.ErrorCodes.InternalError, 'closePayload is undefined');\n                }\n                resolve(event.closePayload);\n              } else {\n                reject(new TableauError(ErrorCodes.DialogClosedByUser, 'Extension dialog closed by user.'));\n              }\n\n              unregisterFn();\n            },\n          );\n        })\n        .catch((error) => {\n          reject(error);\n        });\n    });\n  }\n\n  public closeDialog(payload?: string): void {\n    const uiService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<UIService>(ExtensionsServiceNames.UIService);\n\n    uiService.closeDialog(payload);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardLayoutChangeDetails, TableauEventType, WorkbookFormatting } from '@tableau/api-external-contract-js';\nimport { DashboardLayoutEvent, NotificationId } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  DashboardImpl,\n  DashboardObjectImpl,\n  NotificationService,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n  WorksheetImpl,\n} from '@tableau/api-shared-js';\nimport { DashboardLayoutChangedEvent } from '../Events/DashboardLayoutChangedEvent';\nimport { WorkbookFormattingChangedEvent } from '../Events/WorkbookFormattingChangedEvent';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { DashboardObject } from './DashboardObject';\nimport { Sheet } from './Sheet';\nimport { Worksheet } from './Worksheet';\n\nexport class Dashboard extends Sheet implements Contract.ExtensionDashboard {\n  public constructor(private _dashboardImpl: DashboardImpl) {\n    super(_dashboardImpl);\n    _dashboardImpl.initializeWithPublicInterfaces();\n    this.initializeEvents().forEach((e) => this.addNewEventType(e));\n  }\n\n  public get worksheets(): Array<Contract.ExtensionWorksheet> {\n    return this._dashboardImpl.worksheetsImpl.map((worksheetImpl: WorksheetImpl) => {\n      return new Worksheet(worksheetImpl);\n    });\n  }\n\n  public get objects(): Array<Contract.ExtensionDashboardObject> {\n    return this._dashboardImpl.objects.map((dashboardObjectImpl: DashboardObjectImpl) => {\n      return new DashboardObject(dashboardObjectImpl);\n    });\n  }\n\n  public get activeDashboardObjectId(): number {\n    return this._dashboardImpl.activeDashboardObjectId;\n  }\n\n  public get activeDashboardName(): string {\n    return this._dashboardImpl.activeDashboardName;\n  }\n\n  public setZoneVisibilityAsync(zoneVisibilityMap: Contract.ZoneVisibilityMap): Promise<void> {\n    return this._dashboardImpl.setDashboardObjectVisibilityAsync(zoneVisibilityMap);\n  }\n\n  public setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap: Contract.DashboardObjectVisibilityMap): Promise<void> {\n    return this._dashboardImpl.setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap);\n  }\n\n  public getDashboardObjectById(dashboardObjectId: number): DashboardObject | undefined {\n    const zone = this._dashboardImpl.getDashboardObjectById(dashboardObjectId);\n    return zone && new DashboardObject(zone);\n  }\n\n  public initializeEvents(): Array<SingleEventManager> {\n    const results = new Array<SingleEventManager>();\n\n    // Initializing events and registering notification service\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return (allows unit testing without NotificationService mock)\n      return results;\n    }\n\n    const dashboardLayoutChangedEvent = new SingleEventManagerImpl<DashboardLayoutChangedEvent>(TableauEventType.DashboardLayoutChanged);\n    notificationService.registerHandler(\n      NotificationId.DashboardLayoutChanged,\n      () => true,\n      (event: DashboardLayoutEvent) => {\n        const dashboardObjectChanges: DashboardLayoutChangeDetails = this._dashboardImpl.updateZones(\n          event.zones,\n          event.activeZoneId,\n          event.activeDashboardName,\n        );\n        dashboardLayoutChangedEvent.triggerEvent(() => new DashboardLayoutChangedEvent(dashboardObjectChanges));\n      },\n    );\n\n    results.push(dashboardLayoutChangedEvent);\n\n    const workbookFormattingChangedEvent = new SingleEventManagerImpl<WorkbookFormattingChangedEvent>(\n      TableauEventType.WorkbookFormattingChanged,\n    );\n\n    notificationService.registerHandler(\n      NotificationId.WorkbookFormattingChanged,\n      () => true,\n      (eventFormatting: WorkbookFormatting) => {\n        workbookFormattingChangedEvent.triggerEvent(() => new WorkbookFormattingChangedEvent(eventFormatting));\n      },\n    );\n\n    results.push(workbookFormattingChangedEvent);\n\n    return results;\n  }\n\n  public moveAndResizeDashboardObjectsAsync(\n    dashboardObjectPositionAndSizeUpdateArray: Contract.DashboardObjectPositionAndSizeUpdateArray,\n  ): Promise<void> {\n    return this._dashboardImpl.moveAndResizeDashboardObjectsAsync(dashboardObjectPositionAndSizeUpdateArray);\n  }\n\n  public replayAnimationAsync(replaySpeed: Contract.ReplaySpeedType): Promise<void> {\n    return this._dashboardImpl.replayAnimationAsync(replaySpeed);\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    return this._dashboardImpl.getFiltersAsync();\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    return this._dashboardImpl.applyFilterAsync(fieldName, values, updateType, options);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardObjectImpl } from '@tableau/api-shared-js';\nimport { Dashboard } from './Dashboard';\nimport { Worksheet } from './Worksheet';\n\n/**\n * Implementation of the dashboard objects - the zones in a dashboard.\n */\nexport class DashboardObject implements Contract.ExtensionDashboardObject {\n  public constructor(private _dashboardObjectImpl: DashboardObjectImpl) {}\n\n  public get dashboard(): Contract.ExtensionDashboard {\n    return new Dashboard(this._dashboardObjectImpl.dashboardImpl);\n  }\n\n  public get type(): Contract.DashboardObjectType {\n    return this._dashboardObjectImpl.type;\n  }\n\n  public get position(): Contract.Point {\n    return this._dashboardObjectImpl.position;\n  }\n\n  public get size(): Contract.Size {\n    return this._dashboardObjectImpl.size;\n  }\n\n  public get worksheet(): Contract.ExtensionWorksheet | undefined {\n    if (this._dashboardObjectImpl.worksheetImpl) {\n      return new Worksheet(this._dashboardObjectImpl.worksheetImpl);\n    }\n    return undefined;\n  }\n\n  public get name(): string {\n    return this._dashboardObjectImpl.name;\n  }\n\n  public get isFloating(): boolean {\n    return this._dashboardObjectImpl.isFloating;\n  }\n\n  public get isVisible(): boolean {\n    return this._dashboardObjectImpl.isVisible;\n  }\n\n  public get id(): number {\n    return this._dashboardObjectImpl.id;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { NotificationId } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  ErrorHelpers,\n  EventListenerManager,\n  NotificationService,\n  ParameterImpl,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n} from '@tableau/api-shared-js';\nimport { ParameterChangedEvent } from '../Events/ParameterChangedEvent';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\n\n/**\n * Implementation of the Parameter contract. Calls down to the impl\n * class for almost all of the work it does.\n */\nexport class Parameter extends EventListenerManager implements Contract.Parameter {\n  public constructor(private parameterImpl: ParameterImpl, sheet: Contract.ExtensionSheet) {\n    super();\n\n    // Initialize our event handling for this class\n    this.initializeEvents(sheet).forEach((e) => this.addNewEventType(e));\n  }\n\n  public get name(): string {\n    return this.parameterImpl.name;\n  }\n\n  public get currentValue(): Contract.DataValue {\n    return this.parameterImpl.currentValue;\n  }\n\n  public get dataType(): Contract.DataType {\n    return this.parameterImpl.dataType;\n  }\n\n  public get allowableValues(): Contract.ParameterDomainRestriction {\n    return this.parameterImpl.allowableValues;\n  }\n\n  public get id(): string {\n    return this.parameterImpl.id;\n  }\n\n  public changeValueAsync(newValue: string | number | boolean | Date): Promise<Contract.DataValue> {\n    return this.parameterImpl.changeValueAsync(newValue);\n  }\n\n  /**\n   * Helper method which goes through and registers each event type this impl knows about\n   * with the NotificationService. It returns an array of SingleEventManager objects which\n   * can then be passed to an EventListenerManager to handle user registration / unregistration.\n   *\n   * @param sheet The sheet object which will be included with the event notifications\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager\n   */\n  public initializeEvents(sheet: Contract.ExtensionSheet): Array<SingleEventManager> {\n    ErrorHelpers.verifyInternalValue(sheet, 'sheet');\n\n    const results = new Array<SingleEventManager>();\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return\n      return results;\n    }\n\n    // Initialize all of the event managers we'll need (one for each event type)\n    const parameterEvent = new SingleEventManagerImpl<ParameterChangedEvent>(Contract.TableauEventType.ParameterChanged);\n    notificationService.registerHandler(\n      NotificationId.ParameterChanged,\n      (model) => {\n        const fieldName = model as string;\n        return fieldName === this.parameterImpl.id;\n      },\n      (fieldName: string) => {\n        parameterEvent.triggerEvent(() => new ParameterChangedEvent(fieldName, sheet));\n      },\n    );\n\n    results.push(parameterEvent);\n\n    return results;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { EventListenerManager, SheetImpl, TableauError } from '@tableau/api-shared-js';\nimport { Parameter } from './Parameter';\n\nexport class Sheet extends EventListenerManager implements Contract.ExtensionSheet {\n  public constructor(private _sheetImpl: SheetImpl) {\n    super();\n  }\n\n  public get name(): string {\n    return this._sheetImpl.name;\n  }\n\n  public get sheetType(): Contract.SheetType {\n    return this._sheetImpl.sheetType;\n  }\n\n  public get size(): Contract.Size {\n    if (this.isValidSize(this._sheetImpl.size)) {\n      return this._sheetImpl.size;\n    }\n\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, 'Size not implemented');\n  }\n\n  private isValidSize(size: any): size is Contract.Size {\n    const testSize = size as Contract.Size;\n    if (testSize.width !== undefined && testSize.height !== undefined) {\n      return true;\n    }\n\n    return false;\n  }\n\n  public findParameterAsync(parameterName: string): Promise<Contract.Parameter | undefined> {\n    return this._sheetImpl.findParameterAsync(parameterName).then((parameterImpl) => {\n      if (parameterImpl) {\n        return new Promise<Contract.Parameter>((resolve) => resolve(new Parameter(parameterImpl, this)));\n      } else {\n        return new Promise<undefined>((resolve) => resolve(undefined));\n      }\n    });\n  }\n\n  public getParametersAsync(): Promise<Array<Contract.Parameter>> {\n    return this._sheetImpl.getParametersAsync().then((parametersImpl) => {\n      return parametersImpl.map((parameterImpl) => {\n        return new Parameter(parameterImpl, this);\n      });\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExtensionWorkbookImpl } from '../Impl/ExtensionWorkbookImpl';\n\nexport class Workbook implements Contract.ExtensionWorkbook {\n  public constructor(private _workbookImpl: ExtensionWorkbookImpl) {}\n\n  public getAllDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    return this._workbookImpl.getAllDataSourcesAsync();\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { Column, FilterUpdateType, SelectionUpdateType, TableauEventType, TooltipContext } from '@tableau/api-external-contract-js';\nimport { FilterEvent, NotificationId, SummaryDataEvent, VisualId } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  NotificationService,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n  TableauError,\n  WorksheetImpl,\n} from '@tableau/api-shared-js';\nimport { FilterChangedEvent } from '../Events/FilterChangedEvent';\nimport { MarksSelectedEvent } from '../Events/MarksSelectedEvent';\nimport { SummaryDataChangedEvent } from '../Events/SummaryDataChangedEvent';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { Dashboard } from './Dashboard';\nimport { Sheet } from './Sheet';\n\nexport class Worksheet extends Sheet implements Contract.ExtensionWorksheet {\n  public constructor(protected _worksheetImpl: WorksheetImpl) {\n    super(_worksheetImpl);\n\n    // Call to initialize events and then call down to the event listener manager to handle things\n    this.initializeEvents().forEach((e) => this.addNewEventType(e));\n  }\n\n  public get parentDashboard(): Contract.ExtensionDashboard {\n    // This should never happen for Extensions if the DashboardImpls are created correctly\n    if (this._worksheetImpl.parentDashboard == null) {\n      throw new TableauError(Contract.SharedErrorCodes.ImplementationError, `Parent dashboard not implemented`);\n    }\n\n    return new Dashboard(this._worksheetImpl.parentDashboard);\n  }\n\n  /**\n   * Helper method which goes through and registers each event type this impl knows about\n   * with the NotificationService. It returns an array of SingleEventManager objects which\n   * can then be passed to an EventListenerManager to handle user registration / unregistration.\n   *\n   * @param {Worksheet} worksheet The worksheet object which will be included with the event notifications\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager\n   */\n  public initializeEvents(): Array<SingleEventManager> {\n    const results = new Array<SingleEventManager>();\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return\n      return results;\n    }\n\n    // Initialize all of the event managers we'll need (one for each event type)\n    const marksEvent = new SingleEventManagerImpl<MarksSelectedEvent>(TableauEventType.MarkSelectionChanged);\n    notificationService.registerHandler(\n      NotificationId.SelectedMarksChanged,\n      (model) => {\n        const visualId = model as VisualId;\n        return this.visualIdsAreEqual(visualId, this._worksheetImpl.visualId);\n      },\n      () => marksEvent.triggerEvent(() => new MarksSelectedEvent(this)),\n    );\n\n    const filterEvent = new SingleEventManagerImpl<FilterChangedEvent>(TableauEventType.FilterChanged);\n    notificationService.registerHandler(\n      NotificationId.FilterChanged,\n      (model) => {\n        const filterEventResponse = model as FilterEvent;\n        return this._worksheetImpl.visualId.worksheet === filterEventResponse.visualId.worksheet;\n      },\n      (event: FilterEvent) => {\n        filterEvent.triggerEvent(() => new FilterChangedEvent(this, event.fieldName, event.fieldId));\n      },\n    );\n\n    const summaryDataEvent = new SingleEventManagerImpl<SummaryDataChangedEvent>(TableauEventType.SummaryDataChanged);\n    notificationService.registerHandler(\n      NotificationId.SummaryDataChanged,\n      (model) => {\n        const summaryDataEventResponse = model as SummaryDataEvent;\n        return this._worksheetImpl.visualId.worksheet === summaryDataEventResponse.visualId.worksheet;\n      },\n      (event: SummaryDataEvent) => {\n        summaryDataEvent.triggerEvent(() => new SummaryDataChangedEvent(this));\n      },\n    );\n\n    results.push(marksEvent);\n    results.push(filterEvent);\n    results.push(summaryDataEvent);\n\n    return results;\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    return this._worksheetImpl.applyFilterAsync(fieldName, values, updateType, options);\n  }\n\n  public applyRangeFilterAsync(fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\n    return this._worksheetImpl.applyRangeFilterAsync(fieldName, filterOptions);\n  }\n\n  public applyHierarchicalFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    return this._worksheetImpl.applyHierarchicalFilterAsync(fieldName, values, updateType, options);\n  }\n\n  public applyRelativeDateFilterAsync(fieldName: string, options: Contract.RelativeDateFilterOptions): Promise<string> {\n    return this._worksheetImpl.applyRelativeDateFilterAsync(fieldName, options);\n  }\n\n  public clearFilterAsync(fieldName: string): Promise<string> {\n    return this._worksheetImpl.clearFilterAsync(fieldName);\n  }\n\n  public getDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    return this._worksheetImpl.getDataSourcesAsync();\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    return this._worksheetImpl.getFiltersAsync();\n  }\n\n  public getSelectedMarksAsync(): Promise<Contract.MarksCollection> {\n    return this._worksheetImpl.getSelectedMarksAsync();\n  }\n\n  public getHighlightedMarksAsync(): Promise<Contract.MarksCollection> {\n    return this._worksheetImpl.getHighlightedMarksAsync();\n  }\n\n  public getSummaryDataAsync(options: Contract.GetSummaryDataOptions): Promise<Contract.DataTable> {\n    return this._worksheetImpl.getSummaryDataAsync(options);\n  }\n\n  public getSummaryDataReaderAsync(pageRowCount: number, options: Contract.GetSummaryDataOptions): Promise<Contract.DataTableReader> {\n    return this._worksheetImpl.getSummaryDataReaderAsync(pageRowCount, options);\n  }\n\n  public getSummaryColumnsInfoAsync(): Promise<Array<Column>> {\n    return this._worksheetImpl.getSummaryColumnsInfoAsync();\n  }\n\n  public getUnderlyingDataAsync(options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    console.warn(\n      'Worksheet.getUnderlyingDataAsync is deprecated. Please use ' +\n        'Worksheet.getUnderlyingTablesAsync and Worksheet.getUnderlyingTableDataAsync',\n    );\n    return this._worksheetImpl.getUnderlyingDataAsync(options);\n  }\n\n  public getUnderlyingTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    return this._worksheetImpl.getUnderlyingTablesAsync();\n  }\n\n  public getUnderlyingTableDataAsync(logicalTableId: string, options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    return this._worksheetImpl.getUnderlyingTableDataAsync(logicalTableId, options);\n  }\n\n  public getUnderlyingTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount: number,\n    options: Contract.GetUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    return this._worksheetImpl.getUnderlyingTableDataReaderAsync(logicalTableId, pageRowCount, options);\n  }\n\n  public getVisualSpecificationAsync(): Promise<Contract.VisualSpecification> {\n    return this._worksheetImpl.getVisualSpecificationAsync();\n  }\n\n  public clearSelectedMarksAsync(): Promise<void> {\n    return this._worksheetImpl.clearSelectedMarksAsync();\n  }\n\n  public selectMarksByIDAsync(marksInfo: Array<Contract.MarkInfo>, updateType: SelectionUpdateType): Promise<void> {\n    return this._worksheetImpl.selectMarksByIdAsync(marksInfo, updateType);\n  }\n\n  public selectMarksByValueAsync(selections: Array<Contract.SelectionCriteria>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    return this._worksheetImpl.selectMarksByValueAsync(selections, selectionUpdateType);\n  }\n\n  public selectMarksByIdAsync(selections: Array<Contract.MarkInfo>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    return this._worksheetImpl.selectMarksByIdAsync(selections, selectionUpdateType);\n  }\n\n  public annotateMarkAsync(mark: Contract.MarkInfo, annotationText: string): Promise<void> {\n    return this._worksheetImpl.annotateMarkAsync(mark, annotationText);\n  }\n\n  public getAnnotationsAsync(): Promise<Array<Contract.Annotation>> {\n    return this._worksheetImpl.getAnnotationsAsync();\n  }\n\n  public removeAnnotationAsync(annotation: Contract.Annotation): Promise<void> {\n    return this._worksheetImpl.removeAnnotationAsync(annotation);\n  }\n\n  public hoverTupleAsync(hoveredTuple: number, tooltip?: TooltipContext): Promise<void> {\n    return this._worksheetImpl.hoverTupleAsync(hoveredTuple, tooltip);\n  }\n\n  public selectTuplesAsync(selectedTuples: Array<number>, selectOption: Contract.SelectOptions, tooltip?: TooltipContext): Promise<void> {\n    return this._worksheetImpl.selectTuplesAsync(selectedTuples, selectOption, tooltip);\n  }\n\n  private visualIdsAreEqual(a: VisualId, b: VisualId): boolean {\n    return (\n      a &&\n      b &&\n      a.worksheet === b.worksheet &&\n      a.dashboard === b.dashboard &&\n      a.storyboard === b.storyboard &&\n      a.storyPointID === b.storyPointID\n    );\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\n\n/**\n * Implementation of the external DashboardContent namespace.\n * This does not follow the Impl pattern as DashboardContent is\n * currently just a (single) property bag.\n */\nexport class DashboardContent implements Contract.DashboardContent {\n  public constructor(private _dashboard: Contract.ExtensionDashboard) {}\n\n  public get dashboard(): Contract.ExtensionDashboard {\n    return this._dashboard;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExtensionEnvironment } from '@tableau/api-internal-contract-js';\nimport { ApiVersion, InternalToExternalEnumMappings as EnumMappings } from '@tableau/api-shared-js';\nimport { ConnectedServer } from '../Impl/ConnectedServer';\nimport { WorkbookFormattingEnvUtil } from './WorkbookFormattingEnvUtil';\n\n/**\n * Implementation of the external environment namespace.\n * Environment does not follow the Impl pattern as it is\n * just a property bag.\n * First class extensions can get to ConnectedServer with: environment['connectedServer']\n */\nexport class Environment implements Contract.Environment {\n  /**The following is an index signature. It allows properties to be accessed by name.\n   * This allows us to add properties dynamically (see usage of this.connectedServer below) without Typescript errors.\n   * The reason we do this is so that 3rd-party extension developers do not see the connectedServer property\n   * that is only available to first class extension developers.\n   * The type of the index sigature needs to be a union of all properties in the object, since we could\n   * access any property using the property index method.\n   */\n  [x: string]: ConnectedServer | string | Contract.WorkbookFormatting | string[] | undefined;\n  private _apiVersion: string;\n  private _context: Contract.ExtensionContext;\n  private _formatting?: Contract.WorkbookFormatting;\n  private _language: string;\n  private _country?: string;\n  private _locale: string;\n  private _mode: Contract.ExtensionMode;\n  private _operatingSystem: string;\n  private _tableauVersion: string;\n  private _uniqueUserId?: string;\n\n  public constructor(extensionEnvironment: ExtensionEnvironment) {\n    this._apiVersion = ApiVersion.Instance && ApiVersion.Instance.formattedValue; // maj.min.fix (no build)\n    this._context = EnumMappings.extensionContext.convert(extensionEnvironment.extensionContext);\n    this._formatting = WorkbookFormattingEnvUtil.convertToWorkbookFormatting(extensionEnvironment.workbookFormatting);\n    this._language = extensionEnvironment.extensionLanguage;\n    this._country = extensionEnvironment.extensionCountry;\n    this._locale = extensionEnvironment.extensionLocale;\n    this._mode = EnumMappings.extensionMode.convert(extensionEnvironment.extensionMode);\n    this._operatingSystem = extensionEnvironment.operatingSystem;\n    this._tableauVersion = extensionEnvironment.tableauVersion;\n    this._uniqueUserId = extensionEnvironment.uniqueUserId;\n\n    // If we have a userId, then we are a first class extension\n    if (extensionEnvironment.userId) {\n      this.connectedServer = new ConnectedServer(\n        extensionEnvironment.userId,\n        extensionEnvironment.siteId,\n        extensionEnvironment.siteNamespace,\n        extensionEnvironment.workbookId,\n      );\n\n      this.featureFlags = extensionEnvironment.featureFlags;\n    }\n  }\n\n  public get apiVersion(): string {\n    return this._apiVersion;\n  }\n\n  public get context(): Contract.ExtensionContext {\n    return this._context;\n  }\n\n  public get workbookFormatting(): Contract.WorkbookFormatting | undefined {\n    return this._formatting;\n  }\n\n  public get language(): string {\n    return this._language;\n  }\n\n  public get country(): string | undefined {\n    return this._country;\n  }\n\n  public get locale(): string {\n    return this._locale;\n  }\n\n  public get mode(): Contract.ExtensionMode {\n    return this._mode;\n  }\n\n  public get operatingSystem(): string {\n    return this._operatingSystem;\n  }\n\n  public get tableauVersion(): string {\n    return this._tableauVersion;\n  }\n\n  public get uniqueUserId(): string | undefined {\n    return this._uniqueUserId;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { CallbackMap, ExtensionsImpl } from '../Impl/ExtensionsImpl';\n\n/**\n * Implementation of the external Extensions namespace.\n */\nexport class Extensions implements Contract.Extensions {\n  public constructor(private extensionImpl: ExtensionsImpl) {\n    this.extensionImpl = extensionImpl;\n  }\n\n  public get dashboardContent(): Contract.DashboardContent | undefined {\n    return this.extensionImpl.dashboardContent;\n  }\n\n  public get worksheetContent(): Contract.WorksheetContent | undefined {\n    return this.extensionImpl.worksheetContent;\n  }\n\n  public get environment(): Contract.Environment {\n    return this.extensionImpl.environment;\n  }\n\n  public get settings(): Contract.Settings {\n    return this.extensionImpl.settings;\n  }\n\n  public get ui(): Contract.UI {\n    return this.extensionImpl.ui;\n  }\n\n  public get workbook(): Contract.ExtensionWorkbook {\n    return this.extensionImpl.workbook;\n  }\n\n  public get dashboardObjectId(): number {\n    return this.extensionImpl.extensionZoneId;\n  }\n\n  public initializeAsync(contextMenuCallbacks?: CallbackMap): Promise<void> {\n    return this.extensionImpl.initializeAsync(false, contextMenuCallbacks).then<void>();\n  }\n\n  public initializeDialogAsync(): Promise<string> {\n    return this.extensionImpl.initializeAsync(true);\n  }\n\n  public createVizImageAsync(inputSpec: object): Promise<string> {\n    return this.extensionImpl.createVizImageAsync(inputSpec);\n  }\n\n  public setClickThroughAsync(clickThroughEnabled: boolean): Promise<void> {\n    return this.extensionImpl.setClickThroughAsync(clickThroughEnabled);\n  }\n}\n","import { Settings as SettingsContract } from '@tableau/api-external-contract-js';\nimport { EventListenerManager } from '@tableau/api-shared-js';\nimport { SettingsImpl } from '../Impl/SettingsImpl';\nimport { SettingsCollection } from '../Services/SettingsService';\n\n/**\n * Implementation of the external settings namespace.\n */\nexport class Settings extends EventListenerManager implements SettingsContract {\n  public constructor(private _settingsImpl: SettingsImpl) {\n    super();\n\n    // Initialize our event handling for this class\n    this._settingsImpl.initializeEvents().forEach((e) => this.addNewEventType(e));\n  }\n\n  public erase(key: string): void {\n    this._settingsImpl.erase(key);\n  }\n\n  public get(key: string): string | undefined {\n    return this._settingsImpl.get(key);\n  }\n\n  public getAll(): SettingsCollection {\n    return this._settingsImpl.getAll();\n  }\n\n  public get isModified(): boolean {\n    return this._settingsImpl.isModified;\n  }\n\n  public saveAsync(): Promise<SettingsCollection> {\n    return this._settingsImpl.saveAsync();\n  }\n\n  public set(key: string, value: string): void {\n    this._settingsImpl.set(key, value);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { UIImpl } from '../Impl/UIImpl';\n\n/**\n * Implementation of the external UI namespace.\n */\nexport class UI implements Contract.UI {\n  public constructor(private _impl: UIImpl) {}\n\n  public displayDialogAsync(url: string, payload?: string, options?: Contract.DialogOptions): Promise<string> {\n    return this._impl.displayDialogAsync(url, payload, options);\n  }\n\n  public closeDialog(payload?: string): void {\n    this._impl.closeDialog(payload);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { InternalToExternalEnumMappings as EnumMappings } from '@tableau/api-shared-js';\nimport { WorkbookFormatting } from '../../../../api-internal-contract-js/lib/src/JsApiInternalContract';\n\nexport class WorkbookFormattingEnvUtil {\n  public static convertToWorkbookFormatting(workbookFormattingModel?: WorkbookFormatting): Contract.WorkbookFormatting | undefined {\n    if (!workbookFormattingModel) {\n      return undefined;\n    } else {\n      const formattingMap: Array<Contract.FormattingSheet> = workbookFormattingModel.formattingSheets.map((currentFormattingSheet) => {\n        const formattingSheet: Contract.FormattingSheet = {\n          classNameKey: EnumMappings.classNameKey.convert(currentFormattingSheet.classNameKey),\n          cssProperties: {\n            fontFamily: currentFormattingSheet.cssProperties.fontFamily,\n            fontSize: currentFormattingSheet.cssProperties.fontSize,\n            fontWeight: currentFormattingSheet.cssProperties.fontWeight,\n            fontStyle: currentFormattingSheet.cssProperties.fontStyle,\n            textDecoration: currentFormattingSheet.cssProperties.textDecoration,\n            color: currentFormattingSheet.cssProperties.color,\n          },\n        };\n        return formattingSheet;\n      });\n      const result: Contract.WorkbookFormatting = {\n        formattingSheets: formattingMap,\n      };\n      return result;\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\n\n/**\n * Implementation of the external WorksheetContent namespace.\n * This does not follow the Impl pattern as WorksheetContent is\n * currently just a (single) property bag.\n */\nexport class WorksheetContent implements Contract.WorksheetContent {\n  public constructor(private _worksheet: Contract.ExtensionWorksheet) {}\n\n  public get worksheet(): Contract.ExtensionWorksheet {\n    return this._worksheet;\n  }\n}\n","import { ExecuteParameters, ExtensionBootstrapInfo, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceImplBase } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\nimport { InitializationService } from '../InitializationService';\n\nexport class InitializationServiceImpl extends ServiceImplBase implements InitializationService {\n  public get serviceName(): string {\n    return ExtensionsServiceNames.InitializationService;\n  }\n\n  public initializeDashboardExtensionsAsync(isExtensionDialog: boolean, contextMenuIds: string[]): Promise<ExtensionBootstrapInfo> {\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'initializeDashboardExtensionsAsync',\n      [ParameterId.ExtensionContextMenuIds]: contextMenuIds,\n      [ParameterId.IsExtensionDialog]: isExtensionDialog,\n    };\n\n    return this.execute(VerbId.InitializeExtension, params).then<ExtensionBootstrapInfo>((response) => {\n      // TODO - Validate return value\n\n      const result = response.result as ExtensionBootstrapInfo;\n      return result;\n    });\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ExtensionSettingsInfo, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceImplBase, TableauError } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\nimport { SettingsCollection, SettingsService } from '../SettingsService';\n\nexport class SettingsServiceImpl extends ServiceImplBase implements SettingsService {\n  public get serviceName(): string {\n    return ExtensionsServiceNames.SettingsService;\n  }\n\n  public saveSettingsAsync(settings: SettingsCollection): Promise<SettingsCollection> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'saveSettingsAsync',\n      [ParameterId.SettingsValues]: settings,\n    };\n\n    return this.execute(VerbId.SaveExtensionSettings, parameters).then<SettingsCollection>((value) => {\n      const result = value.result as ExtensionSettingsInfo;\n\n      if (!result || !result.settingsValues) {\n        throw new TableauError(ErrorCodes.InternalError, 'Unexpected error savings settings.');\n      }\n\n      return result.settingsValues;\n    });\n  }\n}\n","import { DialogOptions, DialogStyle, ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ExtensionDialogResult, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ErrorHelpers, ExternalToInternalEnumMappings, ServiceImplBase, TableauError } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\nimport { UIService } from '../UIService';\n\nconst DEFAULT_DIALOG_HEIGHT = 400; // in pixels\nconst DEFAULT_DIALOG_WIDTH = 600; // in pixels\nconst DEFAULT_DIALOG_STYLE: DialogStyle = DialogStyle.Window;\n\nexport class UIServiceImpl extends ServiceImplBase implements UIService {\n  public get serviceName(): string {\n    return ExtensionsServiceNames.UIService;\n  }\n\n  public displayDialogAsync(url: string, payload: string, options?: DialogOptions): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'displayDialogAsync',\n      [ParameterId.ExtensionDialogUrl]: url,\n      [ParameterId.ExtensionDialogPayload]: payload,\n    };\n\n    const h: number = options && options.height ? options.height : DEFAULT_DIALOG_HEIGHT;\n    const w: number = options && options.width ? options.width : DEFAULT_DIALOG_WIDTH;\n    const dialogStyle: DialogStyle = options && options.dialogStyle ? options.dialogStyle : DEFAULT_DIALOG_STYLE;\n\n    // On the platform side, we do something reasonable regardess of whether the passed\n    // height and width are too large or too small.  But this likely indicates a developer error,\n    // so we throw an error here to help with debugging.\n    if (h <= 0 || w <= 0) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'Size parameters for displayDialogAsync must be positive');\n    }\n\n    parameters[ParameterId.ExtensionDialogH] = h;\n    parameters[ParameterId.ExtensionDialogW] = w;\n    ErrorHelpers.verifyEnumValue<DialogStyle>(dialogStyle, DialogStyle, 'DialogStyle');\n    parameters[ParameterId.ExtensionDialogStyle] = ExternalToInternalEnumMappings.dialogStyles.convert(dialogStyle);\n\n    return this.execute(VerbId.DisplayDialog, parameters).then((response) => {\n      const dialogResult = response.result as ExtensionDialogResult;\n      switch (dialogResult) {\n        case ExtensionDialogResult.DialogAlreadyOpen:\n          throw new TableauError(ErrorCodes.DialogAlreadyOpen, 'There already exists an open dialog for this extension.');\n        case ExtensionDialogResult.InvalidDomain:\n          throw new TableauError(\n            ErrorCodes.InvalidDomainDialog,\n            'The url of an extension dialog must match the domain of the parent extension.',\n          );\n        default:\n          // Success case\n          return;\n      }\n    });\n  }\n\n  public closeDialog(payload?: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'closeDialog',\n    };\n\n    if (payload) {\n      parameters[ParameterId.ExtensionDialogPayload] = payload;\n    }\n\n    return this.execute(VerbId.CloseDialog, parameters).then(() => {\n      return;\n    });\n  }\n\n  public setClickThroughAsync(clickThroughEnabled: boolean, extensionZoneId: number): Promise<void> {\n    ErrorHelpers.verifyParameterType(clickThroughEnabled, 'boolean', 'clickThroughEnabled');\n\n    if (extensionZoneId === undefined || extensionZoneId <= 0) {\n      throw new TableauError(ErrorCodes.InternalError, 'Extension Id is invalid.');\n    }\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.ExtensionZoneId]: extensionZoneId,\n      [ParameterId.ClickThroughEnabled]: clickThroughEnabled,\n    };\n\n    return this.execute(VerbId.SetClickThrough, parameters).then(() => {\n      return;\n    });\n  }\n}\n","import { InternalApiDispatcher } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry } from '@tableau/api-shared-js';\nimport { InitializationServiceImpl } from './Impl/InitializationServiceImpl';\nimport { SettingsServiceImpl } from './Impl/SettingsServiceImpl';\nimport { UIServiceImpl } from './Impl/UIServiceImpl';\nimport { ExtensionsRegistryId } from './ServiceRegistryUtil';\n\nexport function registerAllExtensionsServices(dispatcher: InternalApiDispatcher): void {\n  ApiServiceRegistry.get(ExtensionsRegistryId).registerService(new SettingsServiceImpl(dispatcher, ExtensionsRegistryId));\n  ApiServiceRegistry.get(ExtensionsRegistryId).registerService(new UIServiceImpl(dispatcher, ExtensionsRegistryId));\n}\n\nexport function registerInitializationExtensionsServices(dispatcher: InternalApiDispatcher): void {\n  ApiServiceRegistry.get(ExtensionsRegistryId).registerService(new InitializationServiceImpl(dispatcher, ExtensionsRegistryId));\n}\n","export const ExtensionsRegistryId = 0;\n","// This file re-exports everything which is part of the extensions api public interface\n\nexport * from './ExternalContract/Embedding/AskDataInterfaces';\nexport {\n  ApiMenuType,\n  CrosstabFileFormat,\n  DeviceType,\n  EmbeddingErrorCodes,\n  TableauEventType as EmbeddingTableauEventType,\n  FileFormats,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  SheetSizeBehavior,\n  TableauDialogType,\n  Toolbar,\n} from './ExternalContract/Embedding/Enums';\nexport {\n  CustomViewEvent,\n  CustomMarkContextMenuEvent as EmbeddingCustomMarkContextMenuEvent,\n  FilterChangedEvent as EmbeddingFilterChangedEvent,\n  MarksSelectedEvent as EmbeddingMarkSelectedEvent,\n  ParameterChangedEvent as EmbeddingParameterChangedEvent,\n  SummaryDataChangedEvent as EmbeddingSummaryDataChangedEvent,\n  TableauSheetEvent as EmbeddingTableauSheetEvent,\n  TableauWorksheetEvent as EmbeddingTableauWorksheetEvent,\n  ToolbarStateChangedEvent as EmbeddingToolbarStateChangedEvent,\n  FirstVizSizeKnownEvent,\n  StoryPointSwitchedEvent,\n  TabSwitchedEvent,\n  UrlActionEvent,\n  VizLoadErrorEvent,\n  WorkbookPublishedAsEvent,\n} from './ExternalContract/Embedding/EventInterfaces';\nexport { Parameter as EmbeddingParameter } from './ExternalContract/Embedding/ParameterInterfaces';\nexport * from './ExternalContract/Embedding/PulseInterfaces';\nexport {\n  ContextMenuOptions,\n  EmbeddingAbstractQuery,\n  AuthoringWorksheet as EmbeddingAuthoringWorksheet,\n  Dashboard as EmbeddingDashboard,\n  DashboardObject as EmbeddingDashboardObject,\n  Sheet as EmbeddingSheet,\n  EmbeddingVizStateWithDataModel,\n  Worksheet as EmbeddingWorksheet,\n  HierarchicalLevels,\n  SheetInfo,\n  SheetSize,\n} from './ExternalContract/Embedding/SheetInterfaces';\nexport { Story, StoryPoint, StoryPointInfo } from './ExternalContract/Embedding/StoryInterfaces';\nexport * from './ExternalContract/Embedding/TableauError';\nexport * from './ExternalContract/Embedding/VizInterfaces';\nexport * from './ExternalContract/Embedding/WebComponentInterfaces';\nexport {\n  CustomView,\n  AuthoringWorkbook as EmbeddingAuthoringWorkbook,\n  Workbook as EmbeddingWorkbook,\n} from './ExternalContract/Embedding/WorkbookInterface';\nexport * from './SharedApiExternalContract';\n","// This file re-exports everything which is part of the extensions api public interface\n\nexport * from './ExternalContract/Extensions/EventInterface';\nexport { DashboardContent } from './ExternalContract/Extensions/Namespaces/DashboardContent';\nexport { Environment } from './ExternalContract/Extensions/Namespaces/Environment';\nexport { Extensions } from './ExternalContract/Extensions/Namespaces/Extensions';\nexport { Settings } from './ExternalContract/Extensions/Namespaces/Settings';\nexport {\n  ErrorCodes,\n  ExtensionContext,\n  ExtensionMode,\n  TableauEventType,\n  VizImageEncodingType,\n  VizImagePaletteType,\n  VizImageSizeSettingAlignmentType,\n  VizImageSizeSettingType,\n  VizImageSortDirectionType,\n} from './ExternalContract/Extensions/Namespaces/Tableau';\nexport * from './ExternalContract/Extensions/Namespaces/UI';\nexport { WorksheetContent } from './ExternalContract/Extensions/Namespaces/WorksheetContent';\nexport * from './ExternalContract/Extensions/ParameterInterfaces';\nexport {\n  DashboardObjectPositionAndSizeUpdate,\n  DashboardObjectPositionAndSizeUpdateArray,\n  DashboardObjectVisibilityMap,\n  Dashboard as ExtensionDashboard,\n  DashboardObject as ExtensionDashboardObject,\n  Sheet as ExtensionSheet,\n  Worksheet as ExtensionWorksheet,\n  Point,\n  ZoneVisibilityMap,\n} from './ExternalContract/Extensions/SheetInterfaces';\nexport * from './ExternalContract/Extensions/TableauError';\nexport { Workbook as ExtensionWorkbook } from './ExternalContract/Extensions/WorkbookInterfaces';\nexport * from './SharedApiExternalContract';\n","/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\n\nexport * from './EmbeddingApiExternalContract';\nexport * from './ExtensionsApiExternalContract';\n","import { WebComponentLocalSettings, WebComponentSettingsShared } from './WebComponentInterfaces';\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-ask-data> web component.\n * @ignore\n * @deprecated\n */\nexport enum AskDataAttributes {\n  Origin = 'origin',\n  ShowEmbed = 'show-embed',\n  ShowPin = 'show-pin',\n  ShowSave = 'show-save',\n  ShowShare = 'show-share',\n}\n\n/**\n * @deprecated\n */\nexport interface AskDataSettings extends WebComponentSettingsShared, WebComponentLocalSettings {\n  /**\n   * Indicates whether the embed button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-embed>\n   * ```\n   */\n  showEmbed?: boolean;\n\n  /**\n   * Indicates whether the pin button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-pin>\n   * ```\n   */\n  showPin?: boolean;\n\n  /**\n   * Indicates whether the save button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-save>\n   * ```\n   */\n  showSave?: boolean;\n\n  /**\n   * Indicates whether the share button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-share>\n   * ```\n   */\n  showShare?: boolean;\n\n  /**\n   *  Used for telemetry\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" origin=\"embeddingSite\">\n   * ```\n   */\n  origin?: string;\n}\n\n/**\n * The interface for the top level AskData object.\n * @deprecated\n **/\nexport interface AskData extends AskDataSettings {}\n","// All enum values made available to Embedding developers.\n// Enums should be kept in alphabetical order.\n// Most of them should match an enum on the server defined at\n// workgroup/vqlweb/scriptsharp/src/ApiShared/PublicEnums.cs#L398:17\n\n/**\n * Crosstab file formats available to use with {@link Viz.exportCrosstabAsync}\n */\nexport enum CrosstabFileFormat {\n  CSV = 'csv',\n  Excel = 'xlsx',\n}\n\n/**\n * Device types available to use with {@link Viz.device}\n */\nexport enum DeviceType {\n  Default = 'default',\n  Desktop = 'desktop',\n  Tablet = 'tablet',\n  Phone = 'phone',\n}\n\n/**\n * All error codes used by the Embedding API.\n */\nexport enum EmbeddingErrorCodes {\n  /**\n   * Raised when a request to the auth endpoint fails.\n   */\n  AuthFailed = 'auth-failed',\n  /**\n   * The browser is not capable of supporting the Tableau Embedding API\n   */\n  BrowserNotCapable = 'browser-not-capable',\n  /**\n   * The permissions on a workbook or a view do not allow downloading the workbook.\n   */\n  DownloadWorkbookNotAllowed = 'download-workbook-not-allowed',\n  /**\n   * Thrown when an error occurs while attempting to perform a filter operation.\n   */\n  FilterCannotBePerformed = 'filter-cannot-be-performed',\n  /**\n   * Thrown when attempting to switch to a sheet by index that does not exist in the workbook.\n   */\n  IndexOutOfRange = 'index-out-of-range',\n  /**\n   * Thrown when an error occurs within the Tableau Embedding API. Contact Tableau Support.\n   */\n  InternalError = 'internal-error',\n  /**\n   * An operation was attempted on a custom view that does not exist.\n   */\n  InvalidCustomViewName = 'invalid-custom-view-name',\n  /**\n   * An invalid date was specified in a method that required a date parameter.\n   */\n  InvalidDateParameter = 'invalid-date-parameter',\n  /**\n   * Either a filter operation was attempted on a field that does not exist in the data source, or the value supplied\n   * in the filter operation is the wrong data type or format.\n   */\n  invalidFilterFieldNameOrValue = 'invalid-filter-field-name',\n  /**\n   * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message\n   * field.\n   */\n  InvalidParameter = 'invalid-parameter',\n  /**\n   * A negative size was specified or the maxSize value is less than minSize in Sheet.changeSizeAsync().\n   */\n  InvalidSize = 'invalid-size',\n  /**\n   * Attempted to get an authoring worksheet when the current sheet is not a worksheet.\n   * @ignore\n   */\n  InvalidSheetType = 'invalid-sheet-type',\n  /**\n   * A behavior value was found that is not included in the SheetSizeBehavior enum.\n   */\n  InvalidSizeBehavior = 'invalid-size-behavior',\n  /**\n   * A behavior other than SheetSizeBehavior.Automatic was specified in Sheet.changeSizeAsync() when the sheet is a\n   * Worksheet instance.\n   */\n  InvalidSizeBehaviorOnWorksheet = 'invalid-size-behavior-on-worksheet',\n  /**\n   * The URL specified in the Viz class constructor is not valid.\n   */\n  InvalidUrl = 'invalid-url',\n  /**\n   * The maxSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.AtMost.\n   */\n  MissingMaxSize = 'missing-max-size',\n  /**\n   * The minSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.AtLeast.\n   */\n  MissingMinSize = 'missing-min-size',\n  /**\n   * The minSize or maxSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.Range.\n   */\n  MissingMinMaxSize = 'missing-min-max-size',\n  /**\n   * Can occur if the embedding app interacts with a parameter that has been removed from the worksheet.\n   */\n  MissingParameter = 'missing-parameter',\n  /**\n   * The rangeN field is missing for a relative date filter of type LASTN or NEXTN.\n   */\n  MissingRangeNForRelativeDateFilters = 'missing-range-n-for-relative-date-filters',\n  /**\n   * An attempt was made to access Sheet.getUrl() on a hidden sheet. Hidden sheets do not have URLs.\n   */\n  NoUrlForHiddenWorksheet = 'no-url-for-hidden-worksheet',\n  /**\n   * One or both of the parentElement or the URL parameters is not specified in the Viz constructor.\n   */\n  NoUrlOrParentElementNotFound = 'no-url-or-parent-element-not-found',\n  /**\n   * An operation was attempted on a sheet that is not active or embedded within the active dashboard.\n   */\n  NotActiveSheet = 'not-active-sheet',\n  /**\n   * A required parameter was not specified, null, or an empty string/array.\n   */\n  NullOrEmptyParameter = 'null-or-empty-parameter',\n  /**\n   * An operation was attempted on a sheet that does not exist in the workbook.\n   */\n  SheetNotInWorkbook = 'sheet-not-in-workbook',\n  /**\n   * An operation is performed on a CustomView object that is no longer valid (it has been removed).\n   */\n  StaleDataReference = 'stale-data-reference',\n  /**\n   * Unknown error triggered during the auth flow.\n   */\n  UnknownAuthError = 'unknown-auth-error',\n  /**\n   * An unknown event name was specified in the call to Viz.addEventListener or Viz.removeEventListener.\n   */\n  UnsupportedEventName = 'unsupported-event-name',\n  /**\n   * A Viz object has already been created as a child of the parentElement specified in the Viz constructor.\n   */\n  VizAlreadyInManager = 'viz-already-in-manager',\n  /**\n   * Function is not supported in the embedding api.\n   */\n  ImplementationError = 'wrong-implementation',\n  /**\n   * @NotImplemented\n   */\n  NotImplemented = 'not-implemented',\n  /**\n   * Unknown error during event initialization\n   */\n  EventInitializationError = 'event-initialization-error',\n  /**\n   * Version of the embedding api not supported by the version of tableau\n   */\n  IncompatibleVersionError = 'incompatible-version-error',\n\n  /**\n   * Unknown {@link TableauDialogType} passed in to Viz.displayDialogAsync.\n   */\n  UnknownDialogType = 'unknown-dialog-type',\n\n  /**\n   * Can occur if the API interacts with a filter that has been removed from the worksheet.\n   * Can also occurs if a {@link FilterType} has not been implemented.\n   */\n  FilterMissingOrNotImplemented = 'filter-missing-not-implemented',\n\n  /**\n   * Can occur if story point ids no longer match.\n   */\n  StoryPointIdMismatch = 'storypoint-id-mismatch',\n}\n\n/**\n * Formats available to use with displayStaticImage in @VizInterfaces\n */\nexport enum FileFormats {\n  PDF = 'pdf',\n  PNG = 'png',\n}\n\nexport enum PrintOrientation {\n  Portrait = 'portrait',\n  Landscape = 'landscape',\n}\n\nexport enum PrintPageSize {\n  Letter = 'letter',\n  Legal = 'legal',\n  Note = 'note',\n  Folio = 'folio',\n  Tabloid = 'tabloid',\n  Ledger = 'ledger',\n  Statement = 'statement',\n  Executive = 'executive',\n  A3 = 'A3',\n  A4 = 'A4',\n  A5 = 'A5',\n  B4 = 'B4',\n  B5 = 'B5',\n  Quarto = 'quarto',\n  Unspecified = 'unspecified',\n}\n\nexport enum PrintScaling {\n  Automatic = 'automatic',\n  Perc25 = '25%',\n  Perc50 = '50%',\n  Perc60 = '60%',\n  Perc75 = '75%',\n  Perc80 = '80%',\n  Perc90 = '90%',\n  Perc100 = '100%',\n  Perc200 = '200%',\n  Perc400 = '400%',\n  AtMost1PageHigh = 'at-most-1-page-high',\n  AtMost2PagesHigh = 'at-most-2-pages-high',\n  AtMost1PageWide = 'at-most-1-page-wide',\n  AtMost2PagesWide = 'at-most-2-pages-wide',\n}\n\nexport enum RevertVizSelection {\n  All = 'all',\n  Axes = 'axes',\n  Filters = 'filters',\n  Sorts = 'sorts',\n  Shelves = 'shelves',\n}\n\nexport enum ToolbarButtons {\n  Alerts = 'alerts',\n  AskData = 'askData',\n  CustomViews = 'customViews',\n  DataDetails = 'dataDetails',\n  Share = 'share',\n  Subscribe = 'subscribe',\n}\n\nexport enum Toolbar {\n  Top = 'top',\n  Bottom = 'bottom',\n  Hidden = 'hidden',\n}\n\nexport enum SheetSizeBehavior {\n  Automatic = 'automatic',\n  Exactly = 'exactly',\n  Range = 'range',\n  AtLeast = 'atleast',\n  AtMost = 'atmost',\n}\n\n/**\n * Be careful when adding new event types. Extensions and embedding follow two different patterns on how events are named.\n * Events should be all lower case and without hyphens or underscores.\n */\n\n/**\n * Represents the type of tableau embedding event that can be listened for.\n */\nexport enum TableauEventType {\n  /**\n   * Raised when a custom view has finished loading. This event is raised after the callback function for {@link FirstInteractive} (if any) has been called.\n   *\n   * @category Viewing\n   */\n  CustomViewLoaded = 'customviewloaded',\n\n  /**\n   * Raised when a custom view has been removed.\n   *\n   * @category Viewing\n   */\n  CustomViewRemoved = 'customviewremoved',\n\n  /**\n   * Raised when a custom view has been saved (newly created or updated).\n   *\n   * @category Viewing\n   */\n  CustomViewSaved = 'customviewsaved',\n\n  /**\n   * Raised when a custom view has been set as the default view for a workbook.\n   *\n   * @category Viewing\n   */\n  CustomViewSetDefault = 'customviewsetdefault',\n\n  /** Raised when the user clicks on the Edit Button.\n   *\n   * @category Viewing\n   */\n  EditButtonClicked = 'editbuttonclicked',\n\n  /** Raised when the user clicks on the Edit In Desktop Button.\n   *\n   * @category Authoring, Viewing\n   */\n  EditInDesktopButtonClicked = 'editindesktopbuttonclicked',\n\n  /** Raised when any filter has changed state. You can use this event type with TableauViz objects.\n   *\n   * @category Viewing\n   */\n  FilterChanged = 'filterchanged',\n\n  /** Fired when viz size is known\n   *\n   * @category Authoring, Viewing\n   */\n  FirstVizSizeKnown = 'firstvizsizeknown',\n\n  /** Fired when a viz first becomes interactive\n   *\n   * @category Authoring, Viewing\n   */\n  FirstInteractive = 'firstinteractive',\n\n  /** Raised when a custom mark context menu is clicked.\n   *\n   * @category Viewing\n   */\n  CustomMarkContextMenuEvent = 'custommarkcontextmenu',\n\n  /** The selected marks on a visualization have changed. You can use this event type with TableauViz objects.\n   *\n   * @category Viewing\n   */\n  MarkSelectionChanged = 'markselectionchanged',\n\n  /** A parameter has had its value modified. You can use this event type with [[Parameter]] objects.\n   *\n   * @category Viewing\n   */\n  ParameterChanged = 'parameterchanged',\n\n  /** Raised when a toolbar button or control becomes available or becomes unavailable.\n   *\n   * @category Viewing\n   */\n  ToolbarStateChanged = 'toolbarstatechanged',\n\n  /** Raised when the workbook is ready to close. This notification is sent when using embedded web authoring functionality.\n   *\n   * @category Authoring\n   */\n  WorkbookReadyToClose = 'workbookreadytoclose',\n\n  /** Raised when the workbook has been published. This notification is sent when using embedded web authoring functionality.\n   *\n   * @category Authoring\n   */\n  WorkbookPublished = 'workbookpublished',\n\n  /** Raised when \"publish as\" is successful. This notification is sent when using embedded web authoring functionality.\n   *\n   * @category Authoring\n   */\n  WorkbookPublishedAs = 'workbookpublishedas',\n\n  /**\n   * Raised when a URL action occurs. See the {@link UrlActionEvent} class.\n   *\n   * @category Viewing\n   */\n  UrlAction = 'urlaction',\n\n  /**\n   * Raised after a tab switch occurs (the active sheet has changed). Guarantees the viz object will be interactive after this.\n   *\n   * @category Viewing\n   */\n  TabSwitched = 'tabswitched',\n  /**\n   *\n   * Raised after a new story point becomes active.\n   *\n   * @category Viewing\n   */\n  StoryPointSwitched = 'storypointswitched',\n  /**\n   *\n   * Raised when an error occurs while loading the contents of the webcomponent.\n   *\n   * @category Authoring, Viewing, AskData\n   */\n  VizLoadError = 'vizloaderror',\n  /**\n   * Raised after the iframe src attribute has been updated\n   *\n   * @category Authoring, Viewing, AskData\n   */\n  IframeSrcUpdated = 'iframesrcupdated',\n\n  /**\n   * Raised when changes are made to summary data.\n   *\n   * @category Viewing\n   */\n  SummaryDataChanged = 'summarydatachanged',\n\n  /**\n   * Raised when tableau (viz-client) is ready to receive an auth token.\n   * Used for authentication in salesforce native mode.\n   *\n   * @hidden\n   * @category Authoring, Viewing,\n   */\n  ReadyToReceiveAuthToken = 'readytoreceiveauthtoken',\n}\n\n/**\n * Represents the location of a context menu where users can add external menu items.\n */\nexport enum ApiMenuType {\n  /** External menu item will be injected in ubertip dialog */\n  Ubertip = 'ubertip',\n}\n\n/** You can use this type with a {@link Viz} object. */\nexport enum TableauDialogType {\n  /**\n   * Used to display the download PDF dialog.\n   */\n  ExportPDF = 'export-pdf',\n  /**\n   * Used to display the download PowerPoint dialog.\n   */\n  ExportPowerPoint = 'export-powerpoint',\n  /**\n   * Used to display the download Data dialog.\n   */\n  ExportData = 'export-data',\n  /**\n   * Used to display the download CrossTab dialog.\n   */\n  ExportCrossTab = 'export-cross-tab',\n  /**\n   * Used to display the download Workbook dialog.\n   */\n  ExportWorkbook = 'export-workbook',\n  /**\n   * Used to display the Share dialog.\n   */\n  Share = 'share',\n}\n","import { WebComponentLocalSettings } from './WebComponentInterfaces';\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-pulse> web component.\n * @ignore\n */\nexport enum PulseAttributes {\n  DisableExploreFilter = 'disable-explore-filter',\n}\n\nexport interface PulseSettings extends WebComponentLocalSettings {\n  /**\n   * Indicates whether the explore filter is hidden or visible.\n   * ```\n   * <tableau-pulse id=\"tableauPulse\" disable-explore-filter>\n   * ```\n   */\n  disableExploreFilter?: boolean;\n\n  /**\n   * The token used for authorization\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-authoring-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-ask-data id=\"tableauAskData\" token=\"some-token-containing-clientId\" />\n   * ```\n   */\n  token?: string;\n}\n\n/**\n * The interface for the top-level Pulse object.\n **/\nexport interface Pulse extends PulseSettings {}\n","import {\n  CrosstabFileFormat,\n  DeviceType,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  TableauDialogType,\n  TableauEventType,\n  Toolbar,\n} from './Enums';\nimport { SheetSize } from './SheetInterfaces';\nimport { WebComponentLocalSettings, WebComponentSettingsShared } from './WebComponentInterfaces';\nimport { Workbook } from './WorkbookInterface';\n\n/**\n * The shared string constants you can use as HTML attributes for the <tableau-viz> and <tableau-authoring-viz> web component.\n * @ignore\n */\nexport enum VizSharedAttributes {\n  TouchOptimize = 'touch-optimize',\n  HideEditInDesktopButton = 'hide-edit-in-desktop-button',\n  SuppressDefaultEditBehavior = 'suppress-default-edit-behavior',\n  DisableVersionCheck = 'disable-version-check',\n  OnEditInDesktopButtonClicked = 'onEditInDesktopButtonClicked',\n  OnFirstVizSizeKnown = 'onFirstVizSizeKnown',\n  OnFirstInteractive = 'onFirstInteractive',\n}\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-viz> web component.\n * @ignore\n */\nexport enum VizAttributes {\n  DisableUrlActionsPopups = 'disable-url-actions',\n  HideTabs = 'hide-tabs',\n  Toolbar = 'toolbar',\n  InstanceIdToClone = 'instance-id-to-clone',\n  Device = 'device',\n  HideEditButton = 'hide-edit-button',\n  OnEditButtonClicked = 'onEditButtonClicked',\n  OnFilterChanged = 'onFilterChanged',\n  OnCustomMarkContextMenuEvent = 'onCustomMarkContextMenuEvent',\n  OnMarkSelectionChanged = 'onMarkSelectionChanged',\n  OnParameterChanged = 'onParameterChanged',\n  OnToolbarStateChanged = 'onToolbarStateChanged',\n  OnUrlAction = 'onUrlAction',\n  OnTabSwitched = 'onTabSwitched',\n  OnCustomViewLoaded = 'onCustomViewLoaded',\n  OnCustomViewRemoved = 'onCustomViewRemoved',\n  OnCustomViewSaved = 'onCustomViewSaved',\n  OnCustomViewSetDefault = 'onCustomViewSetDefault',\n  OnStoryPointSwitched = 'onStoryPointSwitched',\n  OnSummaryDataChanged = 'onSummaryDataChanged',\n  OnReadyToReceiveAuthToken = 'onReadyToReceiveAuthToken',\n}\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-authoring-viz> web component.\n * @ignore\n */\nexport enum VizAuthoringAttributes {\n  OnWorkbookPublished = 'onWorkbookPublished',\n  OnWorkbookPublishedAs = 'onWorkbookPublishedAs',\n  OnWorkbookReadyToClose = 'onWorkbookReadyToClose',\n  HideCloseButton = 'hide-close-button',\n}\n\n/**\n * The names of the string constants you can use as child tags for TableauViz and TableauAuthoringViz custom elements.\n */\nexport enum VizChildElements {\n  /**\n   * Contains a list of filter parameters. Available only in viewing mode.\n   */\n  VizFilter = 'viz-filter',\n\n  /**\n   * Contains a name and value for a parameter. Available only in viewing mode.\n   */\n  VizParameter = 'viz-parameter',\n\n  /**\n   * Contains a list of custom parameters.  Available in both viewing and authoring modes.\n   */\n  CustomParameter = 'custom-parameter',\n}\n\nexport enum VizChildElementAttributes {\n  Field = 'field',\n  Value = 'value',\n  Name = 'name',\n}\n\n/**\n * The interface for the top level Viz object.\n **/\nexport interface Viz extends VizSettings, WebComponentLocalSettings, VizActions {\n  /**\n   * One Workbook is supported per visualization.\n   */\n  readonly workbook?: Workbook;\n\n  /**\n   * Provide an auth token for salesforce native mode\n   * @param token\n   */\n  setAuthToken(token: string): void;\n}\n\n/**\n * The interface for the top level Authoring Viz object.\n */\nexport interface AuthoringViz extends VizAuthoringSettings, WebComponentLocalSettings {\n  /**\n   * Gets the visualization's current URL.\n   */\n  getCurrentSrcAsync(): Promise<string>;\n\n  /**\n   * Provide an auth token for salesforce native mode\n   * @param token\n   */\n  setAuthToken(token: string): void;\n}\n\n/**\n * Partially implemented - Actions related to events and state of the viz\n */\nexport interface VizActions {\n  /**\n   * Indicates whether automatic updates are currently paused.\n   */\n  readonly automaticUpdatesArePaused: boolean;\n\n  /**\n   * Pause layout updates. This is useful if you are resizing the visualization or performing multiple calls that could affect the layout.\n   */\n  pauseAutomaticUpdatesAsync(): Promise<void>;\n\n  /**\n   * Resume layout updates.\n   */\n  resumeAutomaticUpdatesAsync(): Promise<void>;\n\n  /**\n   * Toggle layout updates.\n   */\n  toggleAutomaticUpdatesAsync(): Promise<void>;\n\n  /**\n   * Equivalent to clicking on the Revert All toolbar button, which restores the workbook to its starting state.\n   */\n  revertAllAsync(): Promise<void>;\n\n  /**\n   * Equivalent to clicking on the Refresh Data toolbar button.\n   */\n  refreshDataAsync(): Promise<void>;\n\n  /**\n   * Equivalent to clicking on Download > Image from the toolbar, which creates a PNG file of the current visualization.\n   */\n  exportImageAsync(): Promise<void>;\n\n  /**\n   * Exports the crosstab of any given worksheet within the current view to a\n   * specified format (CrosstabFileFormat.Excel, CrosstabFileFormat.CSV).\n   * Throws an error if the sheet name does not match any worksheets within the active sheet.\n   * Throws an error if the crosstab file failed to be created.\n   * Note: exportCrosstabAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * viz.exportCrosstabAsync('Sales by Segment', CrosstabFileFormat.CSV);\n   * ```\n   */\n  exportCrosstabAsync(sheetName: string, format: CrosstabFileFormat): Promise<void>;\n\n  /**\n   * Exports the summary data shown in the View Data window\n   * (shown when you click Download > Data from the toolbar for any given worksheet within the current view).\n   * The current file format is CSV. There is no limitation on the amount of summary data you can export.\n   * Throws an error if the sheet name does not match any worksheets within the active sheet.\n   * Throws an error if the CSV file failed to be created.\n   * Note: exportDataAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * const activeSheet = viz.workbook.activeSheet;\n   * if (activeSheet.sheetType === SheetType.Worksheet) {\n   *   const columns = await activeSheet.getSummaryColumnsInfoAsync();\n   *   // Getting fieldId's for Latitude and Longitude columns\n   *   const columnsToIncludeById = columns.map((column) => {\n   *     if (column.fieldName === 'Latitude' || column.fieldName === 'Longitude') {\n   *       return column.fieldId;\n   *     }\n   *   });\n   *   await viz.exportDataAsync(activeSheet.name, { columnsToIncludeById });\n   * }\n   * else if (activeSheet.sheetType === SheetType.Dashboard) {\n   *   // Exporting the summary data for each worksheet in the dashboard while also ignoring aliases\n   *   for (const worksheet of activeSheet.worksheets) {\n   *     await viz.exportDataAsync(worksheet.name, { ignoreAliases: true });\n   *   }\n   * }\n   * else\n   * {\n   *   // activeSheet is a Story and we want to export worksheets within the current view\n   *   const containedSheet = activeSheet.activeStoryPoint.containedSheet;\n   *   if (containedSheet !== undefined && containedSheet.sheetType === SheetType.Worksheet) {\n   *     // Exporting summary data of a worksheet within the active story point\n   *     await viz.exportDataAsync(containedSheet.name);\n   *   } else if (containedSheet !== undefined && containedSheet.sheetType === SheetType.Dashboard) {\n   *     // Exporting the summary data for each worksheet within the active story point\n   *     for (const worksheet of containedSheet.worksheets) {\n   *       await viz.exportDataAsync(worksheet.name);\n   *     }\n   *   }\n   * }\n   * ```\n   */\n  exportDataAsync(sheetName: string, options?: ExportDataOptions): Promise<void>;\n\n  /**\n   * Exports the list of sheets to a PowerPoint file. If no sheets are specified, the current sheet is exported.\n   * The order the sheets appear in the list is the order the sheets appear in the PowerPoint file.\n   * The list of sheets can either exclusively include the worksheets within a dashboard or exclusively include the published sheets from the workbook.\n   *\n   * Throws an error if the list of sheets contains both worksheets within a dashboard and published sheets from the workbook.\n   * Throws an error if the PowerPoint file fails to be created.\n   *\n   * Note: exportPowerPointAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * const workbook = viz.workbook;\n   * const activeSheet = workbook.activeSheet;\n   * if (activeSheet.sheetType === SheetType.Worksheet || activeSheet.sheetType === SheetType.Story) {\n   *   await viz.exportPowerPointAsync();\n   * } else if (activeSheet.sheetType ===  SheetType.Dashboard) {\n   *   const worksheetNames = activeSheet.worksheets.map((worksheet) => worksheet.name);\n   *   await viz.exportPowerPointAsync(worksheetNames);\n   * }\n   * // exporting all sheets within the workbook to PowerPoint\n   * const publishedSheetNames = workbook.publishedSheetsInfo.map((publishedSheetInfo) => publishedSheetInfo.name);\n   * await viz.exportPowerPointAsync(publishedSheetNames);\n   * ```\n   */\n  exportPowerPointAsync(sheetNames?: Array<string>): Promise<void>;\n\n  /**\n   * Exports the list of sheets with the given {@link ExportPDFOptions} options. If no sheets are specified, the current sheet is exported.\n   * The list of sheets can either exclusively include the worksheets within a dashboard or exclusively include the published sheets from the workbook.\n   * If no ExportPDFOptions are specified, the default settings are: Scaling = Automatic, PageSize = Letter, and Orientation = Portrait.\n   *\n   * Throws an error if the list of sheets contains both worksheets within a dashboard and published sheets from the workbook.\n   * Throws an error if the PDF file fails to be created.\n   *\n   * Note: exportPDFAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * const workbook = viz.workbook;\n   * const activeSheet = workbook.activeSheet;\n   * if (activeSheet.sheetType === SheetType.Worksheet || activeSheet.sheetType === SheetType.Story) {\n   *   await viz.exportPDFAsync();\n   * } else if (activeSheet.sheetType ===  SheetType.Dashboard) {\n   *   const worksheetNames = activeSheet.worksheets.map((worksheet) => worksheet.name);\n   *   await viz.exportPDFAsync(worksheetNames);\n   * }\n   * // exporting all sheets within the workbook to PDF\n   * const publishedSheetNames = workbook.publishedSheetsInfo.map((publishedSheetInfo) => publishedSheetInfo.name);\n   * await viz.exportPDFAsync(publishedSheetNames);\n   * ```\n   */\n  exportPDFAsync(sheetNames?: Array<string>, options?: ExportPDFOptions): Promise<void>;\n\n  /**\n   * Display one of the export dialogs based on the dialogType parameter\n   *\n   * Throws an error if dialogType is invalid\n   */\n  displayDialogAsync(dialogType: TableauDialogType): Promise<void>;\n\n  /**\n   * Gets the visualization's current URL.\n   */\n  getCurrentSrcAsync(): Promise<string>;\n\n  /**\n   * Redoes the last action performed on a sheet.\n   */\n  redoAsync(): Promise<void>;\n\n  /**\n   * Undoes the last action performed on a sheet.\n   */\n  undoAsync(): Promise<void>;\n\n  /**\n   * Adds an event listener to the specified event.\n   *\n   * ```\n   * async function getSelectedMarks(event) {\n   *     const marksSelected = await event.detail.getMarksAsync();\n   *     const numMarks = marksSelected.data[0].data.length;\n   *     console.log(`${numMarks} marks Selected`);\n   * }\n   *\n   * let viz = document.getElementById('tableauViz');\n   * viz.addEventListener(\"markselectionchanged\", getSelectedMarks);\n   * ```\n   */\n  addEventListener(type: TableauEventType, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;\n\n  /**\n   * Removes an event listener from the specified event.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * viz.removeEventListener(\"markselectionchanged\", getSelectedMarks);\n   * ```\n   */\n  removeEventListener(type: TableauEventType, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;\n\n  /**\n   * Use this method to filter the viz before initialization. If used after initialization, it will re-render the viz.\n   * For filtering after initialization, use the other filtering methods, such as `applyFilterAsync`.\n   *\n   * If you add the same filter fields using the `addFilter()` method and by using the `<viz-filter>` element in the `<tableau-viz>` web component,\n   * you might experience unexpected behavior.\n   *\n   * @param fieldName The name of the field to filter on.\n   * @param value Single value or a list of comma separated values to filter on.\n   *\n   * ```\n   * viz.addFilter('Region', 'Central,West');\n   * ```\n   */\n  addFilter(fieldName: string, value: string): void;\n}\n\nexport interface VizSize {\n  /**\n   * Gets the sheetSize record for the current sheet\n   */\n  readonly sheetSize: SheetSize;\n\n  /**\n   * Gets the height of the Tableau UI elements (the chrome) surrounding the view.\n   */\n  readonly chromeHeight: number;\n}\n\n/**\n * This interface represents all of the options for configuring a viz that are common between\n * viewing and authoring mode.\n */\ninterface VizSettingsShared extends WebComponentSettingsShared {\n  /**\n   * Indicates whether to touch optimize viz controls.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" touch-optimize />\n   * <tableau-authoring-viz id=\"tableauViz\" touch-optimize />\n   * ```\n   */\n  touchOptimize?: boolean;\n\n  /**\n   * Indicates whether the Edit in Desktop button is hidden or visible.\n   * If not specified, defaults to false, meaning that the Edit in Desktop button is visible.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" hide-edit-in-desktop-button>\n   * <tableau-authoring-viz id=\"tableauViz\" hide-edit-in-desktop-button>\n   * ```\n   */\n  hideEditInDesktopButton?: boolean;\n\n  /**\n   * Indicates whether the default edit behavior is suppressed.\n   * If not specified, defaults to false, meaning that the default edit behavior is not suppressed.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" suppress-default-edit-behavior>\n   * <tableau-authoring-viz id=\"tableauViz\" suppress-default-edit-behavior>\n   * ```\n   */\n  suppressDefaultEditBehavior?: boolean;\n\n  /**\n   * An event raised when the user clicks on the Edit In Desktop Button. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onEditInDesktopButtonClicked=\"onEditInDesktopButtonClickedHandler\" />\n   * <tableau-authoring-viz id=\"tableauViz\" onEditInDesktopButtonClicked=\"onEditInDesktopButtonClickedHandler\" />\n   * ```\n   */\n  onEditInDesktopButtonClicked?: string;\n\n  /**\n   * An event raised when the size of the viz is known. You can use this event to perform tasks such as resizing\n   * the elements surrounding the Viz object once the object's size has been established.\n   * ```\n   * <tableau-viz id=\"tableauViz\" \"onFirstVizSizeKnown\"=\"onFirstVizSizeKnownHandler\" />\n   * <tableau-authoring-viz id=\"tableauViz\" onFirstVizSizeKnown=\"onFirstVizSizeKnownHandler\" />\n   * ```\n   */\n  onFirstVizSizeKnown?: string;\n\n  /**\n   * An event raised when the Viz object first becomes interactive. This is only raised once.\n   * ```\n   * <tableau-viz id=\"tableauViz\" \"onFirstInteractive\"=\"onFirstInteractiveHandler\" />\n   * <tableau-authoring-viz id=\"tableauViz\" onFirstInteractive=\"onFirstInteractiveHandler\" />\n   * ```\n   */\n  onFirstInteractive?: string;\n}\n\n/**\n * The options for configuring a viz in view mode.\n */\nexport interface VizSettings extends VizSettingsShared {\n  /**\n   * Indicates whether to suppress the execution of URL actions. This option does not prevent the URL action\n   * event from being raised. You can use this option to change what happens when a URL action occurs. If set\n   * to true and you create an event listener for the URL_ACTION event, you can use an event listener\n   * handler to customize the actions.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" disable-url-actions />\n   * ```\n   */\n  disableUrlActionsPopups?: boolean;\n\n  /**\n   * Indicates whether tabs are hidden or shown.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  hide-tabs />\n   * ```\n   */\n  hideTabs?: boolean;\n\n  /**\n   * Specifies the position of the toolbar, if it is shown. The values can be Toolbar.Top,\n   * Toolbar.Bottom or Toolbar.Hidden.\n   * If not specified, defaults to Toolbar.Bottom.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  toolbar=\"hidden\" />\n   * ```\n   */\n  toolbar?: Toolbar;\n\n  /**\n   * Specifies a device layout for a dashboard, if it exists.\n   * Values can be default, desktop, tablet, or phone.\n   * If not specified, defaults to loading a layout based on the\n   * smallest dimension of the hosting iframe element.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  device=\"desktop\" />\n   * ```\n   */\n  device?: DeviceType;\n\n  /**\n   * Specifies the ID of an existing instance to make a copy (clone) of.\n   * This is useful if the user wants to continue analysis of an existing visualization\n   * without losing the state of the original. If the ID does not refer to an existing visualization,\n   * the cloned version is derived from the original visualization.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  instance-id-to-clone=\"id1\" />\n   * ```\n   */\n  instanceIdToClone?: string;\n\n  /**\n   * Indicates whether the Edit button is hidden or visible.\n   * If not set, defaults to false, meaning that the Edit button is visible.\n   * ```\n   * <tableau-viz id=\"tableauViz\" hide-edit-button>\n   * ```\n   */\n  hideEditButton?: boolean;\n\n  /**\n   * An event raised when the user clicks on the Edit Button.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onEditButtonClicked=\"onEditButtonClickedHandler\" />\n   * ```\n   */\n  onEditButtonClicked?: string;\n\n  /**\n   * An event raised when any filter has changed state. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onFilterChanged=\"onFilterChangedHandler\" />\n   * ```\n   */\n  onFilterChanged?: string;\n\n  /**\n   * An event raised when a custom mark context menu is clicked.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomMarkContextMenuEvent=\"onCustomMarkContextMenuEventHandler\" />\n   * ```\n   */\n  onCustomMarkContextMenuEvent?: string;\n\n  /**\n   * An event raised when the selected marks on a visualization have changed. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onMarkSelectionChanged=\"onMarkSelectionChangedHandler\" />\n   * ```\n   */\n  onMarkSelectionChanged?: string;\n\n  /**\n   * An event raised when a parameter has had its value modified. You can use this event type with [[Parameter]] objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onParameterChanged=\"onParameterChangedHandler\" />\n   * ```\n   */\n  onParameterChanged?: string;\n\n  /**\n   * An event raised when a toolbar button or control becomes available or becomes unavailable.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onToolbarStateChanged=\"onToolbarStateChangedHandler\" />\n   * ```\n   */\n  onToolbarStateChanged?: string;\n\n  /**\n   * An event raised when a URL action occurs. See the {@link UrlActionEvent} class.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onUrlAction=\"onUrlActionHandler\" />\n   * ```\n   */\n  onUrlAction?: string;\n\n  /**\n   * An event raised after a tab switch occurs (the active sheet has changed). Guarantees the viz object will be interactive after this.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onTabSwitched=\"onTabSwitchedHandler\" />\n   * ```\n   */\n  onTabSwitched?: string;\n\n  /**\n   * An event raised when a custom view has finished loading. This event is raised after the callback\n   * function for {@link FirstInteractive} (if any) has been called.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewLoaded=\"onCustomViewLoadedHandler\" />\n   * ```\n   */\n  onCustomViewLoaded?: string;\n\n  /**\n   * An event raised when a custom view has been removed.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewRemoved=\"onCustomViewRemovedHandler\" />\n   * ```\n   */\n  onCustomViewRemoved?: string;\n\n  /**\n   * An event raised when a custom view has been saved (newly created or updated).\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewSaved=\"onCustomViewSavedHandler\" />\n   * ```\n   */\n  onCustomViewSaved?: string;\n\n  /**\n   * An event raised when a custom view has been set as the default view for a workbook.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewSetDefault=\"onCustomViewSetDefaultHandler\" />\n   * ```\n   */\n  onCustomViewSetDefault?: string;\n\n  /**\n   * An event raised after a new story point becomes active.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onStoryPointSwitched=\"onStoryPointSwitchedHandler\" />\n   * ```\n   */\n  onStoryPointSwitched?: string;\n\n  /**\n   * An event raised when the summary data on a visualization have changed. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onSummaryDataChanged=\"onSummaryDataChangedHandler\" />\n   * ```\n   */\n  onSummaryDataChanged?: string;\n}\n\n/**\n * (Beta) Represents the options for configuring a viz in authoring mode.\n */\nexport interface VizAuthoringSettings extends VizSettingsShared {\n  /**\n   * Indicates whether the Close button is hidden or visible.\n   * If not set, defaults to false, meaning that the Close button is visible.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" hide-close-button />\n   * ```\n   */\n  hideCloseButton?: boolean;\n\n  /**\n   * An event raised when the workbook has been published. This notification is sent when using embedded web authoring functionality.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" onWorkbookPublished=\"onWorkbookPublishedHandler\" />\n   * ```\n   */\n  onWorkbookPublished?: string;\n\n  /**\n   * An event raised when \"publish as\" is successful. This notification is sent when using embedded web authoring functionality.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" onWorkbookPublishedAs=\"onWorkbookPublishedAsHandler\" />\n   * ```\n   */\n  onWorkbookPublishedAs?: string;\n\n  /**\n   * An event raised when the workbook is ready to close. This notification is sent when using embedded web authoring functionality.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" onWorkbookReadyToClose=\"onWorkbookReadyToCloseHandler\" />\n   * ```\n   */\n  onWorkbookReadyToClose?: string;\n}\n\nexport interface FilterParameters {\n  field: string;\n  value: string;\n}\n\n/**\n * VizParameters are used to set Parameter values on the viz.\n *\n * * ```\n * <tableau-viz id=\"tableauViz\">\n *  <viz-parameter name=\"parameter-name\" value=\"parameter-value\"></viz-parameter>\n * </tableau-viz>\n * ```\n *\n */\nexport interface VizParameter {\n  /**\n   * Name of the parameter to be set.\n   */\n  name: string;\n\n  /**\n   * Valid value for the parameter being set.\n   */\n  value: string;\n}\n\n/**\n * CustomParameters are used to pass along settings, information, etc., that aren't exposed on the\n * tableau-viz element. CustomParameters will override attributes, or filters, set on the tableau-viz element.\n *\n * * ```\n * <tableau-viz id=\"tableauViz\">\n *  <custom-parameter name=\"parameter-name\" value=\"parameter-value\"></custom-parameter>\n * </tableau-viz>\n * ```\n *\n */\nexport interface CustomParameter {\n  /**\n   * Name of the parameter to be set.\n   */\n  name: string;\n\n  /**\n   * Valid value for the parameter being set.\n   */\n  value: string;\n}\n\n/**\n * Configuration object for exporting data.\n */\nexport interface ExportDataOptions {\n  /**\n   * Do not use aliases specified in the data source in Tableau. Default is false.\n   */\n  ignoreAliases?: boolean;\n  /**\n   * The columns to include specified by field id, includes all by default.\n   * The order of the column ids in the array determines the column order shown in the summary data table.\n   */\n  columnsToIncludeById?: Array<string>;\n}\n\nexport interface ExportPDFOptions {\n  scaling: PrintScaling;\n  pageSize: PrintPageSize;\n  orientation: PrintOrientation;\n}\n\nexport interface ExportScenariosForPDFAndPowerPoint {\n  currentSheetName: string;\n  exportableSheetNamesFromDashboard: Array<string>;\n  exportableSheetNamesFromWorkbook: Array<string>;\n}\n","/**\n * User supplied options that do not get passed as request parameters to load a Tableau viz, Tableau askdata\n */\nexport interface WebComponentLocalSettings {\n  /**\n   * The viz src\n   */\n  src?: string | null;\n\n  /**\n   * Represents width in pixels\n   * Can be any valid CSS size specifier. If not specified, defaults to the published width of the view.\n   */\n  width?: string | number;\n\n  /**\n   * Represents height in pixels\n   * Can be any valid CSS size specifier. If not specified, defaults to the published height of the view.\n   */\n  height?: string | number;\n}\n\n/**\n * This interface represents all of the options for configuring a webcomponent that are common between\n * viz and askdata.\n */\nexport interface WebComponentSettingsShared {\n  /**\n   * The token used for authorization\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-authoring-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-ask-data id=\"tableauAskData\" token=\"some-token-containing-clientId\" />\n   * ```\n   */\n  token?: string;\n\n  /**\n   * Indicates whether the non-minified version of JavaScript is loaded. If specified (or set to true), the\n   * non-minified version is used for both the local component and the Tableau Server visualization (if enabled).\n   * If not specified (or set to false), the minified version of the JavaScript files are loaded.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" debug />\n   * <tableau-authoring-viz id=\"tableauViz\" debug />\n   * <tableau-ask-data id=\"tableauAskData\" debug />\n   * ```\n   */\n  debug?: boolean;\n\n  /**\n   * Indicates whether to use the old auth mechanism for authentication which happens inside the iframe. If specified, VizLoadErrorEvents\n   * triggered due to auth failures will not be thrown.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" iframe-auth />\n   * <tableau-authoring-viz id=\"tableauViz\" iframe-auth />\n   * <tableau-ask-data id=\"tableauAskData\" iframe-auth />\n   * ```\n   */\n  iframeAuth?: boolean;\n}\n\n/**\n * The names of the common string constants you can use as HTML attributes for the tableau web component.\n * @ignore\n */\nexport enum WebComponentAttributes {\n  Src = 'src',\n  Width = 'width',\n  Height = 'height',\n  Token = 'token',\n  Debug = 'debug',\n  IframeAuth = 'iframe-auth',\n  OnVizLoadError = 'onvizloaderror',\n  ForceTokenSync = 'force-token-sync',\n}\n\n/**\n * The names of the string constants you can use as child tags for TableauViz, TableauAuthoringViz and TableauAskData custom elements.\n * @ignore\n */\nexport enum WebComponentChildElements {\n  /**\n   * Contains a list of custom parameters.  Available in viz viewing, viz authoring and askdata.\n   */\n  CustomParameter = 'custom-parameter',\n}\n\nexport enum WebComponentChildElementAttributes {\n  Field = 'field',\n  Value = 'value',\n  Name = 'name',\n}\n","// All enum values made available to Extensions developers.\n// Enums should be kept in alphabetical order.\n\nimport { Extensions } from './Extensions';\n\nnamespace Tableau {\n  export let extensions: Extensions;\n  /**\n   * All error codes used by the Extensions API.\n   */\n  export enum ErrorCodes {\n    /**\n     * Thrown when caller attempts to execute command before initialization has completed.\n     */\n    APINotInitialized = 'api-not-initialized',\n    /**\n     * Thrown when caller attempts to execute command while extension is not visible.\n     */\n    VisibilityError = 'visibility-error',\n    /**\n     * Only one dialog can be opened at time with the UI namespace functionality.\n     */\n    DialogAlreadyOpen = 'dialog-already-open',\n    /**\n     * The open dialog was closed by the user.\n     */\n    DialogClosedByUser = 'dialog-closed-by-user',\n    /**\n     * An error occurred within the Tableau Extensions API. Contact Tableau Support.\n     */\n    InternalError = 'internal-error',\n    /**\n     * A dialog must start on the same domain as the parent extenion.\n     */\n    InvalidDomainDialog = 'invalid-dialog-domain',\n    /**\n     * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.\n     */\n    InvalidParameter = 'invalid-parameter',\n    /**\n     * Can occur if the extension interacts with a filter that has been removed from the worksheet.\n     */\n    MissingFilter = 'missing-filter',\n    /**\n     * Can occur if the extension interacts with a parameter that has been removed from the worksheet.\n     */\n    MissingParameter = 'missing-parameter',\n    /**\n     * Internal Server Error\n     */\n    ServerError = 'server-error',\n    /**\n     * Developer cannot save settings while another save is still in progress.\n     */\n    SettingSaveInProgress = 'setting-save-in-progress',\n    /**\n     * An unknown event name was specified in the call to `addEventListener` or `removeEventListener`.\n     */\n    UnsupportedEventName = 'unsupported-event-name',\n    /**\n     * A method was used for a type of data source that doesn't support that method (see getActiveTablesAsync for an example)\n     */\n    UnsupportedMethodForDataSourceType = 'unsupported-method-for-data-source-type',\n  }\n\n  /**\n   * The context in which the Extensions is currently running.\n   */\n  export enum ExtensionContext {\n    Desktop = 'desktop',\n    Server = 'server',\n  }\n\n  /**\n   * The mode in which the Extensions is currently running.\n   */\n  export enum ExtensionMode {\n    Authoring = 'authoring',\n    Viewing = 'viewing',\n  }\n\n  /**\n   * Represents the type of event that can be listened for.\n   */\n  export enum TableauEventType {\n    /** Raised when any filter has changed state. You can use this event type with [Worksheet](../interfaces/worksheet.html) objects.*/\n    FilterChanged = 'filter-changed',\n\n    /** The selected marks on a visualization has changed.\n     * You can use this event type with [Worksheet](../interfaces/worksheet.html) objects. */\n    MarkSelectionChanged = 'mark-selection-changed',\n\n    /** The summary data backing a worksheet has changed\n     * You can use this event type with [Worksheet](../interfaces/worksheet.html) objects.*/\n    SummaryDataChanged = 'summary-data-changed',\n\n    /** A parameter has had its value modified. You can use this event type with [[Parameter]] objects. */\n    ParameterChanged = 'parameter-changed',\n\n    /** Settings have been changed for this extension. You can use this event type with [[Settings]] objects. */\n    SettingsChanged = 'settings-changed',\n\n    /** The dashboard layout has changed\n     * @category Dashboard Extensions\n     */\n    DashboardLayoutChanged = 'dashboard-layout-changed',\n\n    /** The workbook formatting has changed\n     * @category Dashboard Extensions\n     */\n    WorkbookFormattingChanged = 'workbook-formatting-changed',\n  }\n\n  /**\n   * Enum that represents the data type of encodings for createVizImageAsync.\n   * @since 1.6.0\n   */\n  export enum VizImageEncodingType {\n    Discrete = 'discrete',\n    Continuous = 'continuous',\n  }\n\n  /**\n   * Enum that represents the sort direction for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImageSortDirectionType {\n    Ascending = 'ascending',\n    Descending = 'descending',\n  }\n\n  /**\n   * Enum that represents the palette type for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImagePaletteType {\n    CustomDiverging = 'custom-diverging',\n    CustomSequential = 'custom-sequential',\n  }\n\n  /**\n   * Enum that represents the Size Setting type for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImageSizeSettingType {\n    Fixed = 'fixed',\n    Manual = 'manual',\n  }\n\n  /**\n   * Enum that represents the Size Setting alignment type for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImageSizeSettingAlignmentType {\n    Right = 'right',\n    Left = 'left',\n    Center = 'center',\n  }\n}\nexport = Tableau;\n","export enum SharedErrorCodes {\n  /**\n   * A CSV or Excel file failed to be created in Viz.exportCrosstabAsync().\n   */\n  CrosstabCreationError = 'crosstab-creation-error',\n  /**\n   * A CSV file failed to be created in Viz.exportDataAsync().\n   */\n  DataCreationError = 'data-creation-error',\n  /**\n   * An invalid aggregation was specified for the filter, such as setting a range filter to \"SUM(Sales)\" instead of\n   * \"Sales\".\n   */\n  InvalidAggregationFieldName = 'invalid-aggregation-field-name',\n  /**\n   * A filter operation was attempted on a field that does not exist in the data source.\n   */\n  InvalidFilterFieldName = 'invalid-filter-name',\n  /**\n   * A filter operation was attempted using a value that is the wrong data type or format.\n   */\n  InvalidFilterFieldValue = 'invalid-filter-fieldValue',\n  /**\n   * An invalid date value was specified in a Sheet.selectMarksAsync() call for a date field.\n   */\n  InvalidSelectionDate = 'invalid-selection-date',\n  /**\n   * A field was specified in a Sheet.selectMarksAsync() call that does not exist in the data source.\n   */\n  InvalidSelectionFieldName = 'invalid-selection-fieldName',\n  /**\n   * An invalid value was specified in a Sheet.selectMarksAsync() call.\n   */\n  InvalidSelectionValue = 'invalid-selection-value',\n  /**\n   * A parameter did not include a valid sheet selection for exporting.\n   */\n  InvalidSelectionSheet = 'invalid-selection-sheet',\n  /**\n   * An error occurred within the Tableau API. Contact Tableau Support.\n   */\n  InternalError = 'internal-error',\n  /**\n   * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.\n   */\n  InvalidParameter = 'invalid-parameter',\n  /**\n   * A PDF file failed to be created in Viz.exportPDFAsync().\n   */\n  PDFCreationError = 'pdf-creation-error',\n  /**\n   * A PowerPoint file failed to be created in Viz.exportPowerPointAsync().\n   */\n  PowerPointCreationError = 'powerpoint-creation-error',\n  /**\n   * An operation was attempted on a sheet that is not active or embedded within the active dashboard.\n   */\n  NotActiveSheet = 'not-active-sheet',\n  /**\n   * Property or Function is not supported within the Tableau API.\n   */\n  ImplementationError = 'wrong-implementation',\n  /**\n   * Can occur when two incompatible calls are triggered together.\n   */\n  ApiExecutionError = 'api-execution-error',\n  /**\n   * A general-purpose server error occurred. Details are contained in the Error object.\n   */\n  ServerError = 'server-error',\n  /**\n   * Can occur when an api call times out.\n   */\n  Timeout = 'timeout',\n}\n","/**\n * The tableau namespace exists for organization and to avoid polluting\n * the global namespace. It contains no constructs other than sub-namespaces and the Tableau enumerations.\n */\nnamespace Tableau {\n  export enum AnalyticsObjectType {\n    Cluster = 'cluster',\n    Forecast = 'forecast',\n    TrendLine = 'trend-line',\n  }\n\n  export enum AnnotationType {\n    Mark = 'mark',\n    Point = 'point',\n    Area = 'area',\n  }\n\n  export enum ColumnType {\n    Discrete = 'discrete',\n    Continuous = 'continuous',\n  }\n\n  export enum ClassNameKey {\n    WorksheetTitle = 'tableau-worksheet-title',\n    Worksheet = 'tableau-worksheet',\n    Tooltip = 'tableau-tooltip',\n    StoryTitle = 'tableau-story-title',\n    DashboardTitle = 'tableau-dashboard-title',\n  }\n\n  /**\n   * What the object represents in a dashboard.\n   */\n  export enum DashboardObjectType {\n    Blank = 'blank',\n    Worksheet = 'worksheet',\n    QuickFilter = 'quick-filter',\n    ParameterControl = 'parameter-control',\n    PageFilter = 'page-filter',\n    Legend = 'legend',\n    Title = 'title',\n    Text = 'text',\n    Image = 'image',\n    WebPage = 'web-page',\n    Extension = 'extension',\n  }\n\n  /**\n   * Enum that represents the visibility state of a dashboard object.\n   * @since 1.7.0\n   */\n  export enum DashboardObjectVisibilityType {\n    /** Used for turning on the visibility of a dashboard object.*/\n    Show = 'show',\n\n    /** Used for turning off the visibility of a dashboard object.*/\n    Hide = 'hide',\n  }\n\n  /**\n   * The different types of data a value can have\n   */\n  export enum DataType {\n    String = 'string',\n    Int = 'int',\n    Float = 'float',\n    Bool = 'bool',\n    Date = 'date',\n    DateTime = 'date-time',\n    Spatial = 'spatial',\n    Unknown = 'unknown',\n  }\n\n  /**\n   * Enum that represents the changes that occur to a dashboard object.\n   */\n  export enum DashboardLayoutChange {\n    /** A dashboard object was added */\n    Added = 'added',\n\n    /** A dashboard object was removed */\n    Removed = 'removed',\n\n    /** A dashboard object's floating state changed */\n    IsFloatingChanged = 'is-floating-changed',\n\n    /** A dashboard object's visibility changed */\n    IsVisibleChanged = 'is-visible-changed',\n\n    /** A dashboard object's position changed */\n    PositionChanged = 'position-changed',\n\n    /** A dashboard object's size changed */\n    SizeChanged = 'size-changed',\n\n    /** A dashboard object was renamed */\n    NameChanged = 'name-changed',\n\n    /** A dashboard object is selected */\n    Selected = 'selected',\n\n    /** A dashboard object is deselected */\n    Deselected = 'deselected',\n\n    /** Navigate to another dashboard */\n    DashboardChanged = 'dashboard-changed',\n  }\n\n  /**\n   * Valid date ranges for a relative date filter.\n   */\n  export enum DateRangeType {\n    Last = 'last',\n    LastN = 'last-n',\n    Next = 'next',\n    NextN = 'next-n',\n    Current = 'current',\n    ToDate = 'to-date',\n  }\n\n  /**\n   * Enum that represents the types of dialog popup styles.\n   */\n  export enum DialogStyle {\n    Window = 'window',\n    Modal = 'modal',\n    Modeless = 'modeless',\n  }\n\n  export enum EncodingType {\n    Column = 'column',\n    Row = 'row',\n    Page = 'page',\n    Filter = 'filter',\n    MarksType = 'marks-type',\n    MeasureValues = 'measure-values',\n    Color = 'color',\n    Size = 'size',\n    Label = 'label',\n    Detail = 'detail',\n    Tooltip = 'tooltip',\n    Shape = 'shape',\n    Path = 'path',\n    Angle = 'angle',\n    Geometry = 'geometry',\n    Custom = 'custom',\n  }\n\n  /**\n   *  Type of aggregation on a field.\n   */\n  export enum FieldAggregationType {\n    Sum = 'sum',\n    Avg = 'avg',\n    Min = 'min',\n    Max = 'max',\n    Stdev = 'stdev',\n    Stdevp = 'stdevp',\n    Var = 'var',\n    Varp = 'varp',\n    Collect = 'collect',\n    Count = 'count',\n    Countd = 'countd',\n    Median = 'median',\n    Attr = 'attr',\n    None = 'none',\n    Year = 'year',\n    Qtr = 'qtr',\n    Month = 'month',\n    Day = 'day',\n    Hour = 'hour',\n    Minute = 'minute',\n    Second = 'second',\n    Week = 'week',\n    Weekday = 'weekday',\n    MonthYear = 'month-year',\n    Mdy = 'mdy',\n    End = 'end',\n    TruncYear = 'trunc-year',\n    TruncQtr = 'trunc-qtr',\n    TruncMonth = 'trunc-month',\n    TruncWeek = 'trunc-week',\n    TruncDay = 'trunc-day',\n    TruncHour = 'trunc-hour',\n    TruncMinute = 'trunc-minute',\n    TruncSecond = 'trunc-second',\n    Quart1 = 'quart1',\n    Quart3 = 'quart3',\n    Skewness = 'skewness',\n    Kurtosis = 'kurtosis',\n    InOut = 'in-out',\n    User = 'user',\n  }\n\n  /**\n   * Role of a field.\n   */\n  export enum FieldRoleType {\n    Dimension = 'dimension',\n    Measure = 'measure',\n    Unknown = 'unknown',\n  }\n\n  /**\n   * An enumeration of the valid types of filters that can be applied.\n   */\n  export enum FilterType {\n    Categorical = 'categorical',\n    Range = 'range',\n    Hierarchical = 'hierarchical',\n    RelativeDate = 'relative-date',\n  }\n\n  /**\n   * The different update types for applying filter\n   */\n  export enum FilterUpdateType {\n    Add = 'add',\n    All = 'all',\n    Replace = 'replace',\n    Remove = 'remove',\n  }\n\n  /**\n   * The domain type for a filter\n   */\n  export enum FilterDomainType {\n    /**\n     * The domain values that are relevant to the specified filter\n     * i.e. the domain is restricted by a previous filter\n     */\n    Relevant = 'relevant',\n    /**\n     * list of all possible domain values from database\n     */\n    Database = 'database',\n  }\n\n  /**\n   * The option for specifying which values to include for filtering\n   * Indicates what to do with null values for a given filter or mark selection call.\n   */\n  export enum FilterNullOption {\n    NullValues = 'null-values',\n    NonNullValues = 'non-null-values',\n    AllValues = 'all-values',\n  }\n\n  /**\n   * Enum that serves as a filter on the DataValues returned from `getSummaryDataReaderAsync`,\n   * `getUnderlyingTableDataReaderAsync` and `getLogicalTableDataReaderAsync`.\n   * This is an optimization of returned data values only. Tableau versions prior to 2021.2\n   * will pass the data across and populate the DataValue properties.\n   * Please note that all properties not requested will be `undefined` in the DataValue results.\n   * @since 1.5.0\n   */\n  export enum IncludeDataValuesOption {\n    /** DataValues will include all properties.*/\n    AllValues = 'all-values',\n\n    /** DataValues will only include value and nativeValue properties.*/\n    OnlyNativeValues = 'only-native-values',\n\n    /** DataValues will only include formattedValue properties. */\n    OnlyFormattedValues = 'only-formatted-values',\n  }\n\n  /**\n   * Type of mark for a given marks card in a viz.\n   */\n  export enum MarkType {\n    Bar = 'bar',\n    Line = 'line',\n    Area = 'area',\n    Square = 'square',\n    Circle = 'circle',\n    Shape = 'shape',\n    Text = 'text',\n    Map = 'map',\n    Pie = 'pie',\n    GanttBar = 'gantt-bar',\n    Polygon = 'polygon',\n    Heatmap = 'heatmap',\n    VizExtension = 'viz-extension',\n  }\n\n  /**\n   * An enumeration describing the different types of allowable values.\n   * This is used for restricting the domain of a parameter\n   */\n  export enum ParameterValueType {\n    All = 'all',\n    List = 'list',\n    Range = 'range',\n  }\n\n  /**\n   * Date period used in filters and in parameters.\n   */\n  export enum PeriodType {\n    Years = 'years',\n    Quarters = 'quarters',\n    Months = 'months',\n    Weeks = 'weeks',\n    Days = 'days',\n    Hours = 'hours',\n    Minutes = 'minutes',\n    Seconds = 'seconds',\n  }\n\n  export enum QuickTableCalcType {\n    RunningTotal = 'running-total',\n    Difference = 'difference',\n    PercentDifference = 'percent-difference',\n    PercentOfTotal = 'percent-of-total',\n    Rank = 'rank',\n    Percentile = 'percentile',\n    MovingAverage = 'moving-average',\n    YTDTotal = 'ytd-total',\n    CompoundGrowthRate = 'compound-growth-rate',\n    YearOverYearGrowth = 'year-over-year-growth',\n    YTDGrowth = 'ytd-growth',\n    Undefined = 'undefined',\n  }\n\n  /**\n   * Enum for specifying the selection type for select marks api.\n   */\n  export enum SelectionUpdateType {\n    Replace = 'select-replace',\n    Add = 'select-add',\n    Remove = 'select-remove',\n  }\n\n  /**\n   * Enum for specifying the select option for the {@link Worksheet.selectTuplesAsync} method.\n   */\n  export enum SelectOptions {\n    /**\n     * Clears existing selection before selecting the tuples specified\n     */\n    Simple = 'select-options-simple',\n    /**\n     * Adds specified tuples to the existing selection\n     */\n    Toggle = 'select-options-toggle',\n  }\n\n  /**\n   * The type of sheet a [[Sheet]] object represents\n   */\n  export enum SheetType {\n    Dashboard = 'dashboard',\n    Story = 'story',\n    Worksheet = 'worksheet',\n  }\n\n  export enum SortDirection {\n    Increasing = 'increasing',\n    Decreasing = 'decreasing',\n  }\n\n  export enum TrendLineModelType {\n    Linear = 'linear',\n    Logarithmic = 'logarithmic',\n    Exponential = 'exponential',\n    Polynomial = 'polynomial',\n  }\n\n  /**\n   * Enum that represents the replay speed of an animation.\n   * @since 1.7.0\n   */\n  export enum ReplaySpeedType {\n    /** Used for setting the replay speed of an animation to 0.5x.*/\n    Slow = 'slow',\n\n    /** Used for setting the replay speed of an animation to 1.0x.*/\n    Normal = 'normal',\n\n    /** Used for setting the replay speed of an animation to 2.0x.*/\n    Fast = 'fast',\n  }\n\n  /**\n   * Enum that represents the selection state of a level in a hierarchical filter\n   * @since Extensions 1.10.0\n   */\n  export enum HierarchicalLevelSelectionState {\n    AllSelected = 'all-selected',\n    NoneSelected = 'none-selected',\n    SomeSelected = 'some-selected',\n    UnknownSelected = 'unknown-selected',\n  }\n\n  /**\n   * ZoneVisibilityType\n   * @deprecated use DashboardObjectVisibilityType\n   */\n  export declare type ZoneVisibilityType = DashboardObjectVisibilityType;\n  export const ZoneVisibilityType = { ...DashboardObjectVisibilityType };\n}\nexport = Tableau;\n","// This file re-exports everything which is part of the shared api public interface\n\nexport * from './ExternalContract/Shared/AnnotationInterfaces';\nexport * from './ExternalContract/Shared/DataSourceInterfaces';\nexport * from './ExternalContract/Shared/DataTableInterfaces';\nexport * from './ExternalContract/Shared/Enums';\nexport * from './ExternalContract/Shared/EnvironmentInterfaces';\nexport * from './ExternalContract/Shared/FilterInterfaces';\nexport {\n  AnalyticsObjectType,\n  AnnotationType,\n  ClassNameKey,\n  ColumnType,\n  DashboardLayoutChange,\n  DashboardObjectType,\n  DashboardObjectVisibilityType,\n  DataType,\n  DateRangeType,\n  DialogStyle,\n  EncodingType,\n  FieldAggregationType,\n  FieldRoleType,\n  FilterDomainType,\n  FilterNullOption,\n  FilterType,\n  FilterUpdateType,\n  HierarchicalLevelSelectionState,\n  IncludeDataValuesOption,\n  MarkType,\n  ParameterValueType,\n  PeriodType,\n  QuickTableCalcType,\n  ReplaySpeedType,\n  SelectOptions,\n  SelectionUpdateType,\n  SheetType,\n  SortDirection,\n  TrendLineModelType,\n  ZoneVisibilityType,\n} from './ExternalContract/Shared/Namespaces/Tableau';\nexport * from './ExternalContract/Shared/SelectionInterfaces';\nexport * from './ExternalContract/Shared/SheetInterfaces';\nexport * from './ExternalContract/Shared/VisualModelInterface';\nexport * from './ExternalContract/Shared/WorkbookFormattingInterfaces';\n","/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\n\n// The following polyfills are needed for IE11\nimport 'core-js/es/number/is-integer';\nimport 'core-js/es/number/is-nan';\nimport 'core-js/es/object/assign';\n// Export the version of the internal contract to be available at runtime\n//  This file is generated by yarn publish:bump via scripts/publish-check.ts\n//  updateInternalContractRuntimeVersion in the monorepo root.\nimport * as internalContractVersion from '../internal-contract-version.json';\nexport const INTERNAL_CONTRACT_VERSION = internalContractVersion;\n\nexport * from './contract/DataTypeConverter';\nexport * from './contract/Enums';\nexport * from './contract/Models';\nexport * from './contract/Notifications';\nexport * from './contract/Parameters';\nexport * from './contract/Verbs';\nexport * from './interface/AskDataInterface';\nexport * from './interface/InitializationOptions';\nexport * from './interface/InternalApiDispatcher';\nexport * from './interface/PulseInterface';\nexport * from './interface/VersionNumber';\nexport * from './interface/VqlInterface';\nexport * from './messaging/CrossFrameMessenger';\nexport * from './messaging/interface/MessageDispatcher';\nexport * from './messaging/interface/MessageListener';\nexport * from './messaging/interface/MessageTypes';\nexport * from './messaging/interface/Messenger';\nexport * from './messaging/interface/PreparedMessage';\nexport * from './versioning/InternalContractVersionConverter';\nexport * from './versioning/VersionConverterFactory';\nexport * from './versioning/external/ExternalContractVersionConverter';\nexport * from './versioning/external/ExternalIdentityVersionConverter';\nexport * from './versioning/external/ExternalVersionConverterFactory';\n\n// Export the version number of messaging for consumers to use.\n// Be very careful making any updates to this contract which break version compatibility.\nexport const MESSAGING_VERSION = {\n  major: 1,\n  minor: 0,\n  fix: 0,\n};\n","import { DataType } from './Enums';\n\nexport class DataTypeConverter {\n  private static isSpecial(valueAsString: string): boolean {\n    // Prior to ShowDataTablePresModel, special values come to us as\n    // '%null%', '%all%', '%wildcard%', '%missing%'...\n    // While this function will never return true for ShowDataTablePresModel conversion,\n    // it is as cheap as passing around a version and checking that.\n    // (See DataValueFormatter.cpp)\n\n    if (valueAsString.length > 2 && valueAsString[0] === '%' && valueAsString[valueAsString.length - 1] === '%') {\n      return true;\n    }\n    return false;\n  }\n\n  private static specialValueIndicator = '%null%';\n\n  // tslint:disable-next-line:no-any\n  private static parseBoolean(booleanString: string): boolean | string {\n    // boolean values come to us as 'true'|'false'\n    const normalizedBoolean: string = booleanString.toLowerCase();\n    return normalizedBoolean !== 'true' && normalizedBoolean !== 'false' ? this.specialValueIndicator : normalizedBoolean === 'true';\n  }\n\n  // tslint:disable-next-line:no-any\n  private static parseNumber(valueAsString: string): number | string {\n    const value = Number(valueAsString);\n    return isNaN(value) ? this.specialValueIndicator : value;\n  }\n\n  private static parseDate(dateAsString: string): Date | null {\n    // Note that without a time, the date is assumed to be UTC\n    // Input of 2020-03-25 is printed as: Mar 24 2020 17:00:00 GMT-0700\n    // This matches style used in existing convertFilterValuePresModel\n    const value = new Date(dateAsString);\n    return Number.isNaN(value.getTime()) ? null : value;\n  }\n\n  private static parseDateTime(dateAsString: string): Date | null {\n    // With a time, the date is assumed to be UTC.\n    // Our date format is always: yyyy-mm-dd hh:mm:ss\n    // Unfortunately, IE11 can't parse that format so we add a T between the day and time.\n    // We also add a Z so that it is UTC. (Without the Z, some browsers assume local, and others UTC)\n    const formattedDateString: string = dateAsString.replace(' ', 'T').concat('Z');\n    const value = new Date(formattedDateString);\n    return Number.isNaN(value.getTime()) ? null : value;\n  }\n\n  // tslint:disable-next-line:no-any\n  public static convertValueAsStringToValue(valueAsString: string, type: DataType): boolean | number | string | undefined {\n    // This is both DataDictionary and ShowDataTablePresModel compatible.\n    // In the DataDictionary, valueAsString can be '%null%' or '%missing%', while in\n    // ShowDataTablePresModel, we can get 'null' or 'missing', or '%null%' for string special values.\n    // For either of these cases, we return specialValueIndicator (or the original special string).\n    // To maintain backwards compatibilty, this converter:\n    // 1. returns a string for any special values\n    // 2. returns a string for any date\n\n    // Parameter min/max values can be undefined, so result is also undefined\n    if (valueAsString === undefined || valueAsString === null) {\n      return undefined;\n    }\n\n    if (this.isSpecial(valueAsString)) {\n      return valueAsString;\n    }\n\n    switch (type) {\n      case DataType.Bool:\n        return this.parseBoolean(valueAsString);\n\n      case DataType.Int:\n      case DataType.Float:\n        // Return special value '%null%' for any failure in parsing.\n        // We need to do that because ShowDataTablePresModel will give us strings like 'null'\n        // for special values.\n        return this.parseNumber(valueAsString);\n\n      case DataType.Date:\n        // For ShowDataTablePresModel, special values will be \"null\" which will fail to parse.\n        // In that case, we return '%null%'.\n        return this.parseDate(valueAsString) === null ? this.specialValueIndicator : valueAsString;\n\n      case DataType.DateTime:\n        // For ShowDataTablePresModel, special values will be \"null\" which will fail to parse.\n        // In that case, we return '%null%'\n        return this.parseDateTime(valueAsString) === null ? this.specialValueIndicator : valueAsString;\n\n      case DataType.Spatial:\n      case DataType.String:\n      default:\n        return valueAsString;\n    }\n  }\n\n  // tslint:disable-next-line:no-any\n  public static convertValueToNativeValue(value: any, type: DataType): boolean | number | Date | string | null {\n    // This converts from our 1.2 API that returns strings for specials, and dates as strings.\n    // It takes the special case of '%null%' and returns a null.\n    // For dates, it returns a Date object rather than a string.\n    // convertValueToNativeValue should be used to build a DataValue.nativeValue field.\n\n    // Parameter min/max can be undefined. If that is the case, nativeValue is treated like a special\n    if (value === undefined || value === null) {\n      return null;\n    }\n\n    switch (type) {\n      case DataType.Bool:\n        return typeof value === 'string' ? null : value;\n\n      case DataType.Int:\n      case DataType.Float:\n        return typeof value === 'string' ? null : value;\n\n      case DataType.Date:\n        // Convert the string to Date object (or null if parsing fails ... we assume special)\n        return this.parseDate(value);\n\n      case DataType.DateTime:\n        // Convert the string to Date object (or null if parsing fails ... we assume special)\n        return this.parseDateTime(value);\n\n      case DataType.String:\n        return this.isSpecial(value) ? null : value;\n\n      case DataType.Spatial:\n      default:\n        return value;\n    }\n  }\n\n  // tslint:disable-next-line:no-any\n  public static convertStringValueToNativeValue(value: string, type: DataType): boolean | number | Date | string | null {\n    // This handles the conversion from string directly to native value for all types\n    return this.convertValueToNativeValue(this.convertValueAsStringToValue(value, type), type);\n  }\n}\n","export enum ExtensionContext {\n  Desktop = 'desktop',\n  Server = 'server',\n  Unknown = 'unknown',\n}\n\nexport enum ExtensionMode {\n  Authoring = 'authoring',\n  Viewing = 'viewing',\n  Unknown = 'unknown',\n}\n\nexport enum AnnotateEnum {\n  Mark = 'mark',\n  Point = 'point',\n  Area = 'area',\n}\n\nexport enum ColumnType {\n  Discrete = 'discrete',\n  Continuous = 'continuous',\n}\n\nexport enum DashboardObjectType {\n  Blank = 'blank',\n  Worksheet = 'worksheet',\n  QuickFilter = 'quick-filter',\n  ParameterControl = 'parameter-control',\n  PageFilter = 'page-filter',\n  Legend = 'legend',\n  Title = 'title',\n  Text = 'text',\n  Image = 'image',\n  WebPage = 'web-page',\n  Extension = 'extension',\n}\n\nexport enum DataType {\n  String = 'string',\n  Int = 'int',\n  Float = 'float',\n  Bool = 'bool',\n  Date = 'date',\n  DateTime = 'date-time',\n  Spatial = 'spatial',\n  Unknown = 'unknown',\n}\n\nexport enum DialogStyle {\n  Window = 'window',\n  Modal = 'modal',\n  Modeless = 'modeless',\n}\n\nexport enum EncodedDataType {\n  Number = 'number',\n  String = 'string',\n  Date = 'date',\n  Boolean = 'boolean',\n}\n\nexport enum ErrorCodes {\n  INITIALIZATION_ERROR = 'initialization-error',\n  INTERNAL_ERROR = 'internal-error',\n  MISSING_ENUM_MAPPING = 'missing-enum-mapping',\n  MISSING_PARAMETER = 'missing-parameter',\n  PERMISSION_DENIED = 'permission-denied',\n  PRES_MODEL_PARSING_ERROR = 'pres-model-parsing-error',\n  VERSION_NOT_CONFIGURED = 'version-not-configured',\n  VISIBILITY_ERROR = 'visibility-error',\n  UNKNOWN_VERB_ID = 'unknown-verb-id',\n}\n\nexport enum FieldAggregationType {\n  Sum = 'sum',\n  Avg = 'avg',\n  Min = 'min',\n  Max = 'max',\n  Stdev = 'stdev',\n  Stdevp = 'stdevp',\n  Var = 'var',\n  Varp = 'varp',\n  Collect = 'collect',\n  Count = 'count',\n  Countd = 'countd',\n  Median = 'median',\n  Attr = 'attr',\n  None = 'none',\n  Year = 'year',\n  Qtr = 'qtr',\n  Month = 'month',\n  Day = 'day',\n  Hour = 'hour',\n  Minute = 'minute',\n  Second = 'second',\n  Week = 'week',\n  Weekday = 'weekday',\n  MonthYear = 'month-year',\n  Mdy = 'mdy',\n  End = 'end',\n  TruncYear = 'trunc-year',\n  TruncQtr = 'trunc-qtr',\n  TruncMonth = 'trunc-month',\n  TruncWeek = 'trunc-week',\n  TruncDay = 'trunc-day',\n  TruncHour = 'trunc-hour',\n  TruncMinute = 'trunc-minute',\n  TruncSecond = 'trunc-second',\n  Quart1 = 'quart1',\n  Quart3 = 'quart3',\n  Skewness = 'skewness',\n  Kurtosis = 'kurtosis',\n  InOut = 'in-out',\n  User = 'user',\n}\n\nexport enum FieldRoleType {\n  Dimension = 'dimension',\n  Measure = 'measure',\n  Unknown = 'unknown',\n}\n\n/**\n *  The different update types for applying filter.\n */\nexport enum FilterUpdateType {\n  Add = 'add',\n  All = 'all',\n  Replace = 'replace',\n  Remove = 'remove',\n}\n\nexport enum SheetType {\n  Dashboard = 'dashboard',\n  Story = 'story',\n  Worksheet = 'worksheet',\n}\n\nexport enum DomainRestrictionType {\n  All = 'all',\n  List = 'list',\n  Range = 'range',\n}\n\nexport enum DateStepPeriod {\n  Years = 'years',\n  Quarters = 'quarters',\n  Months = 'months',\n  Weeks = 'weeks',\n  Days = 'days',\n  Hours = 'hours',\n  Minutes = 'minutes',\n  Seconds = 'seconds',\n}\n\n/**\n * The option for specifying which values to include for filtering.\n */\nexport enum FilterNullOption {\n  NullValues = 'nullvalues',\n  NonNullValues = 'nonnullvalues',\n  AllValues = 'allvalues',\n}\n\n/**\n * The type of filter domain\n */\nexport enum FilterDomainType {\n  Relevant = 'relevant',\n  Database = 'database',\n}\n\n/**\n * Internal enum for specifying the selection type for select marks api.\n */\nexport enum SelectionUpdateType {\n  Replace = 'select-replace',\n  Add = 'select-add',\n  Remove = 'select-remove',\n}\n\n/**\n * Internal enum for specifying the select option for the select tuples api.\n */\nexport enum SelectOptions {\n  Simple = 'select-options-simple',\n  Toggle = 'select-options-toggle',\n  Menu = 'select-options-menu', // not implemented in the external contract\n  Range = 'select-options-range', // not implemented in the external contract\n  Search = 'select-options-search', // not implemented in the external contract\n}\n\n/**\n * Internal enum for specifying the included values type for range selection.\n */\nexport enum QuantitativeIncludedValues {\n  IncludeNull = 'include-null',\n  IncludeNonNull = 'include-non-null',\n  IncludeAll = 'include-all',\n}\n\n/**\n * Internal enum for specifying a hierarchical level selection state.\n */\nexport enum HierarchicalLevelSelectionState {\n  AllSelected = 'all-selected',\n  NoneSelected = 'none-selected',\n  SomeSelected = 'some-selected',\n  UnknownSelected = 'unknown-selected',\n}\n\n/**\n * Type of mark for a given marks card in a viz.\n */\nexport enum MarkType {\n  Bar = 'bar',\n  Line = 'line',\n  Area = 'area',\n  Square = 'square',\n  Circle = 'circle',\n  Shape = 'shape',\n  Text = 'text',\n  Map = 'map',\n  Pie = 'pie',\n  GanttBar = 'gantt-bar',\n  Polygon = 'polygon',\n  Heatmap = 'heatmap',\n  VizExtension = 'viz-extension',\n}\n\n/**\n * Internal enum for specifying the type of filter\n */\nexport enum FilterType {\n  Categorical = 'categorical',\n  Range = 'range',\n  RelativeDate = 'relativeDate',\n  Hierarchical = 'hierarchical',\n}\n\n/**\n * Internal enum for specifying the DateRangeType of a relative date filter\n */\nexport enum DateRangeType {\n  /**\n   * Refers to the last day, week, month, etc. of the date period.\n   */\n  Last = 'last',\n  /**\n   * Refers to the last N days, weeks, months, etc. of the date period.\n   */\n  LastN = 'lastN',\n  /**\n   * Refers to the next day, week, month, etc. of the date period.\n   */\n  Next = 'next',\n  /**\n   * Refers to the next N days, weeks, months, etc. of the date period.\n   */\n  NextN = 'nextN',\n  /**\n   * Refers to the current day, week, month, etc. of the date period.\n   */\n  Current = 'current',\n  /**\n   * Refers to everything up to and including the current day, week, month, etc. of the date period.\n   */\n  ToDate = 'toDate',\n}\n\n/**\n * Used to determine if the launching of an extension dialog succeeded or failed.\n */\nexport enum ExtensionDialogResult {\n  DialogAlreadyOpen = 'dialog-already-open',\n  InvalidDomain = 'invalid-domain',\n  Success = 'success',\n}\n\n// Enumeration for ApiShowData table id sentinels.\nexport enum ApiShowDataTableSentinel {\n  // find the one logical table - used in version compatibility check for getUnderlyingDataTable and getLogicalDataTable commands\n  SingleTableId = 'single-table-id-sentinel',\n  SingleTableCaption = 'Single table id sentinel',\n}\n\n/**\n * Used to optimize the getSummaryData/getUnderlyingTableData results\n * Mapped from external IncludeDataValuesOption\n */\nexport enum ApiShowDataTableFormat {\n  NativeValuesOnly = 'native-values-only',\n  FormattedValuesOnly = 'formatted-values-only',\n  NativeAndFormattedValues = 'native-and-formatted-values',\n}\n\n/**\n * Used to denote the sections of formatting within tableau\n */\nexport const enum ClassNameKey {\n  WorksheetTitle = 'tableau-worksheet-title',\n  Worksheet = 'tableau-worksheet',\n  Tooltip = 'tableau-tooltip',\n  StoryTitle = 'tableau-story-title',\n  DashboardTitle = 'tableau-dashboard-title',\n}\n\n/**\n * Used to set page size for export layout options.\n */\nexport enum PageSizeOption {\n  Letter = 'letter',\n  Legal = 'legal',\n  Note = 'note',\n  Folio = 'folio',\n  Tabloid = 'tabloid',\n  Ledger = 'ledger',\n  Statement = 'statement',\n  Executive = 'executive',\n  A3 = 'a3',\n  A4 = 'a4',\n  A5 = 'a5',\n  B4 = 'b4',\n  B5 = 'b5',\n  Quarto = 'quarto',\n  Unspecified = 'unspecified',\n}\n\n/**\n * Used to set the page orientation mode for export layout options.\n */\nexport enum PageOrientation {\n  Printer = 'printer',\n  Portrait = 'portrait',\n  Landscape = 'landscape',\n}\n\n/**\n * Used to set scale mode for export layout options.\n */\nexport enum ScaleMode {\n  ScaleAuto = 'auto',\n  ScalePercentage = 'percent',\n  ScaleFitPages = 'fit-pages',\n}\n\n/**\n * Used by setFitAndScaleValues to scale percent values\n */\nexport enum PageScalingOption {\n  ScalePctAuto = 'auto',\n  ScalePct400 = 'pct400',\n  ScalePct200 = 'pct200',\n  ScalePct100 = 'pct100',\n  ScalePct90 = 'pct90',\n  ScalePct80 = 'pct80',\n  ScalePct75 = 'pct75',\n  ScalePct60 = 'pct60',\n  ScalePct50 = 'pct50',\n  ScalePct25 = 'pct25',\n}\n\n/**\n * Used by setFitAndScaleValues to scale fit page values\n */\nexport enum FitPages {\n  FitOneHigh = 'fit0x1',\n  FitTwoHigh = 'fit0x2',\n  FitOneWide = 'fit1x0',\n  FitTwoWide = 'fit2x0',\n}\n\n/**\n * Used by getVisualSpecificationAsync\n */\nexport enum EncodingType {\n  Color = 'color',\n  Size = 'size',\n  Label = 'label',\n  Detail = 'detail',\n  Tooltip = 'tooltip',\n  Shape = 'shape',\n  Path = 'path',\n  Angle = 'angle',\n  Geometry = 'geometry',\n  Custom = 'custom',\n}\n","export enum NotificationId {\n  CustomMarkContextMenuClicked = 'custom-mark-context-menu-clicked',\n  ContextMenuClick = 'context-menu-click',\n  CustomViewRemoved = 'custom-view-removed',\n  CustomViewSaved = 'custom-view-saved',\n  CustomViewSetDefault = 'custom-view-set-default',\n  CustomViewsLoaded = 'custom-views-loaded',\n  DashboardLayoutChanged = 'dashboard-layout-changed',\n  EditButtonClicked = 'edit-button-clicked',\n  EditInDesktopButtonClicked = 'edit-in-desktop-button-clicked',\n  ExtensionDialogUpdate = 'extension-dialog-update',\n  FilterChanged = 'filter-changed',\n  FirstVizSizeKnown = 'first-viz-size-known',\n  ParameterChanged = 'parameter-changed',\n  SelectedMarksChanged = 'selected-marks-changed',\n  SettingsChanged = 'settings-changed',\n  SummaryDataChanged = 'summary-data-changed',\n  TestConversionNotification = 'test-conversion-notification',\n  ToolbarStateChanged = 'toolbar-state-changed',\n  VizInteractive = 'viz-interactive',\n  AskDataInteractive = 'ask-data-interactive',\n  WorkbookReadyToClose = 'workbook-ready-to-close',\n  WorkbookFormattingChanged = 'workbook-formatting-changed',\n  WorkbookPublished = 'workbook-published',\n  WorkbookPublishedAs = 'workbook-published-as',\n  UrlAction = 'url-action',\n  TabSwitched = 'tab-switched',\n  StoryPointSwitched = 'story-point-switched',\n  ReadyToReceiveAuthToken = 'ready-to-receive-auth-token',\n}\n","// PLEASE KEEP IN ALPHABETICAL ORDER. This helps with visually finding entries, knowing where to put\n// new ones, and merge conflicts.\nexport enum ParameterId {\n  ActiveTablesInfo = 'active-tables-info',\n  AnchorDate = 'anchor-date',\n  AnnotateEnum = 'annotate-enum',\n  AnnotationList = 'annotation-list',\n\n  CategoricalDomain = 'categorical-domain',\n  ClickThroughEnabled = 'click-through-enabled',\n  ColumnsToInclude = 'columns-to-include',\n  ColumnsToIncludeById = 'columns-to-include-by-id',\n  ConnectionDescriptionSummaries = 'connection-description-summaries',\n  CurrentSheetType = 'current-sheet-type',\n  CustomView = 'custom-view',\n  CustomViewIsDefault = 'custom-view-is-default',\n  CustomViewIsPublic = 'custom-view-is-public',\n  CustomViewLuid = 'custom-view-luid',\n  CustomViewName = 'custom-view-name',\n  CustomViews = 'custom-views',\n\n  Dashboard = 'dashboard',\n  DashboardFilters = 'dashboard-filters',\n  DashboardName = 'dashboard',\n  DashboardObjectPositionAndSizeUpdate = 'dashboard-object-position-and-size-update',\n  DashboardObjectPositionAndSizeUpdateList = 'dashboard-object-position-and-size-update-list',\n  DataRowIndex = 'data-row-index',\n  DataSchema = 'data-schema',\n  DataSource = 'data-source',\n  DataSourceDataTable = 'data-source-data-table',\n  DataSourceId = 'data-source-id',\n  DataSourceName = 'data-source-name',\n  DataTable = 'data-table',\n  DataTableReader = 'data-table-reader',\n  DateRangeType = 'date-range-type',\n  DeltaTimeMs = 'delta-time-ms',\n  DimValSelectionModels = 'dimensionValueSelectionModels',\n  DomainType = 'domain-type',\n\n  EmbeddingAbstractQuery = 'embedding-abstract-query',\n  EmbeddingBootstrapInfo = 'embedding-bootstrap-info',\n  ExportCrosstabSheetMap = 'export-crosstab-sheet-map',\n  ExportFile = 'export-file',\n  ExportOriginUrl = 'export-origin-url',\n  ExportPdfOptions = 'export-pdf-options',\n  ExtensionBootstrapInfo = 'extension-bootstrap-info',\n  ExtensionContextMenuIds = 'extension-context-menu-ids',\n  ExtensionDialogH = 'extension-dialog-height',\n  ExtensionDialogPayload = 'extension-dialog-payload',\n  ExtensionDialogResult = 'extension-dialog-result',\n  ExtensionDialogStyle = 'extension-dialog-style',\n  ExtensionDialogUrl = 'extension-dialog-url',\n  ExtensionDialogW = 'extension-dialog-width',\n  ExtensionLocator = 'extension-locator',\n  ExtensionSettingsInfo = 'extension-settings-info',\n  ExtensionZoneId = 'extension-zone-id',\n  ExternalMenuDescription = 'external-menu-description',\n  ExternalMenuHeader = 'external-menu-header',\n  ExternalMenuItemDisplayName = 'external-menu-item-display-name',\n  ExternalMenuItemId = 'external-menu-item-id',\n\n  Field = 'field',\n  FieldId = 'field-id',\n  FieldName = 'field-name',\n  FilterLevels = 'filter-levels',\n  FilterRangeMax = 'filter-range-max',\n  FilterRangeMin = 'filter-range-min',\n  FilterRangeNullOption = 'filter-range-null-option',\n  FilterUpdateType = 'filter-update-type',\n  FilterValues = 'filter-values',\n  FontNameListItems = 'font-name-list-items',\n  FormattedText = 'formatted-text',\n  FunctionName = 'function-name',\n\n  HierValSelectionModels = 'hierarchicalValueSelectionModels',\n  HighlightedData = 'highlighted-data',\n  HoverTupleInteraction = 'hover-tuple-interaction',\n\n  IgnoreAliases = 'ignore-aliases',\n  IgnoreSelection = 'ignore-selection',\n  IncludeAllColumns = 'include-all-columns',\n  InvalidAggFieldName = 'invalid-agg-field-name',\n  InvalidDates = 'invalid-dates',\n  InvalidFieldCaption = 'invalid-field-caption',\n  InvalidFields = 'invalid-fields',\n  InvalidValues = 'invalid-values',\n  IsExcludeMode = 'is-exclude',\n  IsExtensionDialog = 'is-extension-dialog',\n\n  JoinDescription = 'join-description',\n\n  LogicalTableId = 'logical-table-id',\n  LogicalTableInfoList = 'logical-table-info-list',\n\n  MaxHeight = 'max-height',\n  MaxRows = 'max-rows',\n  MaxWidth = 'max-width',\n  MinHeight = 'min-height',\n  MinWidth = 'min-width',\n\n  PageRowCount = 'page-row-count',\n  ParameterCaption = 'paremeter-caption',\n  ParameterError = 'parameter-error',\n  ParameterFieldName = 'parameter-field-name',\n  ParameterInfo = 'parameter-info',\n  ParameterInfos = 'parameter-infos',\n  ParameterValue = 'parameter-value',\n  PeriodType = 'period-type',\n\n  QuantitativeDomain = 'quantitative-dmain',\n  QuantRangeSelectionModels = 'quantativeRangeSelectionModels',\n\n  RangeN = 'range-n',\n  ReplaySpeed = 'replay-speed',\n\n  SelectedData = 'selected-data',\n  SelectedSheetNames = 'selected-sheet-names',\n  Selection = 'selection',\n  SelectionList = 'selection-list',\n  SelectionUpdateType = 'selectionUpdateType',\n  SelectTuplesInteraction = 'select-tuples-interaction',\n  SendNotifications = 'send-notifications',\n  SettingsValues = 'settings-values',\n  SharedFilterSheets = 'shared-filter-sheets',\n  SharedFiltersInfo = 'shared-filters-info',\n  SheetIdentifier = 'sheet-identifier',\n  SheetName = 'sheet-name',\n  SheetPath = 'sheet-path',\n  ShouldRefreshDS = 'should-refresh-ds',\n  ShowDataTableFormat = 'show-data-table-format',\n  State = 'state',\n  StoryPointIndex = 'story-point-index',\n  StoryPointInfo = 'story-point-info',\n  SwitchToSheetName = 'switch-to-sheet-name',\n\n  TargetPoint = 'target-point',\n  TestConversionParameter = 'test-conversion-parameter',\n  Text = 'formatted-text',\n  TooltipContext = 'tooltip-context',\n\n  UnderlyingDataTable = 'underlying-data-table',\n  UnderlyingSummaryDataTable = 'underlying-summary-data-table',\n  Url = 'url',\n  UseTabDelimiters = 'use-tab-delimiters',\n\n  ViewDataTableCacheId = 'view-data-table-cache-id',\n  ViewDataTableId = 'view-data-table-id',\n  VisualId = 'visual-id',\n  VisualSpecification = 'visual-specification',\n  VizAPIInputJson = 'vizapi-input-json',\n  VizAPIStateWithDataModel = 'vizapi-state-with-data-model',\n  VizAPIStateWarningMsg = 'vizapi-state-warning-msg',\n  VizAPISVG = 'vizapi-svg',\n\n  WorksheetName = 'worksheet-name',\n  WorksheetFilters = 'worksheet-filters',\n\n  ZoneIdsVisibilityMap = 'zone-ids-visibility-map',\n}\n","// Declare this key type and export the NotificationId to make this behave like a string enum.\n//\n// PLEASE KEEP IN ALPHABETICAL ORDER. This helps with visually finding entries, knowing where to put\n// new ones, and merge conflicts.\nexport enum VerbId {\n  ActivateNextStoryPoint = 'activate-next-story-point',\n  ActivatePreviousStoryPoint = 'activate-previous-story-point',\n  ActivateSheet = 'activateSheet',\n  ActivateStoryPoint = 'activate-story-point',\n  AppendExternalMenuItem = 'append-external-menu-item',\n  ApplyCategoricalFilter = 'categorical-filter',\n  ApplyRangeFilter = 'range-filter',\n  ApplyRelativeDateFilter = 'apply-relative-date-Filter',\n  Authenticate = 'authenticate',\n\n  BlockExtension = 'block-extension',\n\n  ChangeParameterValue = 'change-parameter-value',\n  ChangeSharedFilter = 'change-shared-filter',\n  ClearFilter = 'clear-filter',\n  ClearSelectedMarks = 'clear-selected-marks',\n  CloseDialog = 'close-dialog',\n  CreateAnnotation = 'create-annotation',\n\n  DashboardCategoricalFilter = 'dashboard-categorical-filter',\n  DisplayDialog = 'display-dialog',\n  DownloadWorkbook = 'download-workbook',\n\n  ExecuteExternalMenuItem = 'execute-external-menu-item',\n  ExportCrosstab = 'export-crosstab',\n  ExportCrosstabCsvDownload = 'export-crosstab-csv-download',\n  ExportCrosstabExcelDownload = 'export-crosstab-excel-download',\n  ExportData = 'export-data',\n  ExportDataDownload = 'export-data-download',\n  ExportImage = 'export-image',\n  ExportPdf = 'export-pdf',\n  ExportPdfDownload = 'export-pdf-download',\n  ExportPowerpoint = 'export-powerpoint',\n  ExportPowerpointDownload = 'export-powerpoint-download',\n\n  FindParameter = 'find-parameter',\n\n  GetActiveTables = 'get-active-tables',\n  GetAllDataSources = 'get-all-data-sources',\n  GetAnnotations = 'get-annotations',\n  GetCategoricalDomain = 'get-categorical-domain',\n  GetConnectionDescriptionSummaries = 'get-connection-description-summaries',\n  GetCurrentSrc = 'get-current-src',\n  GetCustomViews = 'get-custom-views',\n  GetDashboardFilters = 'get-dashboard-filters',\n  GetDataSource = 'get-datasource',\n  GetDataSourceData = 'get-datasource-data',\n  GetDataSources = 'get-data-sources',\n  GetDataSummaryData = 'get-summary-data',\n  GetDataSummaryDataReader = 'get-summary-data-reader',\n  GetDataTableReaderPage = 'get-data-table-reader-page',\n  GetEmbeddingAbstractQueryWithDataModel = 'get-embedding-abstract-query-with-data-model',\n  GetEmbeddingClientInfo = 'get-embedding-client-info',\n  GetVizStateWithDataModel = 'get-viz-state-with-data-model',\n  GetExportCrosstabSheetMap = 'get-export-crosstab-sheet-map',\n  GetExportPdfOptions = 'get-export-pdf-options',\n  GetField = 'get-field',\n  GetFieldAndDataSource = 'get-field-and-datasource',\n  GetVisualSpecification = 'get-visual-specification',\n  GetFilters = 'get-filters',\n  GetFonts = 'get-fonts',\n  GetHighlightedMarks = 'get-highlighted-marks',\n  GetJoinDescription = 'get-join-description',\n  GetLogicalTableData = 'get-logical-table-data',\n  GetLogicalTableDataReader = 'get-logical-table-data-reader',\n  GetLogicalTables = 'get-logical-tables',\n  GetParametersForSheet = 'get-parameters-for-sheet',\n  GetRangeDomain = 'get-range-domain',\n  GetSelectedMarks = 'get-selected-marks',\n  GetSharedFilter = 'get-shared-filter',\n  GetUnderlyingData = 'get-underlying-data',\n  GetUnderlyingTableData = 'get-underlying-table-data',\n  GetUnderlyingTableDataReader = 'get-underlying-table-data-reader',\n  GetUnderlyingTables = 'get-underlying-tables',\n\n  HierarchicalFilter = 'hierachical-filter',\n\n  InitializeExtension = 'initialize-extension',\n\n  MoveAndResizeZones = 'move-and-resize-zones',\n\n  RaiseHoverTupleNotification = 'raise-hover-tuple-notification',\n  RaiseSelectTuplesNotification = 'raise-select-tuples-notification',\n  Redo = 'redo',\n  RefreshDataSource = 'refresh-data-source',\n  ReleaseDataTableReader = 'release-data-table-reader',\n  RemoveAnnotation = 'remove-annotation',\n  RemoveCustomView = 'remove-custom-view',\n  RemoveExternalMenuItem = 'remove-external-menu-item',\n  RenameExternalMenu = 'rename-external-menu',\n  ReplayAnimation = 'replay-animation',\n  RevertStoryPoint = 'revert-story-point',\n  RevertWorkbook = 'revert-workbook',\n\n  SaveExtensionSettings = 'save-extension-settings',\n  SaveWorkbookAsCustomView = 'save-workbook-as-custom-view',\n  SelectByValue = 'select-by-value',\n  SetActiveCustomViewAsDefault = 'set-active-custom-view-as-default',\n  SetAutoUpdate = 'set-auto-update',\n  SetClickThrough = 'set-click-through',\n  SetVizStateWithDataModel = 'set-viz-state-with-data-model',\n  SetSheetSize = 'set-sheet-size',\n  SetZoneVisibility = 'set-zone-visibility',\n  Share = 'share',\n  ShowCustomView = 'show-custom-view',\n\n  TestConversionVerb = 'test-conversion-verb',\n\n  Undo = 'undo',\n  UpdateCustomView = 'update-custom-view',\n\n  VizAPI = 'viz-api',\n}\n","export enum AskDataOptionNames {\n  token = 'token',\n  origin = 'origin',\n  showEmbed = 'showEmbed',\n  showPin = 'showPin',\n  showSave = 'showSave',\n  showShare = 'showShare',\n  debug = ':jsdebug',\n  ApiID = ':apiID',\n  ApiExternalVersion = ':apiExternalVersion',\n  ApiInternalVersion = ':apiInternalVersion',\n  AskDataWebComponent = ':askDataWebComponent',\n}\n","export enum PulseOptionNames {\n  embed = 'embed',\n  token = 'token',\n  disableExploreFilter = 'disableExploreFilter',\n  ApiExternalVersion = ':apiExternalVersion',\n  ApiInternalVersion = ':apiInternalVersion',\n  PulseWebComponent = ':pulseWebComponent',\n}\n","/**\n * These strings were *manually copied* from the server,\n * workgroup/src/silos/tableau-server/libraries/tab-controller-vizql/src/com/tableausoftware/\n * controller/vizql/constants/ParameterKeys.java#L9\n * should be exported instead\n * parameters that vizql will accept in an embedding URL\n **/\nenum VqlParameterNames {\n  ONE = '1',\n  ALERTS = ':alerts',\n  ALIAS = 'alias',\n  ALLOW_DEFERRED_BOOTSTRAP = ':allowDeferredBootstrap',\n  ALLOW_AUTOGEN_WORKSHEET_PHONE_LAYOUTS = 'allowAutogenWorksheetPhoneLayouts',\n  API_ID = ':apiID',\n  APP = ':app',\n  ATTACHMENT = 'attachment',\n  IS_IPAD_APP = 'app',\n  ANIMATE_TRANSITION = ':animate_transition',\n  ASCENDING = 'ascending',\n  AUTHENTICATION = 'authentication',\n  ATTRIBUTES = 'attributes',\n  AUTHORING_SHEET = ':authSheet',\n  AXIS = 'axis',\n  BOOTSTRAP_WHEN_NOTIFIED = ':bootstrapWhenNotified',\n  BROWSER_BACK_BUTTON_UNDO = ':browserBackButtonUndo',\n  BROWSER_RENDERING_ON = 'isBrowserRendering',\n  BROWSER_RENDERING_THRESHOLD = 'browserRenderingThreshold',\n  CHARSET = 'charset',\n  CLIENT_DIMENSION = 'clientDimension',\n  CLIENT_IP = 'client_ip',\n  CLIENT_NUM = 'clientNum',\n  COLON_EMBEDDED = ':embedded',\n  COLON_MOBILE = ':mobile',\n  COLON_DEEP_LINKING_DISABLED = ':deepLinkingDisabled',\n  COLON_WATERMARK = ':watermark',\n  COMMENTS = ':comments',\n  COMMENTING_ENABLED = ':commentingEnabled',\n  COMMENTING_MENTIONS_ENABLED = ':commentingMentions',\n  CONNECTION = 'connection',\n  CREATED_BY_FEATURE = 'createdByFeature',\n  CRYPTED_PASSWORD = 'crypted',\n  CSSDEBUG = ':cssdebug',\n  CSV = 'csv',\n  CUSTOM_VIEWS = ':customViews',\n  CV = ':cv',\n  CV_ID = 'cvId',\n  DASHBOARD_PORT_SIZE = 'dashboardPortSize',\n  DATA_DETAILS = ':dataDetails',\n  DATASOURCE = 'datasource',\n  DEBUG = ':debug',\n  DELAY = ':delay',\n  DEPTH = 'depth',\n  DEVICE_TYPE = ':device',\n  DEVICE_PIXEL_RATIO = 'devicePixelRatio',\n  DEVICE_PREVIEW_MODE = ':devicepreviewmode',\n  DIMENSIONS = ':dimensions',\n  DISABLE_SHARED_SESSIONS = ':disable_shared_sessions',\n  DISABLE_URL_ACTIONS_POPUPS = ':disableUrlActionsPopups',\n  DIRECTION = 'direction',\n  DISPLAY_OVERLAY = ':display_overlay',\n  DISPLAY_SHARE = ':display_share',\n  DISPLAY_SPINNER = ':display_spinner',\n  DISPLAY_STATIC_IMAGE = ':display_static_image',\n  DISPLAY_TABS = 'display_tabs',\n  DISPLAY_VIEW_COUNT = ':display_count',\n  IGNORE_STICKY_SESSION = ':ignore_sticky_session',\n  INCREMENT_VIEW_COUNT = ':increment_view_count',\n  DOCMODE = 'docmode',\n  DOMAIN = 'domain',\n  DO_WORK = 'do_work',\n  DX = 'dx',\n  DY = 'dy',\n  EDIT_DATA_ALERT = ':editDataAlert',\n  EMBED = ':embed',\n  EMBEDDED = 'embedded',\n  ENCRYPTED = 'encrypted',\n  API_EXTERNAL_VERSION = ':apiExternalVersion',\n  API_INTERNAL_VERSION = ':apiInternalVersion',\n  EXCLUDE = 'exclude',\n  EXPORT_FORMAT = ':export_format',\n  FIELDNAME = 'fieldname',\n  FIELD_NAME = 'field_name',\n  FIELD_SEP = 'field_sep',\n  FILE = 'file',\n  FILTER_TILE_SIZE = 'filterTileSize',\n  FN = 'fn',\n  FOCUS = 'focus',\n  FORCE_CACHE = 'force_cache',\n  FORMAT = 'format',\n  FORMAT_DATA_VALUE_LOCALLY = 'formatDataValueLocally',\n  FROM_WG = ':from_wg',\n  GRAPHQL_DATABASE_ID = ':graphQLDatabaseId',\n  GRAPHQL_TABLE_ID = ':graphQLTableId',\n  GUID = ':guid',\n  H = 'h',\n  HIDDEN = 'hidden',\n  HIDE_CLOSE_BUTTON = ':hideCloseButton',\n  HIDE_EDIT_BUTTON = ':hideEditButton',\n  HIDE_EDIT_IN_DESKTOP_BUTTON = ':hideEditInDesktopButton',\n  HIGH_DPI = ':highdpi',\n  IMAGE_SIZE_LIMIT = 'imageSizeLimit',\n  TRANSPARENT_LINE_MARKS_LIMIT = 'transparentLineMarkLimit',\n  CLIENT_RENDER_PIXEL_LIMIT = 'clientRenderPixelLimit',\n  IN = 'in',\n  INSTANCE_ID = ':iid',\n  IS_GUEST_REDIRECT_FROM_VIZPORTAL = ':isGuestRedirectFromVizportal',\n  IS_MARK_ANIMATION_ENABLED = 'isMarkAnimationEnabled',\n  IS_VIZPORTAL = ':isVizPortal',\n  INPUT_ = 'input_string',\n  JSDEBUG = ':jsdebug',\n  JSON = 'json',\n  JSON_ONLY = ':jsonOnly',\n  KEEPFILE = 'keepfile',\n  KEY = 'key',\n  LANGUAGE = 'language',\n  LANGUAGE_REQUESTED = ':language',\n  LINKTARGET = ':linktarget',\n  LOAD_ORDER_ID = ':loadOrderID', // used for Public\n  LOAD_NEWEST_REVISION = ':loadNewestRevision',\n  LOCAL_PATHS = ':localPaths',\n  LOCALE = 'locale',\n  LOCATION_ID = 'locationid',\n  LOCATION_TYPE = 'locationtype',\n  WORKBOOK_LOCALE = 'workbookLocale',\n  MAXROWS = 'maxrows',\n  MAX_AGE = 'maxAge',\n  MAX_ROWS = 'maxRows',\n  METHOD = 'method',\n  MOBILE = 'mobile',\n  MODIFIER = 'modifier',\n  NAME = 'name',\n  NAV_TYPE = 'navType',\n  NAV_SRC = 'navSrc',\n  NOATTACHMENT = 'no-attachment',\n  NO_OVERWRITE = 'no_overwrite',\n  OPEN_AUTHORING_IN_TOP_WINDOW = ':openAuthoringInTopWindow',\n  OPENID_HD = ':openid_hd',\n  OPENID_LOGIN_HINT = ':openid_login_hint',\n  OAUTHREQUEST = 'oauthrequest',\n  OAUTH_CREDENTIAL_IDS = 'oauth_credential_ids',\n  OFFLINE_MODE = ':offlinemode',\n  ORIGIN = ':origin',\n  OVERLAY = ':overlay',\n  P = 'p',\n  PATH = 'path',\n  PANE_RESOLVER_X = 'paneResolverX',\n  PANE_RESOLVER_Y = 'paneResolverY',\n  PARAM = 'param',\n  PARENT_ID = 'parent_id',\n  PASSWORD = 'password',\n  PATTERN = 'pattern',\n  PIXEL_RATIO = ':pixelratio',\n  PREFIX = ':prefix',\n  PREVIEW = ':preview',\n  PRIMARY_CONTENT_URL = 'primary_content_url',\n  PROJECT = 'project',\n  PROTOCOL = 'protocol',\n  PSEUDO = ':pseudo',\n  QUERY = 'query',\n  R = 'r',\n  RANGE_TYPE = 'range_type',\n  RECORD_SEP = 'record_sep',\n  RECORD_CLIENT_PERFORMANCE = ':record_client_performance',\n  RECORD_PERFORMANCE = ':record_performance',\n  RECOVER_OLD_SESSION_ID = ':recover_old_session_id',\n  RECOVER_SESSION_STATE_TICKETS = ':recover_session_state_tickets',\n  REFRESH = ':refresh',\n  REFRESHUNMODIFIED = ':refreshunmodified',\n  REGION = 'region',\n  RELOAD_ON_CUSTOM_VIEW_SAVE = ':reloadOnCustomViewSave',\n  RENDER = ':render',\n  RENDER_MAPS_CLIENT_SIDE = 'renderMapsClientSide',\n  RETRY = ':retry',\n  REUSE = 'reuse',\n  REUSE_FOREVER = 'reuse_forever',\n  REVERT = ':revert',\n  SAVE_DB_PASSWORDS = 'save_db_passwords',\n  SELECT_X = 'select_x',\n  SELECT_Y = 'select_y',\n  SESSION_FEATURE_PREFIX = ':ff_',\n  SESSION_FLAGS = ':session_feature_flags',\n  SHARE_BUTTON = 'share_button',\n  SHEET_ID = 'sheet_id',\n  SHARED = 'shared',\n  SHOWALL = 'showall',\n  SHOW_APP_BANNER = ':showAppBanner',\n  SHOW_ASK_DATA = ':showAskData',\n  SHOW_PARAMS = 'showParams',\n  SHOW_SHARE_OPTIONS = ':showShareOptions',\n  SIZE = ':size',\n  SOURCE = 'source',\n  STATE = 'state',\n  STICKY_SESSION_KEY = 'stickySessionKey',\n  SUBSCRIPTIONS = ':subscriptions',\n  SUMMARY = 'summary',\n  SUPPRESS_DEFAULT_EDIT_BEHAVIOR = ':suppressDefaultEditBehavior',\n  SYNC_SESSION = ':sync_session',\n  SYNC_SESSION_STATE = 'sync_session_state',\n  TABS = ':tabs',\n  TARGET = 'target',\n  TARGET_SITE = 'target_site',\n  TOOLBAR = ':toolbar',\n  TOOLTIP = ':tooltip',\n  TS = 'ts',\n  UNDERLYING_TABLE_ID = 'underlying_table_id',\n  UNDERLYING_TABLE_CAPTION = 'underlying_table_caption',\n  UPDATE_TYPE = 'update_type',\n  USE_GUEST = ':useGuest',\n  USE_INLINE_IMAGES = 'use_inline_images',\n  USERAGENT = 'useragent',\n  USERNAME = 'username',\n  VALUE = 'value',\n  VERBOSE_MODE = 'verboseMode',\n  VIEW_ID = 'views_id',\n  VIZ_SNAPSHOT_ID = 'viz_snapshot_id',\n  VW = ':vw',\n  W = 'w',\n  WORKSHEET_PORT_SIZE = 'worksheetPortSize',\n  WATERMARK = 'watermark',\n  WATERMARK_MARGIN = ':watermark_margin',\n  WB = ':wb',\n  WHICH = 'which',\n  X = 'x',\n  Y = 'y',\n  ZID = 'zid',\n  ZONE_ID = 'zone_id',\n  KEYCHAIN_VERSION = 'keychain_version',\n  DATASOURCE_ID = 'datasource_id',\n  DATASOURCE_NAME = 'datasource_name',\n  LENS_ID = 'lens_id',\n  WIDTH = 'width',\n  HEIGHT = 'height',\n\n  // Default Layout params\n  LAYOUT_VIEWS = 'views',\n  LAYOUT_MENUS = 'menus',\n  LAYOUT_GEOMETRY = 'geometry',\n  LAYOUT_PAGES = 'pages',\n  LAYOUT_CACHEURL = 'cacheurl',\n  LAYOUT_SHEET = 'sheet',\n  LAYOUT_DEPTH = 'depth',\n}\n\n/**\n * parameters that are only relevant when working with Tableau Public\n * maybe not really necessry to split them out\n */\nenum PublicParameterNames {\n  SHOW_VIZ_HOME = ':showVizHome',\n  // display view count\n}\n\n/**\n * Map the parameter names as used in the url to what we call them publicly in the embedding library.\n * The only parameters listed here should be the ones that get sent to vizql\n *  - this should match the interface at external-contract:VizInterfaces:VizSettings\n */\nexport enum VizOptionNames {\n  // publicName = internalStringValue\n  Size = VqlParameterNames.SIZE,\n  Embed = VqlParameterNames.EMBED,\n  ApiInternalVersion = VqlParameterNames.API_INTERNAL_VERSION,\n  ApiExternalVersion = VqlParameterNames.API_EXTERNAL_VERSION,\n  ShowVizHome = PublicParameterNames.SHOW_VIZ_HOME,\n  Jsdebug = VqlParameterNames.JSDEBUG,\n  BootstrapWhenNotified = VqlParameterNames.BOOTSTRAP_WHEN_NOTIFIED,\n  NavType = VqlParameterNames.NAV_TYPE,\n  NavSrc = VqlParameterNames.NAV_SRC,\n  debug = VqlParameterNames.JSDEBUG,\n  ApiID = VqlParameterNames.API_ID,\n\n  disableUrlActionsPopups = VqlParameterNames.DISABLE_URL_ACTIONS_POPUPS,\n  hideTabs = VqlParameterNames.TABS,\n  toolbar = VqlParameterNames.TOOLBAR,\n  device = VqlParameterNames.DEVICE_TYPE,\n  instanceIdToClone = VqlParameterNames.INSTANCE_ID,\n  touchOptimize = VqlParameterNames.MOBILE,\n  hideEditButton = VqlParameterNames.HIDE_EDIT_BUTTON,\n  hideEditInDesktopButton = VqlParameterNames.HIDE_EDIT_IN_DESKTOP_BUTTON,\n  suppressDefaultEditBehavior = VqlParameterNames.SUPPRESS_DEFAULT_EDIT_BEHAVIOR,\n  hideCloseButton = VqlParameterNames.HIDE_CLOSE_BUTTON,\n}\n","import * as guid from 'guid';\nimport { ExecuteParameters, INTERNAL_CONTRACT_VERSION, Model, NotificationId, VerbId, VersionNumber } from '../JsApiInternalContract';\nimport { InitializationOptions } from '../interface/InitializationOptions';\nimport { CrossFramePreparedMessage } from './CrossFramePreparedMessage';\nimport {\n  isCommandMessage,\n  isCommandResponseMessage,\n  isHandshakeMessage,\n  isInitMessage,\n  isMessage,\n  isNotificationMessage,\n} from './MessageTypeChecks';\nimport {\n  CommandMessageHandler,\n  CommandResponseMessageHandler,\n  HandshakeMessageHandler,\n  InitializeMessageHandler,\n  NotificationMessageHandler,\n} from './interface/MessageListener';\nimport {\n  CommandMessage,\n  CommandResponseMessage,\n  HandshakeMessage,\n  InitializeMessage,\n  Message,\n  MessageType,\n  NotificationMessage,\n} from './interface/MessageTypes';\nimport { Messenger } from './interface/Messenger';\nimport { PreparedMessage } from './interface/PreparedMessage';\n\n/**\n * The CrossFrameMessenger is the primary export from the api-messaging module. An instance of\n * this class can be instantiated on both sides of a frame boundary to facilitate communication\n * in both directions between the frames. This class implements both the dispatcher and the listener\n * portions, but doesn't require callers to care about both.\n */\nexport class CrossFrameMessenger implements Messenger {\n  private unregisterFunction?: () => void;\n  private initializeMessageHandler?: InitializeMessageHandler;\n  private commandResponseMessageHandler?: CommandResponseMessageHandler;\n  private commandMessageHandler?: CommandMessageHandler;\n  private notificationMessageHandler?: NotificationMessageHandler;\n  private handshakeMessageHandler?: HandshakeMessageHandler;\n\n  /**\n   * Creates an instance of CrossFrameMessenger. If you would like to use the CrossFrameMessenger as a MessageListener,\n   * be sure to call StartListening and register message handlers.\n   * @param thisWindow The window object which the CrossFrameMessenger lives. An onMessage listener will be added here.\n   * @param [otherWindow] Optional otherWindow which messages will be posted to.\n   *                      If defined, incoming messages must originate from otherWindow to be passed on\n   * @param [otherWindowOrigin] The target origin which otherWindow must have in order to receive dispatched messages.\n   *                            This value will be sent as the targetOrigin of a postMessage\n   *                            (https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage)\n   */\n  public constructor(private thisWindow: Window, private otherWindow?: Window, private otherWindowOrigin?: string) {\n    // Make sure to call StartListening\n  }\n\n  ///// MessageListener Implementation\n\n  public startListening(): void {\n    // Check if we already are listening, if not, hook up a message listener\n    if (!this.unregisterFunction) {\n      const boundHandler = this.onMessageReceived.bind(this);\n      this.thisWindow.addEventListener('message', boundHandler, true);\n      this.unregisterFunction = () => this.thisWindow.removeEventListener('message', boundHandler, true);\n    }\n  }\n\n  public stopListening(): void {\n    // Stop listening if we have started listening\n    if (this.unregisterFunction) {\n      this.unregisterFunction();\n      this.unregisterFunction = undefined;\n    }\n  }\n\n  public setInitializeMessageHandler(handler?: InitializeMessageHandler): void {\n    this.initializeMessageHandler = handler;\n  }\n\n  public setCommandResponseMessageHandler(handler?: CommandResponseMessageHandler): void {\n    this.commandResponseMessageHandler = handler;\n  }\n\n  public setCommandMessageHandler(handler?: CommandMessageHandler): void {\n    this.commandMessageHandler = handler;\n  }\n\n  public setNotificationMessageHandler(handler?: NotificationMessageHandler): void {\n    this.notificationMessageHandler = handler;\n  }\n\n  public setHandshakeMessageHandler(handler?: HandshakeMessageHandler): void {\n    this.handshakeMessageHandler = handler;\n  }\n\n  ///// MessageDispatcher Implementation\n\n  /**\n   * @param apiVersion api-internal-contract-js version (exported in JsApiInternalConntract)\n   * @param crossFrameVersion crossframe messaging version (exported in JsApiInternalConntract)\n   * @param options additional options that can be passed at initialization (information about the version of\n   *                external being used for example)\n   */\n  public prepareInitializationMessage(\n    apiVersion: VersionNumber,\n    crossFrameVersion: VersionNumber,\n    options?: InitializationOptions,\n  ): PreparedMessage {\n    const message: InitializeMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Initialize,\n      crossFrameVersion: crossFrameVersion,\n      apiVersion: apiVersion,\n      options: options,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareCommandMessage(verbId: VerbId, parameters: ExecuteParameters): PreparedMessage {\n    const message: CommandMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Command,\n      verbId: verbId,\n      parameters: parameters,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareCommandResponseMessage(commandGuid: string, data: Model | undefined, error: Model | undefined): PreparedMessage {\n    const message: CommandResponseMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.CommandResponse,\n      commandGuid: commandGuid,\n      data: data,\n      error: error,\n    };\n\n    if (error) {\n      // stringify error object to remove unserializable fields like functions and prevent serialization errors\n      message.error = JSON.parse(JSON.stringify(error));\n    }\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareNotificationMessage(notificationId: NotificationId, data: Model): PreparedMessage {\n    const message: NotificationMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Notification,\n      notificationId: notificationId,\n      data: data,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareAckMessage(): PreparedMessage {\n    const message: HandshakeMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Ack,\n      platformVersion: INTERNAL_CONTRACT_VERSION,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  /**\n   * Prepares a pending message for sending and returns the prepared message\n   *\n   * @param msg The message to be sent to this.otherWindow\n   * @returns The prepared message\n   */\n  private prepareMessage(msg: Message): PreparedMessage {\n    if (!this.otherWindow || !this.otherWindowOrigin) {\n      throw 'Other window not initialized, cannot dispatch messages';\n    }\n\n    const preparedMessage = new CrossFramePreparedMessage(msg, this.otherWindow, this.otherWindowOrigin);\n    return preparedMessage;\n  }\n\n  /**\n   * Called when a message is received. Does some validation of the message, and then\n   * calls an appropriate message handler if one is defined\n   *\n   * @param event The incoming MessageEvent\n   */\n  private onMessageReceived(event: MessageEvent): void {\n    // If we have an otherWindow defined, make sure the message is coming from there\n    if (this.otherWindow && event.source !== this.otherWindow) {\n      return;\n    }\n\n    // Do some validation on event.data to make sure that we have received a real message\n    if (!event.data) {\n      return;\n    }\n\n    const message = event.data;\n    if (!isMessage(message)) {\n      return;\n    }\n\n    // Check the declared message type, validate the message, and call an appropriate hander if one exists\n    switch (message.msgType) {\n      case MessageType.Initialize: {\n        if (!isInitMessage(message) || !this.initializeMessageHandler) {\n          return;\n        }\n\n        this.initializeMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.CommandResponse: {\n        if (!isCommandResponseMessage(message) || !this.commandResponseMessageHandler) {\n          return;\n        }\n\n        this.commandResponseMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.Command: {\n        if (!isCommandMessage(message) || !this.commandMessageHandler) {\n          return;\n        }\n\n        this.commandMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.Notification: {\n        if (!isNotificationMessage(message) || !this.notificationMessageHandler) {\n          return;\n        }\n\n        this.notificationMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.Handshake: {\n        if (!isHandshakeMessage(message) || !this.handshakeMessageHandler) {\n          return;\n        }\n\n        this.handshakeMessageHandler(message, event.source);\n        break;\n      }\n      default:\n      // Just ignore this since we don't know how to handle the message type\n    }\n  }\n\n  public setOtherWindow(otherWindow: Window): void {\n    this.otherWindow = otherWindow;\n  }\n\n  public setOtherWindowOrigin(origin: string): void {\n    this.otherWindowOrigin = origin;\n  }\n}\n","import { Message } from './interface/MessageTypes';\nimport { PreparedMessage } from './interface/PreparedMessage';\n\n/**\n * Implementation of the PreparedMessage interface used to post messages between\n * two frames using window.postMessage\n */\nexport class CrossFramePreparedMessage implements PreparedMessage {\n  /**\n   * Creates an instance of CrossFramePreparedMessage.\n   * @param _message The message to be sent\n   * @param _target The target window where the message will be sent\n   * @param _origin The targetOrigin where this message can be received\n   */\n  public constructor(private _message: Message, private _target: Window, private _origin: string) {}\n\n  public get messageGuid(): string {\n    return this._message.msgGuid;\n  }\n\n  public send(): PreparedMessage {\n    this._target.postMessage(this._message, this._origin);\n    return this;\n  }\n}\n","import * as guid from 'guid';\nimport { NotificationId } from '../contract/Notifications';\nimport { VersionNumber } from '../interface/VersionNumber';\nimport {\n  CommandMessage,\n  CommandResponseMessage,\n  HandshakeMessage,\n  InitializeMessage,\n  Message,\n  MessageType,\n  NotificationMessage,\n} from './interface/MessageTypes';\n\nconst expectedEmptyNotifications = new Set([\n  NotificationId.EditButtonClicked,\n  NotificationId.EditInDesktopButtonClicked,\n  NotificationId.WorkbookPublished,\n  NotificationId.WorkbookReadyToClose,\n  NotificationId.ReadyToReceiveAuthToken,\n]);\n\n/* tslint:disable no-any */\nexport function isMessage(data: Message | any): data is Message {\n  if (!data) {\n    return false;\n  }\n\n  const message = data as Message;\n  if (!message || !message.msgGuid || !message.msgType) {\n    return false;\n  }\n\n  if (!guid.isGuid(message.msgGuid)) {\n    return false;\n  }\n\n  if (typeof message.msgType !== 'string') {\n    return false;\n  }\n\n  const messageTypes: Array<string> = [\n    MessageType.Command,\n    MessageType.CommandResponse,\n    MessageType.Initialize,\n    MessageType.Notification,\n    MessageType.Handshake,\n  ];\n\n  if (messageTypes.indexOf(message.msgType) < 0) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isVersion(versionNumber: VersionNumber | any): versionNumber is VersionNumber {\n  if (!versionNumber) {\n    return false;\n  }\n\n  const v = versionNumber as VersionNumber;\n\n  if (typeof v !== 'object') {\n    return false;\n  }\n\n  if (typeof v.fix !== 'number' || typeof v.minor !== 'number' || typeof v.major !== 'number') {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isInitMessage(message: InitializeMessage | any): message is InitializeMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const initMessage = message as InitializeMessage;\n  if (initMessage.msgType !== MessageType.Initialize) {\n    return false;\n  }\n\n  if (!initMessage.apiVersion || !isVersion(initMessage.apiVersion)) {\n    return false;\n  }\n\n  if (!initMessage.crossFrameVersion || !isVersion(initMessage.crossFrameVersion)) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isCommandResponseMessage(message: CommandResponseMessage | any): message is CommandResponseMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const crMessage = message as CommandResponseMessage;\n  if (crMessage.msgType !== MessageType.CommandResponse) {\n    return false;\n  }\n\n  if (!guid.isGuid(crMessage.commandGuid)) {\n    return false;\n  }\n\n  if (!crMessage.data && !crMessage.error) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isCommandMessage(message: CommandMessage | any): message is CommandMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const commandMessage = message as CommandMessage;\n  if (commandMessage.msgType !== MessageType.Command) {\n    return false;\n  }\n\n  if (!commandMessage.parameters || typeof commandMessage.parameters !== 'object') {\n    return false;\n  }\n\n  if (!commandMessage.verbId || typeof commandMessage.verbId !== 'string') {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isNotificationMessage(message: NotificationMessage | any): message is NotificationMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const notificationMessage = message as NotificationMessage;\n  if (notificationMessage.msgType !== MessageType.Notification) {\n    return false;\n  }\n\n  if (!notificationMessage.data && !expectedEmptyNotifications.has(notificationMessage.notificationId)) {\n    return false;\n  }\n\n  if (!notificationMessage.notificationId || typeof notificationMessage.notificationId !== 'string') {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isHandshakeMessage(message: HandshakeMessage | any): message is HandshakeMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const handshakeMessage = message as HandshakeMessage;\n  if (handshakeMessage.msgType !== MessageType.Handshake) {\n    return false;\n  }\n\n  return true;\n}\n","import { ExecuteParameters, Model, NotificationId, VerbId, VersionNumber } from '../../JsApiInternalContract';\nimport { InitializationOptions } from '../../interface/InitializationOptions';\n\n/**\n * Enum defining the 4 different types of messages we have defined\n */\nexport enum MessageType {\n  Initialize = 'initialize',\n  Notification = 'notification',\n  Command = 'command',\n  CommandResponse = 'command-response',\n  Handshake = 'v-handshake',\n  Ack = 'v-ack',\n}\n\n/**\n * The Message interface is the base interface for all the other\n * message type interfaces.\n */\nexport interface Message {\n  /**\n   * A unique id for this message\n   */\n  msgGuid: string;\n\n  /**\n   * The type of this message\n   */\n  msgType: MessageType;\n}\n\n/**\n * The initialize message is the first message which will be sent\n * from the javascript to set up communications\n */\nexport interface InitializeMessage extends Message {\n  /**\n   * The version of the api which the sender wants to use\n   */\n  apiVersion: VersionNumber;\n\n  /**\n   * The version of this messaging contract to be used. For now, there\n   * should only be a single version but sending this along should help\n   * if we need to add a new version in a future release\n   */\n  crossFrameVersion: VersionNumber;\n\n  /**\n   * Additional options that can be passed at the time of initialization\n   */\n  options?: InitializationOptions;\n}\n\n/**\n * This message is sent when a notification occurs from the preslayer\n */\nexport interface NotificationMessage extends Message {\n  /**\n   * The id for this type of notification\n   */\n  notificationId: NotificationId;\n\n  /**\n   * The data which came along with the notification\n   */\n  data: Model;\n}\n\n/**\n * Represents calling an internal contract command\n */\nexport interface CommandMessage extends Message {\n  /**\n   * The id of the command which should be executed\n   */\n  verbId: VerbId;\n\n  /**\n   * An object containing the parameters for the command\n   */\n  parameters: ExecuteParameters;\n}\n\n/**\n * This message is sent in response to a CommandMessage with the\n * result of that commands invocation\n */\nexport interface CommandResponseMessage extends Message {\n  /**\n   * Guid of the CommandMessage which this is in response to\n   */\n  commandGuid: string;\n\n  /**\n   * If there was an error returned from the command, this will be defined\n   * and contain the error\n   */\n  error?: Model;\n\n  /**\n   * If the command executed successfully, this will contain the command result\n   */\n  data?: Model;\n}\n\nexport interface HandshakeMessage extends Message {\n  /**\n   * Internal API contract version\n   */\n  platformVersion: VersionNumber;\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId } from '../JsApiInternalContract';\nimport { InternalContractVersionConverter } from './InternalContractVersionConverter';\n\n// tslint:disable:no-any\n\n/**\n * This version converter doesn't actually do anything but is useful for testing or when we have\n * a matching platform and internal version number\n */\nexport class IdentityVersionConverter implements InternalContractVersionConverter {\n  public upgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    return {\n      verb: verb as VerbId,\n      parameters: parameters as ExecuteParameters,\n    };\n  }\n\n  public downgradeExecuteReturn(executeResponse: ExecuteResponse): ExecuteResponse {\n    return executeResponse;\n  }\n\n  public downgradeNotification(notification: Notification): Notification {\n    return notification;\n  }\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId, VersionNumber } from '../JsApiInternalContract';\nimport { InternalContractVersionConverter } from './InternalContractVersionConverter';\nimport * as Translations from './VersionTranslations';\n\n// tslint:disable:no-any\n\n/**\n * The version converter is designed to allow the platform and external modules\n * to seemlessly communicate over two different versions of the internal API. The only\n * mode it supports is external's version <= platform's version. When executing\n * commands, it is used to upgrade the external representation to what platform knows on the way in\n * and downgrade the representations on the way out. Similarly for notifications, it can\n * downgrade those on the way from platform to external.\n */\nexport class StackingVersionConverter implements InternalContractVersionConverter {\n  /**\n   * Creates a new instance of the StackingVersionConverter\n   *\n   * @param _externalVersion The version of the internal contract api-external-js is using\n   * @param _platformVersion The version of the internal contract the api-platform-js is using\n   * @param _upgradeExecuteTranslations Ordered list of the translations to perform when upgrading cmd parameters\n   * @param _downgradeExecuteTranslations Ordered list of downgrade translations to perform after a cmd\n   * @param _downgradeNotificationTranslations Ordered list of downgrade translations to perform on a notification\n   */\n  public static fromData(\n    externalVersion: VersionNumber,\n    platformVersion: VersionNumber,\n    upgradeExecuteTranslations: Array<Translations.UpgradeExecuteCall>,\n    downgradeExecuteTranslations: Array<Translations.DowngradeExecuteReturn>,\n    downgradeNotificationTranslations: Array<Translations.DowngradeNotification>,\n  ): StackingVersionConverter {\n    return new this(\n      externalVersion.major,\n      platformVersion.major,\n      upgradeExecuteTranslations,\n      downgradeExecuteTranslations,\n      downgradeNotificationTranslations,\n    );\n  }\n\n  /**\n   * Creates a new instance of the StackingVersionConverter\n   *\n   * @param _externalMajorVersion The major version of the internal contract api-external-js is using\n   * @param _platformMajorVersion The major version of the internal contract the api-platform-js is using\n   * @param _upgradeExecuteTranslations Ordered list of the translations to perform when upgrading cmd parameters\n   * @param _downgradeExecuteTranslations Ordered list of downgrade translations to perform after a cmd\n   * @param _downgradeNotificationTranslations Ordered list of downgrade translations to perform on a notification\n   */\n  public constructor(\n    private _externalMajorVersion: number,\n    private _platformMajorVersion: number,\n    private _upgradeExecuteTranslations: Array<Translations.UpgradeExecuteCall>,\n    private _downgradeExecuteTranslations: Array<Translations.DowngradeExecuteReturn>,\n    private _downgradeNotificationTranslations: Array<Translations.DowngradeNotification>,\n  ) {\n    if (this._externalMajorVersion > this._platformMajorVersion) {\n      throw new Error(`Cannot convert between external version ${this._externalMajorVersion} and ${this._platformMajorVersion}`);\n    }\n  }\n\n  public upgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    // Perform the upgrade of the verb and parameters to the level that platform is using\n    let upgraded = { verb: verb, parameters: parameters };\n    for (const upgradeTranslation of this._upgradeExecuteTranslations) {\n      upgraded = upgradeTranslation(upgraded.verb, upgraded.parameters);\n    }\n\n    return upgraded;\n  }\n\n  public downgradeExecuteReturn(executeResponse: ExecuteResponse): ExecuteResponse {\n    // Downgrade the response to what the external module is expecting\n    let downgraded = executeResponse;\n    for (const downgradeTranslation of this._downgradeExecuteTranslations) {\n      downgraded = downgradeTranslation(downgraded);\n    }\n\n    return downgraded;\n  }\n\n  public downgradeNotification(notification: Notification): Notification {\n    // Downgrade the notification to what the external module is expecting\n    let downgraded = notification;\n    for (const downgradeTranslation of this._downgradeNotificationTranslations) {\n      downgraded = downgradeTranslation(downgraded);\n    }\n\n    return downgraded;\n  }\n}\n","import { VersionNumber } from '../JsApiInternalContract';\nimport { IdentityVersionConverter } from './IdentityVersionConverter';\nimport { InternalContractVersionConverter } from './InternalContractVersionConverter';\nimport { StackingVersionConverter } from './StackingVersionConverter';\nimport * as Translations from './VersionTranslations';\nimport { DowngradeFlipboardZoneID, DowngradeWorksheetNames } from './VersionTranslations';\n\n/**\n * @returns true if lhs < rhs (ignoring fix number)\n * @param lhs\n * @param rhs\n */\nexport function VersionLessThan(lhs: VersionNumber, rhs: VersionNumber): boolean {\n  if (lhs.major > rhs.major) {\n    return false;\n  }\n  if (lhs.major < rhs.major) {\n    return true;\n  }\n  return lhs.minor < rhs.minor;\n}\n\n/**\n * @returns true if lhs == rhs (ignoring fix number)\n * @param lhs\n * @param rhs\n */\nexport function VersionEqualTo(lhs: VersionNumber, rhs: VersionNumber): boolean {\n  return lhs.major === rhs.major && lhs.minor === rhs.minor;\n}\n\nexport interface MajorMinorTranslators<T> {\n  [major: number]: { [minor: number]: Array<T> };\n}\n\n// A mapping from an older client version of internal-contract to the current platform version of this contract.\n// Each version bump can have an array of translations to perform in order. Notice that this is\n// different than the major upgrades/downgrades above because it handles both major and minor version changes.\n// Also please note: downgradeExecuteCall is handled on the client/external side rather than platform side.\n// When updating the major or minor version of our internal-contract, you will need to update these data structures.\n// * If there are translations to add, add them to the version to \"upgrade from\" or \"downgrade to\".\nexport const ExecuteMinorUpgrades: MajorMinorTranslators<Translations.UpgradeExecuteCall> = {\n  1: {\n    9: [], // Note that we put upgrades from 1.9 to 1.10 in the [1][9] bucket\n  },\n};\n\nexport const ExecuteMinorDowngrades: MajorMinorTranslators<Translations.DowngradeExecuteReturn> = {\n  1: {\n    5: [DowngradeWorksheetNames],\n    9: [],\n  },\n};\n\nexport const NotificationMinorDowngrades: MajorMinorTranslators<Translations.DowngradeNotification> = {\n  1: {\n    9: [],\n    10: [DowngradeFlipboardZoneID],\n  },\n};\n\n/**\n * Creates a new InternalContractVersionConverter which has the ability to upgrade and downgrade the contract\n * between the two versions, which are specified. If externalMajorVersion is greater than platformMajorVersion,\n * an error will be thrown because we won't know how to do those conversions.\n * This converter can handle both major and minor updates when the platform version is greater than external version.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n */\nexport function CreateVersionConverter(externalVersion: VersionNumber, platformVersion: VersionNumber): InternalContractVersionConverter {\n  return CreateVersionConverterWithTranslators(\n    externalVersion,\n    platformVersion,\n    ExecuteMinorUpgrades,\n    ExecuteMinorDowngrades,\n    NotificationMinorDowngrades,\n  );\n}\n\n/**\n * Implementation of CreateVersionConverter. This function takes the upgrade, downgrade, and\n * notification arrays so that all the logic can be tested.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n * @param upgrades MajorMinorTranslators for upgrades\n * @param downgrades MajorMinorTranslators for downgrades\n * @param notificationDowngrades MajorMinorTranslators for notification downgrades\n */\nexport function CreateVersionConverterWithTranslators(\n  externalVersion: VersionNumber,\n  platformVersion: VersionNumber,\n  upgrades: MajorMinorTranslators<Translations.UpgradeExecuteCall>,\n  downgrades: MajorMinorTranslators<Translations.DowngradeExecuteReturn>,\n  notificationDowngrades: MajorMinorTranslators<Translations.DowngradeNotification>,\n): InternalContractVersionConverter {\n  const externalMajorVersion: number = externalVersion.major;\n  const externalMinorVersion: number = externalVersion.minor;\n  const platformMajorVersion: number = platformVersion.major;\n\n  if (externalMajorVersion > platformMajorVersion) {\n    throw new Error(`External version must be less than or equal to platform version.\n    externalMajorVersion=${externalMajorVersion} platformMajorVersion=${platformMajorVersion}`);\n  }\n\n  // If we are using the exact same versions (major.minor), just use the identity converter\n  if (VersionEqualTo(externalVersion, platformVersion)) {\n    return new IdentityVersionConverter();\n  }\n\n  // Walk the span between the versions we have here and collect the upgrade and downgrades necessary\n  const neededExecuteUpgrades: Array<Translations.UpgradeExecuteCall> = GetNeededTranslations(\n    externalMajorVersion,\n    platformMajorVersion,\n    externalMinorVersion,\n    upgrades,\n  );\n\n  const neededExecuteDowngrades: Array<Translations.DowngradeExecuteReturn> = GetNeededTranslations(\n    externalMajorVersion,\n    platformMajorVersion,\n    externalMinorVersion,\n    downgrades,\n  );\n\n  const neededNotificationDowngrades: Array<Translations.DowngradeNotification> = GetNeededTranslations(\n    externalMajorVersion,\n    platformMajorVersion,\n    externalMinorVersion,\n    notificationDowngrades,\n  );\n\n  // We want to apply the downgrades in reverse order in case of dependencies between them\n  neededExecuteDowngrades.reverse();\n  neededNotificationDowngrades.reverse();\n\n  return StackingVersionConverter.fromData(\n    externalVersion,\n    platformVersion,\n    neededExecuteUpgrades,\n    neededExecuteDowngrades,\n    neededNotificationDowngrades,\n  );\n}\n\nfunction GetNeededTranslations<T>(\n  externalMajorVersion: number,\n  platformMajorVersion: number,\n  externalMinorVersion: number,\n  majorMinorTranslators: MajorMinorTranslators<T>,\n): Array<T> {\n  const neededTranslations: Array<T> = [];\n\n  for (let major = externalMajorVersion; major <= platformMajorVersion; major++) {\n    if (major in majorMinorTranslators) {\n      const start = major === externalMajorVersion ? externalMinorVersion : 0;\n      const maximumMinorVersion = GetMaximumMinorIndex(Object.keys(majorMinorTranslators[major]));\n      for (let minor = start; minor <= maximumMinorVersion; minor++) {\n        if (minor in majorMinorTranslators[major]) {\n          neededTranslations.push(...majorMinorTranslators[major][minor]);\n        }\n      }\n    }\n  }\n\n  return neededTranslations;\n}\n\nexport function GetMaximumMinorIndex(minorVersions: Array<string>): number {\n  return minorVersions.map((a) => Number(a)).reduce((a, b) => (a > b ? a : b));\n}\n","import { ExecuteParameters, ExecuteResponse, ExtensionBootstrapInfo, Notification, VerbId } from '../JsApiInternalContract';\nimport { VisualId } from '../contract/Models';\nimport { NotificationId } from '../contract/Notifications';\n\n// tslint:disable:no-any\n\n/** This function is called when we receive old vers and parameters from the external before we send it to platform */\nexport type UpgradeExecuteCall = (verb: VerbId, parameters: ExecuteParameters) => { verb: VerbId; parameters: ExecuteParameters };\n\n/** This function is called when we received a response back from platform and we need to downgrade it to external's version */\nexport type DowngradeExecuteReturn = (executeResponse: ExecuteResponse) => ExecuteResponse;\n\n/** This function is called when we receive a notification from platform and we need to downgrade it to external's version */\nexport type DowngradeNotification = (notification: Notification) => Notification;\n\n// This is where we will start to define some of these translations.\n// When modifying existing models, add the requisite conversion functions here, then use them\n// in the VersionConverterFactory implementation. Import old versions as you would any other module\n\n// 0 <-> Translations\n// Uncomment this line to import from the V0 definition of the API\n// import * as V0 from '@tableau-api-internal-contract-js_v0';\n\n// 1 <-> 2 Translations\n// Uncomment this line to import from the V1 definition of the API\n// import * as V1 from '@tableau-api-internal-contract-js_v1';\n\nexport function DowngradeWorksheetNames(executeResponse: ExecuteResponse): ExecuteResponse {\n  // Fix the dashboard friendly name issue. The structures are compatible,\n  // so we still return the original reply, but we copy the SheetInfo.name\n  // into the DashboardZone.name, where v1 wants to find it.\n\n  const bootstrapInfo = executeResponse.result as ExtensionBootstrapInfo;\n  if (bootstrapInfo.extensionDashboardInfo !== undefined) {\n    bootstrapInfo.extensionDashboardInfo.zones.forEach((zone) => {\n      if (zone.sheetInfo) {\n        zone.name = zone.sheetInfo.name;\n      }\n    });\n  }\n\n  return executeResponse;\n}\n\nexport function DowngradeFlipboardZoneID(notification: Notification): Notification {\n  // Fix the FlipboardZoneId issue. Older external versions still check for flipboardZoneIDs.\n  // When running against a newer server, if flipboardZoneId is absent, set it to default(0).\n\n  if (notification.notificationId === NotificationId.SelectedMarksChanged) {\n    const visualModel = notification.data as VisualId;\n    if (visualModel.flipboardZoneID === undefined) {\n      visualModel.flipboardZoneID = 0;\n    }\n  }\n\n  return notification;\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId } from '../../JsApiInternalContract';\nimport { ExternalContractVersionConverter } from './ExternalContractVersionConverter';\n\n// tslint:disable:no-any\n\n/**\n * This version converter doesn't actually do anything but is useful for testing or when we have\n * a matching platform and external version number\n */\nexport class ExternalIdentityVersionConverter implements ExternalContractVersionConverter {\n  public downgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    return {\n      verb: verb as VerbId,\n      parameters: parameters as ExecuteParameters,\n    };\n  }\n\n  public upgradeExecuteReturn(executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters): ExecuteResponse {\n    return executeResponse;\n  }\n\n  public upgradeNotification(notification: Notification): Notification {\n    return notification;\n  }\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId, VersionNumber } from '../../JsApiInternalContract';\nimport { ExternalContractVersionConverter } from './ExternalContractVersionConverter';\nimport * as Translations from './ExternalVersionTranslations';\n\n// tslint:disable:no-any\n/**\n * The version converter is designed to allow the platform and external modules\n * to seemlessly communicate over two different versions of the internal API. This converter\n * supports external's version(minor) >= platform's version(minor). When executing\n * commands, it is used to downgrade the external representation to what platform knows on the way in\n * and upgrade the representations on the way out.\n */\nexport class ExternalStackingVersionConverter implements ExternalContractVersionConverter {\n  /**\n   * Creates a new instance of the StackingVersionConverter\n   *\n   * @param _externalVersion The version of the internal contract api-external-js is using\n   * @param _platformVersion The version of the internal contract the api-platform-js is using\n   * @param _downgradeExecuteCallTranslations Ordered list of the translations to perform when downgrading cmd parameters\n   * @param _upgradeExecuteReturnTranslations Ordered list of upgrade translations to perform after a cmd is executed\n   * @param _upgradeNotificationTranslations Ordered list of upgrade notfications to perform on events\n   */\n  public constructor(\n    private _externalVersion: VersionNumber,\n    private _platformVersion: VersionNumber,\n    private _downgradeExecuteCallTranslations: Array<Translations.DowngradeExecuteCall>,\n    private _upgradeExecuteReturnTranslations: Array<Translations.UpgradeExecuteReturn>,\n    private _upgradeNotificationTranslations: Array<Translations.UpgradeNotification>,\n  ) {\n    if (this._externalVersion.major > this._platformVersion.major) {\n      throw new Error(`Cannot convert between external version ${this._externalVersion.major}\n      and ${this._platformVersion.major}`);\n    }\n  }\n\n  public downgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    // Perform the downgrade of the verb and parameters to the level that platform is using\n    let downgraded = { verb: verb, parameters: parameters };\n    for (const downgradeTranslation of this._downgradeExecuteCallTranslations) {\n      downgraded = downgradeTranslation(downgraded.verb, downgraded.parameters);\n    }\n\n    return downgraded;\n  }\n\n  public upgradeExecuteReturn(executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters): ExecuteResponse {\n    // Perform the upgrade of the response to what the external module is expecting\n    let upgraded = executeResponse;\n    for (const upgradeTranslation of this._upgradeExecuteReturnTranslations) {\n      upgraded = upgradeTranslation(upgraded, verb, parameters);\n    }\n\n    return upgraded;\n  }\n\n  public upgradeNotification(notification: Notification): Notification {\n    // Perform the upgrade of notification to what the external module is expecting\n    let upgraded = notification;\n    for (const upgradeNotification of this._upgradeNotificationTranslations) {\n      upgraded = upgradeNotification(upgraded);\n    }\n\n    return upgraded;\n  }\n}\n","import { VersionNumber } from '../../JsApiInternalContract';\nimport { GetMaximumMinorIndex, MajorMinorTranslators, VersionEqualTo } from '../VersionConverterFactory';\nimport { ExternalContractVersionConverter } from './ExternalContractVersionConverter';\nimport { ExternalIdentityVersionConverter } from './ExternalIdentityVersionConverter';\nimport { ExternalStackingVersionConverter } from './ExternalStackingVersionConverter';\nimport * as TranslationsExternal from './ExternalVersionTranslations';\nimport {\n  DowngradeLogicalTableDataAsync,\n  DowngradeUnderlyingTableDataAsync,\n  UpgradeDataTableRowsAndColumns,\n  UpgradeDataTableTypes,\n} from './ExternalVersionTranslations';\n\n// A mapping from the current client version of internal-contract to an older platform version of the contract.\n// Each version bump can have an array of translations to perform in order.\n// These translations handle downgradeExecuteCall and upgradeExecuteReturn and are meant to be called on the\n// client/external side.\n// When updating the major or minor version of our internal-contract, you will need to update these data structures.\n// * If there are translations to add, add them to the version to 'upgrade from' or 'downgrade to'.\nexport const ExecuteMinorDowngradeCallExternal: MajorMinorTranslators<TranslationsExternal.DowngradeExecuteCall> = {\n  1: {\n    9: [], // Note that we put downgrades from 1.10 to 1.9 in the [1][9] bucket\n    13: [DowngradeUnderlyingTableDataAsync, DowngradeLogicalTableDataAsync],\n  },\n};\n\nexport const ExecuteMinorUpgradeReturnExternal: MajorMinorTranslators<TranslationsExternal.UpgradeExecuteReturn> = {\n  1: {\n    9: [UpgradeDataTableTypes], // Note that we put upgrades from 1.9 to 1.10 in the [1][9] bucket\n    29: [UpgradeDataTableRowsAndColumns], // 2021.1 was released with 1.29. Upgrade from 1.29 in the [1][29] bucket\n  },\n};\n\nexport const ExecuteMinorUpgradeNotification: MajorMinorTranslators<TranslationsExternal.UpgradeNotification> = {\n  1: {\n    9: [], // Note that we put upgrades from 1.9 to 1.10 in the [1][9] bucket\n  },\n};\n\n/**\n * Creates a new ExternalContractVersionConverter which has the ability to upgrade and downgrade\n * the contract between the two versions which are specified. If externalMajorVersion is less than\n * platformMajorVersion, an ExternalIdentityVersionConverter will be returned.\n * Handles upgrade/downgrade for both major and minor updates.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n */\nexport function CreateExternalCompatibleVersionConverter(\n  externalVersion: VersionNumber,\n  platformVersion: VersionNumber,\n): ExternalContractVersionConverter {\n  return CreateExternalCompatibleVersionConverterWithTranslators(\n    externalVersion,\n    platformVersion,\n    ExecuteMinorDowngradeCallExternal,\n    ExecuteMinorUpgradeReturnExternal,\n    ExecuteMinorUpgradeNotification,\n  );\n}\n\n/**\n * Implementation of CreateExternalCompatibleVersionConverterWithTranslators.\n * This function takes the upgrade, downgrade arrays so that all the logic can be tested.\n *\n * @param externalVersion VersionNumber of the internal contract which the external module is using\n * @param platformVersion VersionNumber of the internal contract which the platform is using\n * @param upgrades MajorMinorTranslators for response upgrades\n * @param downgrades MajorMinorTranslators for execute call downgrades\n */\nexport function CreateExternalCompatibleVersionConverterWithTranslators(\n  externalVersion: VersionNumber,\n  platformVersion: VersionNumber,\n  downgrades: MajorMinorTranslators<TranslationsExternal.DowngradeExecuteCall>,\n  upgrades: MajorMinorTranslators<TranslationsExternal.UpgradeExecuteReturn>,\n  upgradeNotifications: MajorMinorTranslators<TranslationsExternal.UpgradeNotification>,\n): ExternalContractVersionConverter {\n  const externalMajorVersion: number = externalVersion.major;\n  const platformMajorVersion: number = platformVersion.major;\n  const platformMinorVersion: number = platformVersion.minor;\n\n  // This check is present in VersionConverterFactory. We throw the same error here as well.\n  // Hence we only need to check the minor versions for translations.\n  if (externalMajorVersion > platformMajorVersion) {\n    throw new Error(`External version must be less than or equal to platform version.\n    externalMajorVersion=${externalMajorVersion} platformMajorVersion=${platformMajorVersion}`);\n  }\n\n  if (externalMajorVersion < platformMajorVersion || VersionEqualTo(externalVersion, platformVersion)) {\n    return new ExternalIdentityVersionConverter();\n  }\n\n  // Walk the span between the versions we have here and collect the upgrade and downgrades necessary\n  const neededExecuteCallDowngrade: Array<TranslationsExternal.DowngradeExecuteCall> = GetNeededExternalTranslations(\n    platformMajorVersion,\n    platformMinorVersion,\n    downgrades,\n  );\n\n  const neededExecuteReturnUpgrades: Array<TranslationsExternal.UpgradeExecuteReturn> = GetNeededExternalTranslations(\n    platformMajorVersion,\n    platformMinorVersion,\n    upgrades,\n  );\n\n  const neededNotificationUpgrades: Array<TranslationsExternal.UpgradeNotification> = GetNeededExternalTranslations(\n    platformMajorVersion,\n    platformMinorVersion,\n    upgradeNotifications,\n  );\n\n  // Reverse the downgrade calls, so that we start the downgrade from the external version to the platform version\n  neededExecuteCallDowngrade.reverse();\n  return new ExternalStackingVersionConverter(\n    externalVersion,\n    platformVersion,\n    neededExecuteCallDowngrade,\n    neededExecuteReturnUpgrades,\n    neededNotificationUpgrades,\n  );\n}\n\nfunction GetNeededExternalTranslations<T>(\n  platformMajorVersion: number,\n  platformMinorVersion: number,\n  majorMinorTranslators: MajorMinorTranslators<T>,\n): Array<T> {\n  const neededTranslations: Array<T> = [];\n\n  if (platformMajorVersion in majorMinorTranslators) {\n    const start = platformMinorVersion;\n    const maximumMinorVersion = GetMaximumMinorIndex(Object.keys(majorMinorTranslators[platformMajorVersion]));\n    for (let minor = start; minor <= maximumMinorVersion; minor++) {\n      if (minor in majorMinorTranslators[platformMajorVersion]) {\n        neededTranslations.push(...majorMinorTranslators[platformMajorVersion][minor]);\n      }\n    }\n  }\n\n  return neededTranslations;\n}\n","import {\n  ApiShowDataTableSentinel,\n  DataHeader,\n  DataTable,\n  DataTypeConverter,\n  ExecuteParameters,\n  ExecuteResponse,\n  InternalTableauError,\n  Notification,\n  ParameterId,\n  SelectedMarksTable,\n  UnderlyingDataTable,\n  VerbId,\n} from '../../JsApiInternalContract';\n\n// tslint:disable:no-any\n\n/** This function is called when we receive newer version and parameters from the external before we send it to platform */\nexport type DowngradeExecuteCall = (verb: VerbId, parameters: ExecuteParameters) => { verb: VerbId; parameters: ExecuteParameters };\n\n/** This function is called when we receive a response back from platform and we need to upgrade it to external's version\n *  The verb and parameters provide a context to decide how to handle the response.\n */\nexport type UpgradeExecuteReturn = (executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters) => ExecuteResponse;\n\n/** This function is called when we receive a notification from platform and we need to upgrade it to external's version */\nexport type UpgradeNotification = (notification: Notification) => Notification;\n\n// 1.2 -> 1.0 Translations\n// Uncomment this line to import from the V1 definition of the API\n// import * as V1 from '@tableau-api-internal-contract-js_v1';\n\n/**\n * Prior to 2019.2 (internal-contract v1.9), DataValue.value were all strings.\n * Go through all DataValue objects. If we have a string, but the type should not be a string,\n * convert it to the correct type. The type of DataValue.value is 'any' in the contract, so\n * this change doesn't need any updates to classes or types.\n */\nexport function UpgradeDataTableTypes(executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters): ExecuteResponse {\n  if (!executeResponse) {\n    return executeResponse;\n  }\n\n  const oldUnderlyingDataTable = executeResponse.result as UnderlyingDataTable;\n  if (oldUnderlyingDataTable.data !== undefined && oldUnderlyingDataTable.isSummary !== undefined) {\n    convertDataValues(oldUnderlyingDataTable.data);\n    return executeResponse;\n  }\n\n  const oldSelectedMarksTable = executeResponse.result as SelectedMarksTable;\n  if (oldSelectedMarksTable.data !== undefined && Array.isArray(oldSelectedMarksTable.data)) {\n    oldSelectedMarksTable.data.forEach((marksTable) => {\n      convertDataValues(marksTable);\n    });\n    return executeResponse;\n  }\n\n  return executeResponse;\n}\n\n/**\n * Prior to 2020.2 (internal-contract v1.13 and older), worksheet.getUnderlyingTableDataAsync doesn't exist.\n * Map it to the older GetUnderlyingData verb and validate the the logical table Id.\n **/\nexport function DowngradeUnderlyingTableDataAsync(\n  verb: VerbId,\n  parameters: ExecuteParameters,\n): {\n  verb: VerbId;\n  parameters: ExecuteParameters;\n} {\n  if (verb === VerbId.GetUnderlyingTableData) {\n    validateParametersForObjectModel(verb, parameters);\n    verb = VerbId.GetUnderlyingData;\n  }\n  return {\n    verb: verb,\n    parameters: parameters,\n  };\n}\n\n/**\n * Prior to 2020.2 (internal-contract v1.13 and older), datasource.getLogicalTableDataAsync doesn't exist.\n * Map it to the older GetDataSourceData verb and validate the the logical table Id.\n **/\nexport function DowngradeLogicalTableDataAsync(\n  verb: VerbId,\n  parameters: ExecuteParameters,\n): {\n  verb: VerbId;\n  parameters: ExecuteParameters;\n} {\n  if (verb === VerbId.GetLogicalTableData) {\n    validateParametersForObjectModel(verb, parameters);\n    verb = VerbId.GetDataSourceData;\n  }\n  return {\n    verb: verb,\n    parameters: parameters,\n  };\n}\n\nfunction convertDataValues(table: DataTable): void {\n  // dataTable is a two-dimensional array of data. First index is the row, second is the column.\n  if (table === undefined || table.dataTable === undefined || !Array.isArray(table.dataTable)) {\n    return;\n  }\n\n  table.dataTable.forEach((row) => {\n    row.forEach((dataValue, columnIndex) => {\n      const value = dataValue.value;\n      if (value !== null) {\n        dataValue.value = DataTypeConverter.convertValueAsStringToValue(value, table.headers[columnIndex].dataType);\n      }\n    });\n  });\n}\n\n// ToDo: TFS1069027 Refactor input verbs & parameters in api-internal-contract Upgrade/Downgrade framework\nfunction validateParametersForObjectModel(verb: VerbId, parameters: ExecuteParameters): void {\n  if (parameters[ParameterId.LogicalTableId] !== ApiShowDataTableSentinel.SingleTableId) {\n    throw new Error(`Invalid logical table id passed to ${verb}.`) as InternalTableauError;\n  }\n}\n\n/**\n * Prior to 2021.2 (internal-contract v1.29 and below), getSummaryDataAsync did not support maxRows,\n * and any get...DataAsync did not support columnsToIncludeById.\n * Trim result to maxRows if it is included in the parameters for getSummaryDataAsync\n * Trim columns to columnsToInclude if included in the parameters for any get...DataAsync\n */\nexport function UpgradeDataTableRowsAndColumns(\n  executeResponse: ExecuteResponse,\n  verb: VerbId,\n  parameters: ExecuteParameters,\n): ExecuteResponse {\n  if (isGetSummaryDataVerb(verb) && parameters[ParameterId.MaxRows]) {\n    executeResponse = adjustDataRowLength(executeResponse, parameters[ParameterId.MaxRows] as number);\n  }\n\n  if (isGetTableDataVerb(verb) && parameters[ParameterId.ColumnsToIncludeById]) {\n    executeResponse = adjustDataColumns(executeResponse, parameters[ParameterId.ColumnsToIncludeById] as string[]);\n  }\n\n  return executeResponse;\n}\n\nfunction isGetSummaryDataVerb(verb: VerbId): boolean {\n  return verb === VerbId.GetDataSummaryData;\n}\n\nfunction isGetTableDataVerb(verb: VerbId): boolean {\n  return (\n    verb === VerbId.GetDataSummaryData ||\n    verb === VerbId.GetUnderlyingTableData ||\n    verb === VerbId.GetLogicalTableData ||\n    verb === VerbId.GetDataSourceData ||\n    verb === VerbId.GetUnderlyingData\n  );\n}\n\nfunction adjustDataRowLength(executeResponse: ExecuteResponse, maxRows: number): ExecuteResponse {\n  const underlyingDataTable = executeResponse.result as UnderlyingDataTable;\n  if (!underlyingDataTable.data || !Array.isArray(underlyingDataTable.data.dataTable)) {\n    return executeResponse;\n  }\n\n  if (maxRows > 0 && maxRows < underlyingDataTable.data.dataTable.length) {\n    underlyingDataTable.data.dataTable.length = maxRows;\n  }\n  return executeResponse;\n}\n\nfunction adjustDataColumns(executeResponse: ExecuteResponse, columnsToInclude: string[]): ExecuteResponse {\n  if (columnsToInclude.length === 0) {\n    return executeResponse;\n  }\n\n  // verify that we have a valid UnderlyingDataTable\n  const underlyingDataTable = executeResponse.result as UnderlyingDataTable;\n  if (!underlyingDataTable.data || !Array.isArray(underlyingDataTable.data.dataTable) || !Array.isArray(underlyingDataTable.data.headers)) {\n    return executeResponse;\n  }\n\n  // 1. filter the headers to only columnsToInclude\n  // 2. use the new headers to filter all rows\n  // 3. update the indices in our new headers\n  const newHeaders: DataHeader[] = underlyingDataTable.data.headers.filter((header, index) =>\n    columnsToInclude.find((name) => name === header.fieldName),\n  );\n  underlyingDataTable.data.dataTable.forEach((row, index) => {\n    underlyingDataTable.data.dataTable[index] = row.filter(\n      (value, valueIndex) => newHeaders.findIndex((header) => header.index === valueIndex) !== -1,\n    );\n  });\n  let newIndex = 0;\n  underlyingDataTable.data.headers = newHeaders.map((header) => {\n    header.index = newIndex++;\n    return header;\n  });\n\n  return executeResponse;\n}\n","// Export everything which had been previously in the api-shared module\n\nexport { ApiVersion } from './ApiShared/ApiVersion';\nexport * from './ApiShared/CrossFrame/CrossFrameBootstrap';\nexport { CrossFrameDispatcher } from './ApiShared/CrossFrame/CrossFrameDispatcher';\nexport { DataSource } from './ApiShared/DataSource';\nexport { ExternalToInternalEnumMappings } from './ApiShared/EnumMappings/ExternalToInternalEnumMappings';\nexport { InternalToExternalEnumMappings } from './ApiShared/EnumMappings/InternalToExternalEnumMappings';\nexport { EventListenerManager } from './ApiShared/EventListenerManager';\nexport { Field } from './ApiShared/Field';\nexport { CustomViewImpl } from './ApiShared/Impl/CustomViewImpl';\nexport { DashboardImpl } from './ApiShared/Impl/DashboardImpl';\nexport { DashboardObjectImpl } from './ApiShared/Impl/DashboardObjectImpl';\nexport { DataSourceImpl } from './ApiShared/Impl/DataSourceImpl';\nexport { ParameterImpl } from './ApiShared/Impl/ParameterImpl';\nexport { SheetImpl } from './ApiShared/Impl/SheetImpl';\nexport { SheetInfoImpl } from './ApiShared/Impl/SheetInfoImpl';\nexport { SingleEventManagerImpl } from './ApiShared/Impl/SingleEventManagerImpl';\nexport { StoryImpl } from './ApiShared/Impl/StoryImpl';\nexport { StoryPointImpl } from './ApiShared/Impl/StoryPointImpl';\nexport { StoryPointInfoImpl } from './ApiShared/Impl/StoryPointInfoImpl';\nexport { WorkbookImpl } from './ApiShared/Impl/WorkbookImpl';\nexport { WorksheetImpl } from './ApiShared/Impl/WorksheetImpl';\nexport { Point } from './ApiShared/Point';\nexport { AnnotationService } from './ApiShared/Services/AnnotationService';\nexport { DataSourceService } from './ApiShared/Services/DataSourceService';\nexport { ExportService } from './ApiShared/Services/ExportService';\nexport { FilterService } from './ApiShared/Services/FilterService';\nexport { GetDataService } from './ApiShared/Services/GetDataService';\nexport { NotificationService, UnregisterFn } from './ApiShared/Services/NotificationService';\nexport { ParametersService } from './ApiShared/Services/ParametersService';\nexport * from './ApiShared/Services/RegisterAllSharedServices';\nexport { SelectionService } from './ApiShared/Services/SelectionService';\nexport * from './ApiShared/Services/ServiceRegistry';\nexport { SizeService } from './ApiShared/Services/SizeService';\nexport { StoryActivationService } from './ApiShared/Services/StoryActivationService';\nexport { VizService } from './ApiShared/Services/VizService';\nexport { ClientInfoServiceImpl } from './ApiShared/Services/impl/ClientInfoServiceImpl';\nexport { NotificationServiceImpl } from './ApiShared/Services/impl/NotificationServiceImpl';\nexport { NotificationServiceImplBase, Registration } from './ApiShared/Services/impl/NotificationServiceImplBase';\nexport { ServiceImplBase } from './ApiShared/Services/impl/ServiceImplBase';\nexport { SizeServiceImpl } from './ApiShared/Services/impl/SizeServiceImpl';\nexport { StoryActivationServiceImpl } from './ApiShared/Services/impl/StoryActivationServiceImpl';\nexport { SingleEventManager } from './ApiShared/SingleEventManager';\nexport { TableauError } from './ApiShared/TableauError';\nexport { Deferred } from './ApiShared/Utils/Deferred';\nexport { ErrorHelpers } from './ApiShared/Utils/ErrorHelpers';\nexport { ExportHelpers } from './ApiShared/Utils/ExportHelpers';\nexport { SheetUtils } from './ApiShared/Utils/SheetUtils';\nexport { VersionNumber } from './ApiShared/VersionNumber';\nexport { VersionedExternalApiDispatcher } from './VersionedExternalApiDispatcher';\n","import { VersionNumber } from './VersionNumber';\nimport { VersionNumberContract } from './VersionNumberContract';\n\n/**\n * This is the singleton wrapper of VersionNumber\n */\nexport class ApiVersion {\n  // Using some webpack tricks, we can inject this version into our code (kinda like c++ preprocessor stuff)\n  private static _instance: VersionNumberContract;\n\n  /**\n   * Gets the singleton instance of the version number.\n   */\n  public static get Instance(): VersionNumberContract {\n    return ApiVersion._instance;\n  }\n\n  public static SetVersionNumber(numString: string, isAlpha: boolean): void {\n    ApiVersion._instance = new VersionNumber(numString, isAlpha);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ConnectionDescriptionSummary } from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of a connection summary.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class ConnectionSummary implements Contract.ConnectionSummary {\n  public constructor(private _connectionInfo: ConnectionDescriptionSummary) {}\n\n  public get name(): string {\n    return this._connectionInfo.name;\n  }\n\n  public get id(): string {\n    return this._connectionInfo.id;\n  }\n\n  public get serverURI(): string {\n    return this._connectionInfo.serverURI;\n  }\n\n  public get type(): string {\n    return this._connectionInfo.type;\n  }\n}\n","import * as Contract from '@tableau/api-internal-contract-js';\nimport {\n  CommandResponseMessage,\n  CrossFrameMessenger,\n  InitializationOptions,\n  MESSAGING_VERSION as ApiMessagingVersion,\n} from '@tableau/api-internal-contract-js';\nimport { CrossFrameDispatcher } from './CrossFrameDispatcher';\n\n// Checks to see if we are running in an iframe currently: https://stackoverflow.com/a/326076/8821153\nfunction inIframe(thisWindow: Window): boolean {\n  try {\n    return thisWindow.self !== thisWindow.parent;\n  } catch (e) {\n    return true;\n  }\n}\n\n/**\n * Attempts to bootstrap the extension with a cross-frame parent where Tableau is running\n *\n * @param thisWindow The window which we are running in (injected for unit testing purposes)\n * @param internalContractVersion The version number of the internal contract we are using\n * @returns A promise which is doing the actual bootstrapping\n */\nexport function doCrossFrameBootstrap(\n  thisWindow: Window,\n  internalContractVersion: Contract.VersionNumber,\n  options: InitializationOptions,\n): Promise<Contract.InternalApiDispatcherFactory> {\n  return new Promise<Contract.InternalApiDispatcherFactory>((resolve, reject) => {\n    let parent: Window;\n\n    // Normally, we are running inside an iframe.  The exception to this is\n    // when we are running as an extension inside a dialog as part of the UINamespace\n    // functionality.  In that case, we want the opener of this window rather than the parent.\n    if (!inIframe(thisWindow)) {\n      parent = thisWindow.opener;\n    } else {\n      parent = thisWindow.parent;\n    }\n\n    if (!parent) {\n      reject('This extension is not running inside an iframe, desktop, or popup window. Initialization failed.');\n    }\n\n    // Create the messenger which will do he communication between this window and our parent\n    // Since we don't know where we are running yet, we have to make this initial origin '*'. Once\n    // we have successfully initialized our extension, we will limit where we send messages\n    const messenger = new CrossFrameMessenger(thisWindow, parent, '*');\n\n    // Prepare to send an initialization message to the parent frame\n    const initializationMessage = messenger.prepareInitializationMessage(internalContractVersion, ApiMessagingVersion, options);\n\n    // When we receive a response back from the parent, we check to make sure the guids match and then we know\n    // that the parent is aware of us and we can start communicating\n    messenger.setCommandResponseMessageHandler(function (msg: CommandResponseMessage): void {\n      // Verify we are getting a response from our initialize message\n      if (msg.commandGuid === initializationMessage.messageGuid) {\n        // The versioning of the dispatcher happens on the other side of our frame, and\n        // in a wrapper on this side. This one doesn't have any version knowledge.\n        const dispatcherFactory = () => new CrossFrameDispatcher(messenger);\n        resolve(dispatcherFactory);\n      }\n    });\n\n    // Now that our handlers are ready, start listening and send our initialization message\n    messenger.startListening();\n    initializationMessage.send();\n  });\n}\n","import { EmbeddingErrorCodes } from '@tableau/api-external-contract-js';\nimport {\n  CommandResponseMessage,\n  ExecuteParameters,\n  ExecuteResponse,\n  InternalApiDispatcher,\n  Messenger,\n  Model,\n  NotificationHandler,\n  NotificationMessage,\n  VerbId,\n} from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * This is an implementation of the InternalApiDispatcher interface which functions by passing messages\n * across a frame boundary. This is usually between the code where our javscript library has been included\n * by a 3rd party dev and another frame where Tableau server has content.\n */\nexport class CrossFrameDispatcher implements InternalApiDispatcher {\n  // Collection of pending promises which are waiting to be resolved. When we receive a response back from the other frame,\n  // these promises can be either resolved or rejected\n  private _pendingPromises: { [messageGuid: string]: { resolve: (response: ExecuteResponse) => void; reject: (error: Model) => void } } =\n    {};\n\n  // The collection of notification handlers which have been registered with this dispatcher\n  private _notificationHandlers: Array<NotificationHandler> = [];\n\n  /**\n   * Creates an instance of CrossFrameDispatcher which will use the given messenger to communicate\n   * @param _messenger an instantiated and listening messenger object\n   */\n  public constructor(private _messenger: Messenger) {\n    if (!this._messenger) {\n      throw 'Missing messenger object';\n    }\n\n    // Set up our message handlers. We only care about incoming notifications and command responses\n    this._messenger.setCommandResponseMessageHandler(this.onCommandResponse.bind(this));\n    this._messenger.setNotificationMessageHandler(this.onNotification.bind(this));\n  }\n\n  ////// Start InternalApiDispatcher implementation\n\n  public execute(verb: VerbId, parameters: ExecuteParameters): Promise<ExecuteResponse> {\n    // To execute a verb, we first prepare a command message and then define a promise.\n    const preparedMessage = this._messenger.prepareCommandMessage(verb, parameters);\n    const promise = new Promise<ExecuteResponse>((resolve, reject) => {\n      // Save off the pending promise by the messageGuid we are about to send. When a response is\n      // received, we'll be able to resolve this promise with the result\n      this._pendingPromises[preparedMessage.messageGuid] = { resolve: resolve, reject: reject };\n    });\n\n    // Actually send the message and return the promise\n    preparedMessage.send();\n    return promise;\n  }\n\n  public registerNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers.push(handler);\n  }\n\n  public unregisterNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers = this._notificationHandlers.filter((h) => h !== handler);\n  }\n\n  ////// End InternalApiDispatcher implementation\n\n  private onCommandResponse(response: CommandResponseMessage): void {\n    // We got a command response, look through the pending promises and resolve\n    if (Object.keys(this._pendingPromises).indexOf(response.commandGuid) < 0) {\n      return; // We don't have any reference to this command, just return\n    }\n\n    const pendingPromise = this._pendingPromises[response.commandGuid];\n\n    // If we have an error defined, reject the promise\n    if (response.error) {\n      pendingPromise.reject(response.error);\n    }\n\n    // If we have data defined, resolve the promise\n    if (response.data) {\n      pendingPromise.resolve({ result: response.data });\n    }\n\n    // Clean up our pending promises object\n    delete this._pendingPromises[response.commandGuid];\n  }\n\n  private onNotification(notificationMessage: NotificationMessage): void {\n    // Go through each notification handler we have registered and let them know a notification came in\n    for (const handler of this._notificationHandlers) {\n      try {\n        handler({ notificationId: notificationMessage.notificationId, data: notificationMessage.data });\n      } catch (e) {\n        // Incase of a IncompatibleVersionError, re-throw the error.\n        if ((e as TableauError).errorCode === EmbeddingErrorCodes.IncompatibleVersionError) {\n          throw e;\n        }\n        // Else Ignore  so if one handler errors, the other still get the message.\n      }\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataSourceImpl } from './Impl/DataSourceImpl';\n\nexport class DataSource implements Contract.DataSource {\n  public constructor(private _dataSourceImpl: DataSourceImpl) {}\n\n  public get name(): string {\n    return this._dataSourceImpl.name;\n  }\n\n  public get id(): string {\n    return this._dataSourceImpl.id;\n  }\n\n  public get fields(): Array<Contract.Field> {\n    return this._dataSourceImpl.fields;\n  }\n\n  public get extractUpdateTime(): string | undefined {\n    return this._dataSourceImpl.extractUpdateTime;\n  }\n\n  public get isExtract(): boolean {\n    return this._dataSourceImpl.isExtract;\n  }\n\n  public get isPublished(): boolean | undefined {\n    return this._dataSourceImpl.isPublished;\n  }\n\n  public publishedUrl(): string | undefined {\n    return this._dataSourceImpl.publishedUrl();\n  }\n\n  public refreshAsync(): Promise<void> {\n    return this._dataSourceImpl.refreshAsync();\n  }\n\n  public getActiveTablesAsync(): Promise<Array<Contract.TableSummary>> {\n    console.warn('DataSource.getActiveTablesAsync is deprecated. Please use DataSource.getLogicalTablesAsync.');\n    return this._dataSourceImpl.getActiveTablesAsync();\n  }\n\n  public getConnectionSummariesAsync(): Promise<Array<Contract.ConnectionSummary>> {\n    return this._dataSourceImpl.getConnectionSummariesAsync();\n  }\n\n  public getUnderlyingDataAsync(options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    console.warn(\n      'DataSource.getUnderlyingDataAsync is deprecated. Please use ' +\n        'DataSource.getLogicalTablesAsync and DataSource.getLogicalTableDataAsync.',\n    );\n    return this._dataSourceImpl.getUnderlyingDataAsync(options);\n  }\n\n  public getLogicalTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    return this._dataSourceImpl.getLogicalTablesAsync();\n  }\n\n  public getLogicalTableDataAsync(logicalTableId: string, options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    return this._dataSourceImpl.getLogicalTableDataAsync(logicalTableId, options);\n  }\n\n  public getLogicalTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount?: number,\n    options?: Contract.DataSourceUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    return this._dataSourceImpl.getLogicalTableDataReaderAsync(logicalTableId, pageRowCount, options);\n  }\n}\n","import {\n  DateRangeType as ExternalDateRangeType,\n  DialogStyle as ExternalDialogStyle,\n  FilterDomainType as ExternalDomainType,\n  FilterNullOption as ExternalNullOption,\n  FilterUpdateType as ExternalFilterUpdateType,\n  IncludeDataValuesOption,\n  PeriodType,\n  ReplaySpeedType,\n  SheetType as ExternalSheetType,\n  ZoneVisibilityType,\n} from '@tableau/api-external-contract-js';\nimport {\n  ApiShowDataTableFormat,\n  DateRangeType as InternalDateRangeType,\n  DateStepPeriod,\n  DialogStyle as InternalDialogStyle,\n  FilterDomainType as InternalDomainType,\n  FilterNullOption as InternalNullOption,\n  FilterUpdateType as InternalFilterUpdateType,\n  SheetType as InternalSheetType,\n} from '@tableau/api-internal-contract-js';\nimport { EnumConverter } from '../Utils/EnumConverter';\n\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\n/**\n * Maps enums used by the external-api-contract to the enums used\n * in the internal-api-contract, which developers code against.\n */\nexport class ExternalToInternalEnumMappings {\n  public static filterDomainType = new EnumConverter<ExternalDomainType, InternalDomainType>({\n    [ExternalDomainType.Relevant]: InternalDomainType.Relevant,\n    [ExternalDomainType.Database]: InternalDomainType.Database,\n  });\n\n  public static nullOptions = new EnumConverter<ExternalNullOption, InternalNullOption>({\n    [ExternalNullOption.AllValues]: InternalNullOption.AllValues,\n    [ExternalNullOption.NonNullValues]: InternalNullOption.NonNullValues,\n    [ExternalNullOption.NullValues]: InternalNullOption.NullValues,\n  });\n\n  public static filterUpdateType = new EnumConverter<ExternalFilterUpdateType, InternalFilterUpdateType>({\n    [ExternalFilterUpdateType.Add]: InternalFilterUpdateType.Add,\n    [ExternalFilterUpdateType.All]: InternalFilterUpdateType.All,\n    [ExternalFilterUpdateType.Remove]: InternalFilterUpdateType.Remove,\n    [ExternalFilterUpdateType.Replace]: InternalFilterUpdateType.Replace,\n  });\n\n  public static setVisibilityType = new EnumConverter<ZoneVisibilityType, boolean>({\n    [ZoneVisibilityType.Show]: true,\n    [ZoneVisibilityType.Hide]: false,\n  });\n\n  public static setReplaySpeedType = new EnumConverter<ReplaySpeedType, number>({\n    // these numbers are duration multipliers\n    // 2.0, for example, doubles the duration of the replay, slowing it down to 0.5x speed\n    [ReplaySpeedType.Slow]: 2.0,\n    [ReplaySpeedType.Normal]: 1.0,\n    [ReplaySpeedType.Fast]: 0.5,\n  });\n\n  public static sheetType = new EnumConverter<ExternalSheetType, InternalSheetType>({\n    [ExternalSheetType.Dashboard]: InternalSheetType.Dashboard,\n    [ExternalSheetType.Worksheet]: InternalSheetType.Worksheet,\n    [ExternalSheetType.Story]: InternalSheetType.Story,\n  });\n\n  public static showDataTableFormatType = new EnumConverter<IncludeDataValuesOption, ApiShowDataTableFormat>({\n    [IncludeDataValuesOption.AllValues]: ApiShowDataTableFormat.NativeAndFormattedValues,\n    [IncludeDataValuesOption.OnlyNativeValues]: ApiShowDataTableFormat.NativeValuesOnly,\n    [IncludeDataValuesOption.OnlyFormattedValues]: ApiShowDataTableFormat.FormattedValuesOnly,\n  });\n\n  public static periodType = new EnumConverter<PeriodType, DateStepPeriod>({\n    [PeriodType.Years]: DateStepPeriod.Years,\n    [PeriodType.Quarters]: DateStepPeriod.Quarters,\n    [PeriodType.Months]: DateStepPeriod.Months,\n    [PeriodType.Weeks]: DateStepPeriod.Weeks,\n    [PeriodType.Days]: DateStepPeriod.Days,\n    [PeriodType.Hours]: DateStepPeriod.Hours,\n    [PeriodType.Minutes]: DateStepPeriod.Minutes,\n    [PeriodType.Seconds]: DateStepPeriod.Seconds,\n  });\n\n  public static dateRangeType = new EnumConverter<ExternalDateRangeType, InternalDateRangeType>({\n    [ExternalDateRangeType.Last]: InternalDateRangeType.Last,\n    [ExternalDateRangeType.LastN]: InternalDateRangeType.LastN,\n    [ExternalDateRangeType.Next]: InternalDateRangeType.Next,\n    [ExternalDateRangeType.NextN]: InternalDateRangeType.NextN,\n    [ExternalDateRangeType.Current]: InternalDateRangeType.Current,\n    [ExternalDateRangeType.ToDate]: InternalDateRangeType.ToDate,\n  });\n\n  public static dialogStyles = new EnumConverter<ExternalDialogStyle, InternalDialogStyle>({\n    [ExternalDialogStyle.Window]: InternalDialogStyle.Window,\n    [ExternalDialogStyle.Modal]: InternalDialogStyle.Modal,\n    [ExternalDialogStyle.Modeless]: InternalDialogStyle.Modeless,\n  });\n}\n/* tslint:enable:typedef */\n","import {\n  AnnotationType as ExternalAnnotationType,\n  ClassNameKey as ExternalClassNameKey,\n  ColumnType as ExternalColumnType,\n  DashboardObjectType as ExternalDashboardObjectType,\n  DataType as ExternalDataType,\n  PeriodType as ExternalDatePeriod,\n  DateRangeType as ExternalDateRangeType,\n  ErrorCodes as ExternalErrorCodes,\n  ExtensionContext as ExternalExtensionsContext,\n  ExtensionMode as ExternalExtensionsMode,\n  FieldAggregationType as ExternalFieldAggregationType,\n  FieldRoleType as ExternalFieldRoleType,\n  FilterType as ExternalFilterType,\n  FilterUpdateType as ExternalFilterUpdateType,\n  HierarchicalLevelSelectionState as ExternalHierarchicalLevelSelectionState,\n  MarkType as ExternalMarkType,\n  ParameterValueType as ExternalParameterValueType,\n  SheetType as ExternalSheetType,\n} from '@tableau/api-external-contract-js';\nimport {\n  AnnotateEnum as InternalAnnotationType,\n  ClassNameKey as InternalClassNameKey,\n  ColumnType as InternalColumnType,\n  DashboardObjectType as InternalDashboardObjectType,\n  DataType as InternalDataType,\n  DateRangeType as InternalDateRangeType,\n  DateStepPeriod as InternalDateStepPeriod,\n  DomainRestrictionType as InternalDomainRestrictionType,\n  ErrorCodes as InternalErrorCodes,\n  ExtensionContext as InternalExtensionsContext,\n  ExtensionMode as InternalExtensionsMode,\n  FieldAggregationType as InternalFieldAggregationType,\n  FieldRoleType as InternalFieldRoleType,\n  FilterType as InternalFilterType,\n  FilterUpdateType as InternalFilterUpdateType,\n  HierarchicalLevelSelectionState as InternalHierarchicalLevelSelectionState,\n  MarkType as InternalMarkType,\n  SheetType as InternalSheetType,\n} from '@tableau/api-internal-contract-js';\nimport { EnumConverter } from '../Utils/EnumConverter';\n\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\n/**\n * Maps enums used by the internal-api-contract to the enums used\n * in the external-api-contract, which developers code against.\n */\nexport class InternalToExternalEnumMappings {\n  public static extensionContext = new EnumConverter<InternalExtensionsContext, ExternalExtensionsContext>({\n    [InternalExtensionsContext.Desktop]: ExternalExtensionsContext.Desktop,\n    [InternalExtensionsContext.Server]: ExternalExtensionsContext.Server,\n  });\n\n  public static extensionMode = new EnumConverter<InternalExtensionsMode, ExternalExtensionsMode>({\n    [InternalExtensionsMode.Authoring]: ExternalExtensionsMode.Authoring,\n    [InternalExtensionsMode.Viewing]: ExternalExtensionsMode.Viewing,\n  });\n\n  public static columnType = new EnumConverter<InternalColumnType, ExternalColumnType>({\n    [InternalColumnType.Continuous]: ExternalColumnType.Continuous,\n    [InternalColumnType.Discrete]: ExternalColumnType.Discrete,\n  });\n\n  public static fieldAggregationType = new EnumConverter<InternalFieldAggregationType, ExternalFieldAggregationType>({\n    [InternalFieldAggregationType.Attr]: ExternalFieldAggregationType.Attr,\n    [InternalFieldAggregationType.Avg]: ExternalFieldAggregationType.Avg,\n    [InternalFieldAggregationType.Collect]: ExternalFieldAggregationType.Collect,\n    [InternalFieldAggregationType.Count]: ExternalFieldAggregationType.Count,\n    [InternalFieldAggregationType.Countd]: ExternalFieldAggregationType.Countd,\n    [InternalFieldAggregationType.Day]: ExternalFieldAggregationType.Day,\n    [InternalFieldAggregationType.End]: ExternalFieldAggregationType.End,\n    [InternalFieldAggregationType.Hour]: ExternalFieldAggregationType.Hour,\n    [InternalFieldAggregationType.InOut]: ExternalFieldAggregationType.InOut,\n    [InternalFieldAggregationType.Kurtosis]: ExternalFieldAggregationType.Kurtosis,\n    [InternalFieldAggregationType.Max]: ExternalFieldAggregationType.Max,\n    [InternalFieldAggregationType.Mdy]: ExternalFieldAggregationType.Mdy,\n    [InternalFieldAggregationType.Median]: ExternalFieldAggregationType.Median,\n    [InternalFieldAggregationType.Min]: ExternalFieldAggregationType.Min,\n    [InternalFieldAggregationType.Minute]: ExternalFieldAggregationType.Minute,\n    [InternalFieldAggregationType.MonthYear]: ExternalFieldAggregationType.MonthYear,\n    [InternalFieldAggregationType.None]: ExternalFieldAggregationType.None,\n    [InternalFieldAggregationType.Qtr]: ExternalFieldAggregationType.Qtr,\n    [InternalFieldAggregationType.Quart1]: ExternalFieldAggregationType.Quart1,\n    [InternalFieldAggregationType.Quart3]: ExternalFieldAggregationType.Quart3,\n    [InternalFieldAggregationType.Second]: ExternalFieldAggregationType.Second,\n    [InternalFieldAggregationType.Skewness]: ExternalFieldAggregationType.Skewness,\n    [InternalFieldAggregationType.Stdev]: ExternalFieldAggregationType.Stdev,\n    [InternalFieldAggregationType.Stdevp]: ExternalFieldAggregationType.Stdevp,\n    [InternalFieldAggregationType.Sum]: ExternalFieldAggregationType.Sum,\n    [InternalFieldAggregationType.TruncDay]: ExternalFieldAggregationType.TruncDay,\n    [InternalFieldAggregationType.TruncHour]: ExternalFieldAggregationType.TruncHour,\n    [InternalFieldAggregationType.TruncMinute]: ExternalFieldAggregationType.TruncMinute,\n    [InternalFieldAggregationType.TruncMonth]: ExternalFieldAggregationType.TruncMonth,\n    [InternalFieldAggregationType.TruncQtr]: ExternalFieldAggregationType.TruncQtr,\n    [InternalFieldAggregationType.TruncSecond]: ExternalFieldAggregationType.TruncSecond,\n    [InternalFieldAggregationType.TruncWeek]: ExternalFieldAggregationType.TruncWeek,\n    [InternalFieldAggregationType.TruncYear]: ExternalFieldAggregationType.TruncYear,\n    [InternalFieldAggregationType.User]: ExternalFieldAggregationType.User,\n    [InternalFieldAggregationType.Var]: ExternalFieldAggregationType.Var,\n    [InternalFieldAggregationType.Varp]: ExternalFieldAggregationType.Varp,\n    [InternalFieldAggregationType.Week]: ExternalFieldAggregationType.Week,\n    [InternalFieldAggregationType.Weekday]: ExternalFieldAggregationType.Weekday,\n    [InternalFieldAggregationType.Year]: ExternalFieldAggregationType.Year,\n  });\n\n  public static fieldRoleType = new EnumConverter<InternalFieldRoleType, ExternalFieldRoleType>({\n    [InternalFieldRoleType.Dimension]: ExternalFieldRoleType.Dimension,\n    [InternalFieldRoleType.Measure]: ExternalFieldRoleType.Measure,\n    [InternalFieldRoleType.Unknown]: ExternalFieldRoleType.Unknown,\n  });\n\n  public static sheetType = new EnumConverter<InternalSheetType, ExternalSheetType>({\n    [InternalSheetType.Dashboard]: ExternalSheetType.Dashboard,\n    [InternalSheetType.Story]: ExternalSheetType.Story,\n    [InternalSheetType.Worksheet]: ExternalSheetType.Worksheet,\n  });\n\n  public static dashboardObjectType = new EnumConverter<InternalDashboardObjectType, ExternalDashboardObjectType>({\n    [InternalDashboardObjectType.Extension]: ExternalDashboardObjectType.Extension,\n    [InternalDashboardObjectType.Blank]: ExternalDashboardObjectType.Blank,\n    [InternalDashboardObjectType.Image]: ExternalDashboardObjectType.Image,\n    [InternalDashboardObjectType.Legend]: ExternalDashboardObjectType.Legend,\n    [InternalDashboardObjectType.PageFilter]: ExternalDashboardObjectType.PageFilter,\n    [InternalDashboardObjectType.ParameterControl]: ExternalDashboardObjectType.ParameterControl,\n    [InternalDashboardObjectType.QuickFilter]: ExternalDashboardObjectType.QuickFilter,\n    [InternalDashboardObjectType.Text]: ExternalDashboardObjectType.Text,\n    [InternalDashboardObjectType.Title]: ExternalDashboardObjectType.Title,\n    [InternalDashboardObjectType.WebPage]: ExternalDashboardObjectType.WebPage,\n    [InternalDashboardObjectType.Worksheet]: ExternalDashboardObjectType.Worksheet,\n  });\n\n  public static dataType = new EnumConverter<InternalDataType, ExternalDataType>({\n    [InternalDataType.Bool]: ExternalDataType.Bool,\n    [InternalDataType.Date]: ExternalDataType.Date,\n    [InternalDataType.DateTime]: ExternalDataType.DateTime,\n    [InternalDataType.Float]: ExternalDataType.Float,\n    [InternalDataType.Int]: ExternalDataType.Int,\n    [InternalDataType.String]: ExternalDataType.String,\n  });\n\n  public static filterUpdateType = new EnumConverter<InternalFilterUpdateType, ExternalFilterUpdateType>({\n    [InternalFilterUpdateType.Add]: ExternalFilterUpdateType.Add,\n    [InternalFilterUpdateType.All]: ExternalFilterUpdateType.All,\n    [InternalFilterUpdateType.Remove]: ExternalFilterUpdateType.Remove,\n    [InternalFilterUpdateType.Replace]: ExternalFilterUpdateType.Replace,\n  });\n\n  public static allowableValues = new EnumConverter<InternalDomainRestrictionType, ExternalParameterValueType>({\n    [InternalDomainRestrictionType.All]: ExternalParameterValueType.All,\n    [InternalDomainRestrictionType.List]: ExternalParameterValueType.List,\n    [InternalDomainRestrictionType.Range]: ExternalParameterValueType.Range,\n  });\n\n  public static dateStepPeriod = new EnumConverter<InternalDateStepPeriod, ExternalDatePeriod>({\n    [InternalDateStepPeriod.Years]: ExternalDatePeriod.Years,\n    [InternalDateStepPeriod.Quarters]: ExternalDatePeriod.Quarters,\n    [InternalDateStepPeriod.Months]: ExternalDatePeriod.Months,\n    [InternalDateStepPeriod.Weeks]: ExternalDatePeriod.Weeks,\n    [InternalDateStepPeriod.Days]: ExternalDatePeriod.Days,\n    [InternalDateStepPeriod.Hours]: ExternalDatePeriod.Hours,\n    [InternalDateStepPeriod.Minutes]: ExternalDatePeriod.Minutes,\n    [InternalDateStepPeriod.Seconds]: ExternalDatePeriod.Seconds,\n  });\n\n  public static dateRangeType = new EnumConverter<InternalDateRangeType, ExternalDateRangeType>({\n    [InternalDateRangeType.Current]: ExternalDateRangeType.Current,\n    [InternalDateRangeType.Last]: ExternalDateRangeType.Last,\n    [InternalDateRangeType.LastN]: ExternalDateRangeType.LastN,\n    [InternalDateRangeType.Next]: ExternalDateRangeType.Next,\n    [InternalDateRangeType.NextN]: ExternalDateRangeType.NextN,\n    [InternalDateRangeType.ToDate]: ExternalDateRangeType.ToDate,\n  });\n\n  public static errorCode = new EnumConverter<InternalErrorCodes, ExternalErrorCodes>(\n    {\n      [InternalErrorCodes.INITIALIZATION_ERROR]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.INTERNAL_ERROR]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.MISSING_ENUM_MAPPING]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.MISSING_PARAMETER]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.PERMISSION_DENIED]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.PRES_MODEL_PARSING_ERROR]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.UNKNOWN_VERB_ID]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.VERSION_NOT_CONFIGURED]: ExternalErrorCodes.APINotInitialized,\n      [InternalErrorCodes.VISIBILITY_ERROR]: ExternalErrorCodes.VisibilityError,\n    },\n    ExternalErrorCodes.InternalError,\n  );\n\n  public static filterType = new EnumConverter<InternalFilterType, ExternalFilterType>({\n    [InternalFilterType.Categorical]: ExternalFilterType.Categorical,\n    [InternalFilterType.Range]: ExternalFilterType.Range,\n    [InternalFilterType.RelativeDate]: ExternalFilterType.RelativeDate,\n    [InternalFilterType.Hierarchical]: ExternalFilterType.Hierarchical,\n  });\n\n  public static classNameKey = new EnumConverter<InternalClassNameKey, ExternalClassNameKey>({\n    [InternalClassNameKey.DashboardTitle]: ExternalClassNameKey.DashboardTitle,\n    [InternalClassNameKey.StoryTitle]: ExternalClassNameKey.StoryTitle,\n    [InternalClassNameKey.Tooltip]: ExternalClassNameKey.Tooltip,\n    [InternalClassNameKey.Worksheet]: ExternalClassNameKey.Worksheet,\n    [InternalClassNameKey.WorksheetTitle]: ExternalClassNameKey.WorksheetTitle,\n    // Temporary until we fix 1317266 - Platform hasn't been updated currently because near branch is closed\n    ['dashboard-title']: ExternalClassNameKey.DashboardTitle,\n    ['story-title']: ExternalClassNameKey.StoryTitle,\n    ['tooltip']: ExternalClassNameKey.Tooltip,\n    ['worksheet']: ExternalClassNameKey.Worksheet,\n    ['worksheet-title']: ExternalClassNameKey.WorksheetTitle,\n  });\n\n  public static hierarchicalLevelSelectionState = new EnumConverter<\n    InternalHierarchicalLevelSelectionState,\n    ExternalHierarchicalLevelSelectionState\n  >({\n    [InternalHierarchicalLevelSelectionState.AllSelected]: ExternalHierarchicalLevelSelectionState.AllSelected,\n    [InternalHierarchicalLevelSelectionState.NoneSelected]: ExternalHierarchicalLevelSelectionState.NoneSelected,\n    [InternalHierarchicalLevelSelectionState.SomeSelected]: ExternalHierarchicalLevelSelectionState.SomeSelected,\n    [InternalHierarchicalLevelSelectionState.UnknownSelected]: ExternalHierarchicalLevelSelectionState.UnknownSelected,\n  });\n\n  public static annotationType = new EnumConverter<InternalAnnotationType, ExternalAnnotationType>({\n    [InternalAnnotationType.Area]: ExternalAnnotationType.Area,\n    [InternalAnnotationType.Mark]: ExternalAnnotationType.Mark,\n    [InternalAnnotationType.Point]: ExternalAnnotationType.Point,\n  });\n\n  public static markType = new EnumConverter<InternalMarkType, ExternalMarkType>({\n    [InternalMarkType.Area]: ExternalMarkType.Area,\n    [InternalMarkType.Bar]: ExternalMarkType.Bar,\n    [InternalMarkType.Circle]: ExternalMarkType.Circle,\n    [InternalMarkType.GanttBar]: ExternalMarkType.GanttBar,\n    [InternalMarkType.Heatmap]: ExternalMarkType.Heatmap,\n    [InternalMarkType.Line]: ExternalMarkType.Line,\n    [InternalMarkType.Map]: ExternalMarkType.Map,\n    [InternalMarkType.Pie]: ExternalMarkType.Pie,\n    [InternalMarkType.Polygon]: ExternalMarkType.Polygon,\n    [InternalMarkType.Shape]: ExternalMarkType.Shape,\n    [InternalMarkType.Square]: ExternalMarkType.Square,\n    [InternalMarkType.Text]: ExternalMarkType.Text,\n    [InternalMarkType.VizExtension]: ExternalMarkType.VizExtension,\n  });\n}\n/* tslint:enable:typedef */\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, TableauEventType } from '@tableau/api-external-contract-js';\nimport { SingleEventManager } from './SingleEventManager';\nimport { TableauError } from './TableauError';\n\n/**\n * Class designed to register and unregister handlers from a user. Only those events\n * which are added via AddNewEventType will be supported by this instance\n */\nexport class EventListenerManager implements Contract.EventListenerManager {\n  private _eventListenerManagers: { [tableauEventType: string]: SingleEventManager };\n\n  public constructor() {\n    this._eventListenerManagers = {};\n  }\n\n  public addEventListener(eventType: TableauEventType, handler: Contract.TableauEventHandlerFn): Contract.TableauEventUnregisterFn {\n    if (!this._eventListenerManagers.hasOwnProperty(eventType)) {\n      throw new TableauError(ErrorCodes.UnsupportedEventName, `Cannot add event, unsupported event type: ${eventType}`);\n    }\n\n    return this._eventListenerManagers[eventType].addEventListener(handler);\n  }\n\n  public removeEventListener(eventType: TableauEventType, handler: Contract.TableauEventHandlerFn): boolean {\n    if (!this._eventListenerManagers.hasOwnProperty(eventType)) {\n      throw new TableauError(ErrorCodes.UnsupportedEventName, `Cannot remove event, unsupported event type: ${eventType}`);\n    }\n\n    return this._eventListenerManagers[eventType].removeEventListener(handler);\n  }\n\n  protected addNewEventType(eventManager: SingleEventManager): void {\n    this._eventListenerManagers[eventManager.eventType] = eventManager;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ColumnType, DataType, FieldAggregationType, FieldRoleType } from '@tableau/api-external-contract-js';\nimport { FieldImpl } from './Impl/FieldImpl';\nimport { ErrorHelpers } from './Utils/ErrorHelpers';\n\nexport class Field implements Contract.Field {\n  public constructor(private _fieldImpl: FieldImpl) {}\n\n  public get name(): string {\n    return this._fieldImpl.name;\n  }\n\n  public get id(): string {\n    return this._fieldImpl.id;\n  }\n\n  public get description(): string | undefined {\n    return this._fieldImpl.description;\n  }\n\n  public get dataType(): DataType {\n    return this._fieldImpl.dataType;\n  }\n\n  public get aggregation(): FieldAggregationType {\n    return this._fieldImpl.aggregation;\n  }\n\n  public get dataSource(): Contract.DataSource {\n    return this._fieldImpl.dataSource;\n  }\n\n  public get role(): FieldRoleType {\n    return this._fieldImpl.role;\n  }\n\n  public get isHidden(): boolean {\n    return this._fieldImpl.isHidden;\n  }\n\n  public get isGenerated(): boolean {\n    return this._fieldImpl.isGenerated;\n  }\n\n  public get isCalculatedField(): boolean {\n    return this._fieldImpl.isCalculatedField;\n  }\n\n  public get columnType(): ColumnType {\n    throw ErrorHelpers.apiNotImplemented('Field.columnType');\n  }\n\n  public get isCombinedField(): boolean {\n    return this._fieldImpl.isCombinedField;\n  }\n\n  public get isPresentOnPublishedDatasource(): boolean {\n    return this._fieldImpl.isPresentOnPublishedDatasource;\n  }\n}\n","import { CustomViewModel } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, ServiceNames, VizService } from '../../ApiShared';\nexport class CustomViewImpl {\n  private _luid: string;\n  private _name: string;\n  private _shared: boolean;\n  private _isDefault: boolean;\n  private _ownerName: string;\n  private _url: string;\n  public constructor(customViewModel: CustomViewModel, private _registryId: number) {\n    this._luid = customViewModel.luid;\n    this._name = customViewModel.name;\n    this._shared = customViewModel.shared;\n    this._isDefault = customViewModel.isDefault;\n    this._ownerName = customViewModel.owner.userFriendlyName;\n    this._url = customViewModel.url;\n  }\n\n  public get luid() {\n    return this._luid;\n  }\n\n  public get name() {\n    return this._name;\n  }\n\n  public set name(name: string) {\n    this._name = name;\n  }\n\n  public get shared() {\n    return this._shared;\n  }\n\n  public set shared(shared: boolean) {\n    this._shared = shared;\n  }\n\n  public get isDefault() {\n    return this._isDefault;\n  }\n\n  public set isDefault(isDefault: boolean) {\n    this._isDefault = isDefault;\n  }\n\n  public get ownerName() {\n    return this._ownerName;\n  }\n\n  public get url() {\n    return this._url;\n  }\n\n  public saveAsync(): Promise<CustomViewImpl> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<VizService>(ServiceNames.Viz);\n    return service.saveAsync(this);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  DashboardLayoutChange,\n  DashboardLayoutChangeDetails,\n  ErrorCodes,\n  SharedErrorCodes,\n  SheetType,\n} from '@tableau/api-external-contract-js';\nimport { DashboardObjectType, DashboardZone, SheetPath, VisualId } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\nimport { Point } from '../Point';\nimport { AnimationService } from '../Services/AnimationService';\nimport { FilterService } from '../Services/FilterService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { ZoneService } from '../Services/ZoneService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { DashboardObjectImpl } from './DashboardObjectImpl';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryPointImpl } from './StoryPointImpl';\nimport { WorksheetImpl } from './WorksheetImpl';\n\nexport class DashboardImpl extends SheetImpl {\n  private _worksheetsImpl: Array<WorksheetImpl>;\n  private _objects: Array<DashboardObjectImpl>;\n  private zoneMap: Map<number, DashboardObjectImpl>;\n\n  public constructor(\n    _sheetInfo: SheetInfoImpl,\n    private _zones: Array<DashboardZone>,\n    private _sheetPath: SheetPath,\n    _registryId: number,\n    private _parentStoryPointImpl: StoryPointImpl | null,\n    private _activeDashboardObjectId: number = 0,\n  ) {\n    super(_sheetInfo, _registryId);\n  }\n\n  public get worksheetsImpl(): Array<WorksheetImpl> {\n    return this._worksheetsImpl;\n  }\n\n  public get objects(): Array<DashboardObjectImpl> {\n    return this._objects;\n  }\n\n  public get parentStoryPoint(): StoryPointImpl | null {\n    return this._parentStoryPointImpl;\n  }\n\n  public get activeDashboardObjectId(): number {\n    return this._activeDashboardObjectId;\n  }\n\n  public get activeDashboardName(): string {\n    return this._sheetPath.sheetName;\n  }\n\n  public initializeWithPublicInterfaces(): void {\n    this._worksheetsImpl = new Array<WorksheetImpl>();\n    this._objects = new Array<DashboardObjectImpl>();\n    this.zoneMap = new Map<number, DashboardObjectImpl>();\n\n    // Process all the zones which are contained in this dashboard\n    for (const zone of this._zones) {\n      let worksheetImpl: WorksheetImpl | undefined = undefined;\n\n      const zoneSize: Contract.Size = { width: zone.width, height: zone.height };\n      // As the dashboard is active, all other zones in the dashboard are inactive.\n      const isActive = false;\n\n      if (zone.zoneType === DashboardObjectType.Worksheet) {\n        let worksheetName = '';\n        let worksheetUrl = '';\n        let isHidden = false;\n        if (zone.sheetInfo) {\n          // zone.sheetInfo was not initialized prior to internal-contract 1.6.0\n          worksheetName = zone.sheetInfo.name;\n\n          // worksheetUrl & isHidden is for Embedding only\n          worksheetUrl = zone.sheetInfo.url || '';\n          // If there's a url, then it's not hidden\n          isHidden = worksheetUrl === '';\n        } else {\n          worksheetName = zone.name;\n        }\n        // Indexes, isActive and some more properties in sheetInfoImpl are embedding specific.\n        // But we init them for both extensions and embedding as the Models will only use what is relevant.\n        const sheetInfoImpl = new SheetInfoImpl(\n          worksheetName,\n          SheetType.Worksheet,\n          zoneSize,\n          this._worksheetsImpl.length,\n          isActive,\n          isHidden,\n          worksheetUrl,\n        );\n\n        const vizId: VisualId = {\n          worksheet: worksheetName,\n          dashboard: this._sheetInfoImpl.name,\n          storyboard: this._sheetPath.storyboard,\n          flipboardZoneID: this._sheetPath.flipboardZoneID,\n          storyPointID: this._sheetPath.storyPointID,\n        };\n\n        worksheetImpl = new WorksheetImpl(sheetInfoImpl, this._registryId, vizId, this, this._parentStoryPointImpl);\n        this._worksheetsImpl.push(worksheetImpl);\n      }\n\n      const zonePoint = new Point(zone.x, zone.y);\n\n      const dashboardObjectImpl = new DashboardObjectImpl(\n        this,\n        InternalToExternalEnumMappings.dashboardObjectType.convert(zone.zoneType),\n        zonePoint,\n        zoneSize,\n        worksheetImpl,\n        zone.name,\n        zone.isFloating !== undefined ? zone.isFloating : false, // before 1.6.0 we didn't have isFloating, so we assume false\n        zone.isVisible !== undefined ? zone.isVisible : true, // before 1.6.0 we didn't have isVisible, so we assume true\n        zone.zoneId,\n      );\n\n      this._objects.push(dashboardObjectImpl);\n      this.zoneMap.set(zone.zoneId, dashboardObjectImpl);\n    }\n  }\n\n  public setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap: Contract.DashboardObjectVisibilityMap | object): Promise<void> {\n    const zoneService = ApiServiceRegistry.get(this._registryId).getService<ZoneService>(ServiceNames.Zone);\n\n    return zoneService.setVisibilityAsync(/*Dashboard Name*/ this.name, this.zoneMap, dashboardObjectVisibilityMap);\n  }\n\n  public getDashboardObjectById(dashboardObjectId: number): DashboardObjectImpl | undefined {\n    return this.zoneMap.get(dashboardObjectId);\n  }\n\n  public updateZones(newZones: Array<DashboardZone>, newActiveZoneId = 0, newActiveDashboardName = ''): DashboardLayoutChangeDetails {\n    // getting previous dashboard objects, active zone ID and active dashboard name\n    const oldDashboardObjects = this._objects;\n    const oldZoneMap = this.zoneMap;\n    const oldActiveZoneId = this._activeDashboardObjectId;\n    const oldActiveDashboardName = this._sheetPath.sheetName;\n    // updating zones and reinitializing instance variables\n    this._zones = newZones;\n    this._activeDashboardObjectId = newActiveZoneId;\n    this._sheetPath.sheetName = newActiveDashboardName;\n    this._sheetInfoImpl.name = newActiveDashboardName;\n    this.initializeWithPublicInterfaces();\n    // getting new dashboard objects\n    const newDashboardObjects = this._objects;\n    const newZoneMap = this.zoneMap;\n    // initializing map for changes\n    const zoneChanges: DashboardLayoutChangeDetails = new Map();\n\n    // comparing old dashboard objects with new ones\n    oldDashboardObjects.forEach((oldObject) => {\n      const oldId: number = oldObject.id;\n\n      // checking if zone was removed\n      if (!newZoneMap.has(oldId)) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.Removed);\n        return;\n      }\n\n      const newObject = newZoneMap.get(oldId);\n      if (oldObject.isFloating !== newObject!.isFloating) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.IsFloatingChanged);\n      }\n\n      if (oldObject.isVisible !== newObject!.isVisible) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.IsVisibleChanged);\n      }\n\n      if (oldObject.name !== newObject!.name) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.NameChanged);\n      }\n\n      if (oldObject.position.x !== newObject!.position.x || oldObject.position.y !== newObject!.position.y) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.PositionChanged);\n      }\n\n      if (oldObject.size.width !== newObject!.size.width || oldObject.size.height !== newObject!.size.height) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.SizeChanged);\n      }\n    });\n\n    // Checking for any added zones\n    newDashboardObjects.forEach((newObject) => {\n      if (!oldZoneMap.has(newObject.id)) {\n        this.addChange(newObject.id, zoneChanges, DashboardLayoutChange.Added);\n      }\n    });\n\n    // Checking if zone selection has changed\n    if (oldActiveZoneId !== newActiveZoneId) {\n      if (newActiveZoneId !== 0) {\n        this.addChange(newActiveZoneId, zoneChanges, DashboardLayoutChange.Selected);\n      }\n      if (oldActiveZoneId !== 0) {\n        this.addChange(oldActiveZoneId, zoneChanges, DashboardLayoutChange.Deselected);\n      }\n    }\n\n    // Checking if switched to another dashboard\n    if (oldActiveDashboardName !== newActiveDashboardName) {\n      this.addChange(0, zoneChanges, DashboardLayoutChange.DashboardChanged);\n    }\n\n    return zoneChanges;\n  }\n\n  private addChange(zoneId: number, zoneChanges: DashboardLayoutChangeDetails, change: DashboardLayoutChange): void {\n    if (!zoneChanges.has(zoneId)) {\n      zoneChanges.set(zoneId, []);\n    }\n\n    zoneChanges.get(zoneId)!.push(change);\n  }\n\n  public moveAndResizeDashboardObjectsAsync(\n    dashboardObjectPositionAndSizeUpdateArray: Contract.DashboardObjectPositionAndSizeUpdateArray,\n  ): Promise<void> {\n    const zoneService = ApiServiceRegistry.get(this._registryId).getService<ZoneService>(ServiceNames.Zone);\n\n    return zoneService.moveAndResizeAsync(/*Dashboard Name*/ this.name, this.zoneMap, dashboardObjectPositionAndSizeUpdateArray);\n  }\n\n  public replayAnimationAsync(replaySpeed: Contract.ReplaySpeedType): Promise<void> {\n    const animationService = ApiServiceRegistry.get(this._registryId).getService<AnimationService>(ServiceNames.Animation);\n\n    return animationService.replayAsync(replaySpeed);\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    this.verifyActiveSheetOrEmbeddedInActiveStoryPoint();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getDashboardFiltersAsync();\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    ErrorHelpers.verifyEnumValue<Contract.FilterUpdateType>(updateType, Contract.FilterUpdateType, 'FilterUpdateType');\n    ErrorHelpers.verifyStringParameter(fieldName, 'fieldName');\n    if (!Array.isArray(values)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'values parameter for applyDashboardFilterAsync must be an array');\n    }\n    this.verifyActiveSheetOrEmbeddedInActiveStoryPoint();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyDashboardFilterAsync(fieldName, values, updateType, options);\n  }\n\n  // @W-12986439: remove once initializeWithPublicInterfaces is moved to the constructor for this class\n  // This method only exists since worksheetsImpl can be undefined, but we need the worksheet names in the Export APIs\n  public getWorksheetNamesFromZones(): Array<string> {\n    const worksheetNames: string[] = [];\n    for (const zone of this._zones) {\n      if (zone.zoneType !== DashboardObjectType.Worksheet) {\n        continue;\n      }\n      // zone.sheetInfo was not initialized prior to internal-contract 1.6.0\n      const worksheetName = zone.sheetInfo ? zone.sheetInfo.name : zone.name;\n      worksheetNames.push(worksheetName);\n    }\n\n    return worksheetNames;\n  }\n\n  private verifyActiveSheetOrEmbeddedInActiveStoryPoint() {\n    const isRootAndActiveDashboard = this.active;\n    const isWithinActiveStoryPoint = this.parentStoryPoint != null && this.parentStoryPoint.active;\n    if (!isRootAndActiveDashboard && !isWithinActiveStoryPoint) {\n      throw new TableauError(SharedErrorCodes.NotActiveSheet, 'Operation not allowed on non-active sheet');\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardObjectType } from '@tableau/api-external-contract-js';\nimport { DashboardImpl } from './DashboardImpl';\nimport { WorksheetImpl } from './WorksheetImpl';\n\n/**\n * Implementation of the dashboard objects - the zones in a dashboard.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class DashboardObjectImpl {\n  public constructor(\n    private _dashboardImpl: DashboardImpl,\n    private _type: DashboardObjectType,\n    private _position: Contract.Point,\n    private _size: Contract.Size,\n    private _worksheetImpl: WorksheetImpl | undefined,\n    private _name: string,\n    private _isFloating: boolean,\n    private _isVisible: boolean,\n    private _id: number,\n  ) {}\n\n  public get dashboardImpl(): DashboardImpl {\n    return this._dashboardImpl;\n  }\n\n  public get type(): DashboardObjectType {\n    return this._type;\n  }\n\n  public get position(): Contract.Point {\n    return this._position;\n  }\n\n  public get size(): Contract.Size {\n    return this._size;\n  }\n\n  public get worksheetImpl(): WorksheetImpl | undefined {\n    return this._worksheetImpl;\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get isFloating(): boolean {\n    return this._isFloating;\n  }\n\n  public get isVisible(): boolean {\n    return this._isVisible;\n  }\n\n  public get id(): number {\n    return this._id;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { IncludeDataValuesOption } from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport { ConnectionSummary } from '../ConnectionSummary';\nimport { Field } from '../Field';\nimport { LogicalTable } from '../LogicalTable';\nimport { DataSourceService } from '../Services/DataSourceService';\nimport { GetDataService } from '../Services/GetDataService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { TableSummary } from '../TableSummary';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { FieldImpl } from './FieldImpl';\n\nexport class DataSourceImpl {\n  private _fields: Array<Field>;\n\n  public constructor(private _dataSourceInfo: InternalContract.DataSource, private _registryId: number) {\n    this._fields = _dataSourceInfo.fields.map((fieldModel) => {\n      const fieldImpl = new FieldImpl(fieldModel, this);\n      return new Field(fieldImpl);\n    });\n  }\n\n  public get name(): string {\n    return this._dataSourceInfo.name;\n  }\n\n  public get id(): string {\n    return this._dataSourceInfo.id;\n  }\n\n  public get extractUpdateTime(): string | undefined {\n    return this._dataSourceInfo.extractUpdateTime;\n  }\n\n  public get fields(): Array<Contract.Field> {\n    return this._fields;\n  }\n\n  public get isExtract(): boolean {\n    return this._dataSourceInfo.isExtract;\n  }\n\n  public get isPublished(): boolean | undefined {\n    return this._dataSourceInfo.isPublished;\n  }\n\n  public publishedUrl(): string | undefined {\n    return this._dataSourceInfo.publishedUrl;\n  }\n\n  public getMaxPageRowLimit(): number {\n    return 10000;\n  }\n\n  public refreshAsync(): Promise<void> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.refreshAsync(this._dataSourceInfo.id);\n  }\n\n  public getConnectionSummariesAsync(): Promise<Contract.ConnectionSummary[]> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.getConnectionSummariesAsync(this._dataSourceInfo.id).then<Contract.ConnectionSummary[]>((summaries) => {\n      return summaries.map((summary) => new ConnectionSummary(summary));\n    });\n  }\n\n  public getActiveTablesAsync(): Promise<Array<Contract.TableSummary>> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.getActiveTablesAsync(this._dataSourceInfo.id).then<Array<Contract.TableSummary>>((tableInfos) => {\n      return tableInfos.map((tableInfo) => new TableSummary(tableInfo));\n    });\n  }\n\n  public getUnderlyingDataAsync(options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    const getDataService = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return getDataService.getDataSourceDataAsync(\n      this.id,\n      !!options.ignoreAliases,\n      options.maxRows || 0, // 0 and [] are defaults\n      options.columnsToInclude || [],\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getLogicalTableDataAsync(logicalTableId: string, options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    const getDataService = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return getDataService.getLogicalTableDataAsync(\n      this.id,\n      logicalTableId,\n      !!options.ignoreAliases,\n      options.maxRows || 0, // 0 and [] are defaults\n      options.columnsToInclude || [],\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getLogicalTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount?: number,\n    options?: Contract.DataSourceUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    const getDataService = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return getDataService.getLogicalTableDataReaderAsync(\n      this.id,\n      logicalTableId,\n      pageRowCount || this.getMaxPageRowLimit(),\n      !!options.ignoreAliases,\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public initializeWithPublicInterfaces(dataSource: Contract.DataSource): void {\n    ErrorHelpers.verifyInternalValue(dataSource, 'dataSource');\n\n    this._fields = this._dataSourceInfo.fields.map((fieldModel) => {\n      const fieldImpl = new FieldImpl(fieldModel, dataSource);\n      return new Field(fieldImpl);\n    });\n  }\n\n  public getLogicalTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.getLogicalTablesAsync(this.id).then<Array<Contract.LogicalTable>>((logicalTableInfos) => {\n      return logicalTableInfos.map((logicalTableInfo) => new LogicalTable(logicalTableInfo));\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataType, FieldAggregationType, FieldRoleType } from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\n\nexport class FieldImpl {\n  public constructor(private _fieldInfo: InternalContract.Field, private _parentDataSource?: Contract.DataSource) {}\n\n  public get name(): string {\n    return this._fieldInfo.name;\n  }\n\n  public get id(): string {\n    return this._fieldInfo.id;\n  }\n\n  public get description(): string | undefined {\n    return this._fieldInfo.description;\n  }\n\n  public get dataType(): DataType {\n    return this._fieldInfo.dataType ?? DataType.Unknown;\n  }\n\n  public get aggregation(): FieldAggregationType {\n    return InternalToExternalEnumMappings.fieldAggregationType.convert(this._fieldInfo.aggregation);\n  }\n\n  public get dataSource(): Contract.DataSource {\n    if (!this._parentDataSource)\n      throw new Error(\n        `Data source information is not available for this field. Please use getFieldAsync method to get field's data source information`,\n      );\n    return this._parentDataSource;\n  }\n\n  public get role(): FieldRoleType {\n    return InternalToExternalEnumMappings.fieldRoleType.convert(this._fieldInfo.role);\n  }\n\n  public get isHidden(): boolean {\n    return this._fieldInfo.isHidden;\n  }\n\n  public get isGenerated(): boolean {\n    return this._fieldInfo.isGenerated;\n  }\n\n  public get isCalculatedField(): boolean {\n    return this._fieldInfo.isCalculatedField;\n  }\n\n  public get isCombinedField(): boolean {\n    return this._fieldInfo.isCombinedField;\n  }\n\n  public get isPresentOnPublishedDatasource(): boolean {\n    return this._fieldInfo.isPresentOnPublishedDatasource;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataType, ParameterValueType, PeriodType } from '@tableau/api-external-contract-js';\nimport { ParameterInfo } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\nimport { DataValue } from '../Models/GetDataModels';\nimport { ParametersService } from '../Services/ParametersService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { DataValueFactory } from '../Utils/DataValueFactory';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { Param } from '../Utils/Param';\n\nexport class ParameterImpl {\n  private _allowableValues: Contract.ParameterDomainRestriction;\n  private _globalFieldName: string;\n  private _parameterInfo: ParameterInfo;\n\n  public constructor(parameterInfo: ParameterInfo, private _registryId: number) {\n    this.setParameterInfo(parameterInfo);\n  }\n\n  public get name(): string {\n    return this._parameterInfo.name;\n  }\n\n  public get currentValue(): DataValue {\n    return DataValueFactory.MakeParameterDataValue(this._parameterInfo.currentValue, this._parameterInfo.dataType);\n  }\n\n  public get dataType(): DataType {\n    return InternalToExternalEnumMappings.dataType.convert(this._parameterInfo.dataType);\n  }\n\n  public get id(): string {\n    return this._globalFieldName;\n  }\n\n  public get allowableValues(): Contract.ParameterDomainRestriction {\n    return this._allowableValues;\n  }\n\n  public changeValueAsync(newValue: string | number | boolean | Date): Promise<DataValue> {\n    ErrorHelpers.verifyParameter(newValue, 'newValue');\n\n    const coercedValue = Param.serializeParameterValue(newValue);\n    const parametersService = ApiServiceRegistry.get(this._registryId).getService<ParametersService>(ServiceNames.Parameters);\n    return parametersService.changeParameterValueAsync(this._globalFieldName, coercedValue).then((parameterInfo) => {\n      this.setParameterInfo(parameterInfo);\n      return this.currentValue;\n    });\n  }\n\n  private setParameterInfo(parameterInfo: ParameterInfo): void {\n    this._parameterInfo = parameterInfo;\n    this._globalFieldName = parameterInfo.fieldName;\n\n    const type = InternalToExternalEnumMappings.allowableValues.convert(parameterInfo.allowableValuesType);\n    let listValues: Array<DataValue> | undefined;\n    let minValue: DataValue | undefined;\n    let maxValue: DataValue | undefined;\n    let stepSize: number | undefined;\n    let dateStepPeriod: PeriodType | undefined;\n\n    if (type === ParameterValueType.List) {\n      const values = parameterInfo.allowableValues || [];\n      listValues = values.map((val) => DataValueFactory.MakeParameterDataValue(val, parameterInfo.dataType));\n    } else if (type === ParameterValueType.Range) {\n      minValue = parameterInfo.minValue && DataValueFactory.MakeParameterDataValue(parameterInfo.minValue, parameterInfo.dataType);\n      maxValue = parameterInfo.maxValue && DataValueFactory.MakeParameterDataValue(parameterInfo.maxValue, parameterInfo.dataType);\n      stepSize = parameterInfo.stepSize;\n      dateStepPeriod = parameterInfo.dateStepPeriod && InternalToExternalEnumMappings.dateStepPeriod.convert(parameterInfo.dateStepPeriod);\n    }\n\n    this._allowableValues = {\n      type: type,\n      allowableValues: listValues,\n      minValue: minValue,\n      maxValue: maxValue,\n      stepSize: stepSize,\n      dateStepPeriod: dateStepPeriod,\n    };\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { SheetPath } from '@tableau/api-internal-contract-js';\nimport { ClientInfoService } from '../Services/ClientInfoService';\nimport { ParametersService } from '../Services/ParametersService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { SizeService } from '../Services/SizeService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { Param } from '../Utils/Param';\nimport { SheetUtils } from '../Utils/SheetUtils';\nimport { ParameterImpl } from './ParameterImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\n\ninterface PartialSheetSize {\n  /**\n   * Contains an enumeration value of one of the following: AUTOMATIC, EXACTLY, RANGE, ATLEAST, and ATMOST.\n   */\n  readonly behavior: Contract.SheetSizeBehavior;\n\n  /**\n   *  This is only defined when behavior is EXACTLY, RANGE, or ATLEAST.\n   */\n  readonly minSize?: Partial<Contract.Size>;\n\n  /**\n   *  This is only defined when behavior is EXACTLY, RANGE or ATMOST.\n   */\n  readonly maxSize?: Partial<Contract.Size>;\n}\n\nexport class SheetImpl {\n  public constructor(protected _sheetInfoImpl: SheetInfoImpl, protected _registryId: number) {}\n\n  public get name(): string {\n    return this._sheetInfoImpl.name;\n  }\n\n  public get sheetType(): Contract.SheetType {\n    return this._sheetInfoImpl.sheetType;\n  }\n\n  public get sheetPath(): SheetPath {\n    return this._sheetInfoImpl.sheetPath;\n  }\n\n  public get size(): Contract.Size | Contract.SheetSize {\n    return this._sheetInfoImpl.sheetSize;\n  }\n\n  public get hidden(): boolean {\n    if (this._sheetInfoImpl.isHidden !== undefined) {\n      return this._sheetInfoImpl.isHidden;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `isHidden not implemented`);\n  }\n\n  public get active(): boolean {\n    if (this._sheetInfoImpl.isActive !== undefined) {\n      return this._sheetInfoImpl.isActive;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `active not implemented`);\n  }\n\n  public set active(active: boolean) {\n    if (this._sheetInfoImpl.isActive !== undefined) {\n      this._sheetInfoImpl.active = active;\n    }\n  }\n\n  public get index(): number {\n    if (this._sheetInfoImpl.index !== undefined) {\n      return this._sheetInfoImpl.index;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `index not implemented`);\n  }\n\n  public get url(): string {\n    if (this._sheetInfoImpl.url !== undefined) {\n      return this._sheetInfoImpl.url;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `url not implemented`);\n  }\n\n  private getSheetSize(): Contract.SheetSize {\n    if (!SheetUtils.isValidSheetSize(this.size)) {\n      throw new TableauError(Contract.EmbeddingErrorCodes.InternalError, 'size is not of type SheetSize');\n    }\n\n    return this.size;\n  }\n\n  public findParameterAsync(parameterName: string): Promise<ParameterImpl | undefined> {\n    ErrorHelpers.verifyParameter(parameterName, 'parameterName');\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ParametersService>(ServiceNames.Parameters);\n    return service.findParameterByNameAsync(parameterName);\n  }\n\n  public getParametersAsync(): Promise<Array<ParameterImpl>> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<ParametersService>(ServiceNames.Parameters);\n    return service.getParametersForSheetAsync(this.sheetPath);\n  }\n\n  public changeSizeAsync(newSize: Contract.SheetSize): Promise<Contract.SheetSize> {\n    const invalidSizeError = new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Invalid sheet size parameter');\n    if (!newSize || !newSize.behavior) {\n      throw invalidSizeError;\n    }\n\n    const partialSheetSize = this.normalizeSheetSize(newSize);\n\n    const isAutomatic = partialSheetSize.behavior === Contract.SheetSizeBehavior.Automatic;\n    if (!isAutomatic && !partialSheetSize.minSize && !partialSheetSize.maxSize) {\n      throw invalidSizeError;\n    }\n\n    if (!isAutomatic && this.sheetType === Contract.SheetType.Worksheet) {\n      throw new TableauError(\n        Contract.EmbeddingErrorCodes.InvalidSizeBehaviorOnWorksheet,\n        'Only SheetSizeBehavior.Automatic is allowed on Worksheets',\n      );\n    }\n\n    if (isAutomatic && this.getSheetSize().behavior === partialSheetSize.behavior) {\n      return Promise.resolve(newSize);\n    }\n\n    const processedNewSize = this.processNewSize(partialSheetSize);\n\n    const sizeService = ApiServiceRegistry.get(this._registryId).getService<SizeService>(ServiceNames.Size);\n    return sizeService.changeSizeAsync(this.name, processedNewSize).then(() => {\n      const clientInfoService = ApiServiceRegistry.get(this._registryId).getService<ClientInfoService>(ServiceNames.ClientInfo);\n\n      return clientInfoService.getClientInfoAsync().then((bootstrapInfo) => {\n        const sheet = bootstrapInfo.publishedSheets.find((s) => s.name === this.name);\n        if (!sheet) {\n          throw new TableauError(Contract.SharedErrorCodes.InternalError, `Can't find sheet with name ${this.name}`);\n        }\n\n        const sheetSize = SheetUtils.getSheetSizeFromSizeConstraints(sheet.sizeConstraint);\n        this._sheetInfoImpl.sheetSize = sheetSize;\n\n        return sheetSize;\n      });\n    });\n  }\n\n  private normalizeSheetSize(newSize: Contract.SheetSize): PartialSheetSize {\n    const { behavior } = newSize;\n\n    ErrorHelpers.verifyEnumValue<Contract.SheetSizeBehavior>(behavior, Contract.SheetSizeBehavior, 'SheetSizeBehavior');\n\n    const minSize = SheetImpl.parseDimensions(newSize.minSize);\n    const maxSize = SheetImpl.parseDimensions(newSize.maxSize);\n\n    return { behavior, minSize, maxSize };\n  }\n\n  private processNewSize(newSize: PartialSheetSize): Contract.SheetSize {\n    const { behavior, minSize: minSizeMaybe, maxSize: maxSizeMaybe } = newSize;\n\n    const hasMinWidth = !Param.isNullOrUndefined(minSizeMaybe?.width);\n    const hasMinHeight = !Param.isNullOrUndefined(minSizeMaybe?.height);\n    const hasMaxWidth = !Param.isNullOrUndefined(maxSizeMaybe?.width);\n    const hasMaxHeight = !Param.isNullOrUndefined(maxSizeMaybe?.height);\n    const hasValidMinSize = hasMinWidth && hasMinHeight;\n    const hasValidMaxSize = hasMaxWidth && hasMaxHeight;\n\n    switch (behavior) {\n      case Contract.SheetSizeBehavior.Automatic: {\n        return { behavior };\n      }\n\n      case Contract.SheetSizeBehavior.AtMost: {\n        if (!maxSizeMaybe || !hasValidMaxSize) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.MissingMaxSize, 'Missing maxSize for SheetSizeBehavior.AtMost');\n        }\n\n        const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n        if (maxSize.width < 0 || maxSize.height < 0) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Size value cannot be less than zero');\n        }\n\n        return { behavior, maxSize };\n      }\n\n      case Contract.SheetSizeBehavior.AtLeast: {\n        if (!minSizeMaybe || !hasValidMinSize) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.MissingMinSize, 'Missing minSize for SheetSizeBehavior.AtLeast');\n        }\n\n        const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n        if (minSize.width < 0 || minSize.height < 0) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Size value cannot be less than zero');\n        }\n\n        return { behavior, minSize };\n      }\n\n      case Contract.SheetSizeBehavior.Range: {\n        if (!minSizeMaybe || !maxSizeMaybe || !hasValidMinSize || !hasValidMaxSize) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.MissingMinMaxSize, 'Missing minSize or maxSize for SheetSizeBehavior.Range');\n        }\n\n        const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n        const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n\n        if (\n          minSize.width < 0 ||\n          minSize.height < 0 ||\n          maxSize.width < 0 ||\n          maxSize.height < 0 ||\n          minSize.width > maxSize.width ||\n          minSize.height > maxSize.height\n        ) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Missing minSize or maxSize for SheetSizeBehavior.Range');\n        }\n\n        return { behavior, minSize, maxSize };\n      }\n\n      case Contract.SheetSizeBehavior.Exactly: {\n        if (minSizeMaybe && maxSizeMaybe) {\n          if (hasValidMinSize && hasValidMaxSize) {\n            const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n            const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n\n            if (minSize.width !== maxSize.width || minSize.height !== maxSize.height) {\n              throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Conflicting size values for SheetSizeBehavior.Exactly');\n            }\n\n            return { behavior, minSize, maxSize };\n          }\n\n          if (hasValidMinSize) {\n            const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n            return { behavior, minSize, maxSize: minSize };\n          }\n\n          if (hasValidMaxSize) {\n            const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n            return { behavior, minSize: maxSize, maxSize };\n          }\n        }\n\n        throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Invalid sheet size parameter');\n      }\n\n      default: {\n        throw new TableauError(Contract.SharedErrorCodes.InternalError, `Unsupported sheet size behavior: ${behavior}`);\n      }\n    }\n  }\n\n  private static parseDimensions = (size: Contract.Size | undefined): Partial<Contract.Size> => {\n    const empty = { width: undefined, height: undefined };\n\n    if (!size) {\n      return empty;\n    }\n\n    const { success: widthParsed, parsed: parsedWidth } = Param.tryParseNumber(size.width);\n    const { success: heightParsed, parsed: parsedHeight } = Param.tryParseNumber(size.height);\n\n    if (widthParsed && heightParsed) {\n      return { width: parsedWidth!, height: parsedHeight! };\n    }\n\n    if (widthParsed) {\n      return { width: parsedWidth! };\n    }\n\n    if (heightParsed) {\n      return { height: parsedHeight! };\n    }\n\n    return empty;\n  };\n}\n","import { SheetSize as EmbeddingSheetSize, Size as ExtensionSheetSize, SheetType } from '@tableau/api-external-contract-js';\nimport { SheetPath } from '@tableau/api-internal-contract-js';\n\nexport class SheetInfoImpl {\n  public constructor(\n    private _name: string,\n    private _sheetType: SheetType,\n    private _sheetSize: ExtensionSheetSize | EmbeddingSheetSize,\n    private _index?: number,\n    private _isActive?: boolean,\n    private _isHidden?: boolean,\n    private _url?: string,\n  ) {}\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public set name(sheetName: string) {\n    this._name = sheetName;\n  }\n\n  public get sheetSize(): ExtensionSheetSize | EmbeddingSheetSize {\n    return this._sheetSize;\n  }\n\n  public set sheetSize(value: ExtensionSheetSize | EmbeddingSheetSize) {\n    this._sheetSize = value;\n  }\n\n  public get sheetType(): SheetType {\n    return this._sheetType;\n  }\n\n  public get sheetPath(): SheetPath {\n    return {\n      sheetName: this.name,\n      isDashboard: this.sheetType === SheetType.Dashboard,\n      // TODO - Stories\n    };\n  }\n\n  public get index(): number | undefined {\n    return this._index;\n  }\n\n  public get isActive(): boolean | undefined {\n    return this._isActive;\n  }\n\n  public set active(active: boolean) {\n    this._isActive = active;\n  }\n\n  public get isHidden(): boolean | undefined {\n    return this._isHidden;\n  }\n\n  public get url(): string | undefined {\n    return this._url;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { SingleEventManager } from '../SingleEventManager';\n\n/**\n * This class implements the SingleEventManager interface for a single type of Tableau event\n *\n * @template TEventType The Tableau event type this class specializes\n */\nexport class SingleEventManagerImpl<TEventType extends Contract.TableauEvent> implements SingleEventManager {\n  private _eventType: TableauEventType;\n  private _handlers: Array<(eventObj: TEventType) => void>;\n\n  public constructor(eventType: TableauEventType) {\n    this._eventType = eventType;\n    this._handlers = [];\n  }\n\n  public get eventType(): TableauEventType {\n    return this._eventType;\n  }\n\n  public addEventListener(handler: (eventObj: TEventType) => void): Contract.TableauEventUnregisterFn {\n    this._handlers.push(handler);\n    return () => this.removeEventListener(handler);\n  }\n\n  public removeEventListener(handler: (eventObj: TEventType) => void): boolean {\n    const beforeCount = this._handlers.length;\n    this._handlers = this._handlers.filter((h) => h !== handler);\n    return beforeCount > this._handlers.length;\n  }\n\n  public triggerEvent(eventGenerator: () => TEventType): void {\n    for (const handler of this._handlers) {\n      try {\n        const eventModel = eventGenerator();\n        handler(eventModel);\n      } catch (e) {\n        // Since this handler could be outside our control, just catch anything it throws and continue on\n        continue;\n      }\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { SheetInfo, StoryModel, StoryPointModel } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { StoryActivationService } from '../Services/StoryActivationService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { ShortLivedDeferred } from '../Utils/ShortLivedDeferred';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryPointImpl } from './StoryPointImpl';\nimport { StoryPointInfoImpl } from './StoryPointInfoImpl';\n\nexport class StoryImpl extends SheetImpl {\n  private _activeStoryPointImpl: StoryPointImpl;\n  private _storyPointInfoImpls: Array<StoryPointInfoImpl> = [];\n  private _deferred: ShortLivedDeferred<StoryPointImpl>;\n\n  public constructor(\n    protected _sheetInfoImpl: SheetInfoImpl,\n    storyModel: StoryModel,\n    private _publishedSheetInfos: Array<SheetInfo>,\n    protected _registryId: number,\n  ) {\n    super(_sheetInfoImpl, _registryId);\n    this._deferred = new ShortLivedDeferred<StoryPointImpl>();\n    this.initializeStory(storyModel);\n  }\n\n  private initializeStory(storyModel: StoryModel) {\n    storyModel.storyPoints.forEach((storyPointModel) => {\n      const isActive = storyPointModel.index === storyModel.activeStoryPointIndex;\n      const storyPointInfoImpl = new StoryPointInfoImpl(\n        storyPointModel.caption,\n        storyPointModel.index,\n        storyPointModel.storyPointId,\n        isActive,\n        storyPointModel.updated,\n        this,\n      );\n      this._storyPointInfoImpls.push(storyPointInfoImpl);\n\n      if (isActive) {\n        this._activeStoryPointImpl = new StoryPointImpl(\n          storyPointInfoImpl,\n          this._publishedSheetInfos,\n          this._registryId,\n          storyPointModel.containedSheetInfo,\n        );\n      }\n    });\n  }\n\n  private updateStoryInfo(index: number, storyPointModel: StoryPointModel) {\n    if (!this._storyPointInfoImpls) {\n      return;\n    }\n\n    let storyInfoImpl = this._storyPointInfoImpls[index];\n    if (storyInfoImpl.storyPointId !== storyPointModel.storyPointId) {\n      throw new TableauError(\n        Contract.EmbeddingErrorCodes.StoryPointIdMismatch,\n        `We should not be updating a story point when the IDs don't match. Existing storyPointID=${storyInfoImpl.storyPointId}, newStoryPointID=${storyPointModel.storyPointId}`,\n      );\n    }\n    storyInfoImpl.caption = storyPointModel.caption;\n    storyInfoImpl.updated = storyPointModel.updated;\n\n    if (this._activeStoryPointImpl.storyPointId === storyPointModel.storyPointId) {\n      this._activeStoryPointImpl.updated = storyInfoImpl.updated;\n    }\n  }\n\n  public updateStory(storyPointModel: StoryPointModel) {\n    if (!this._storyPointInfoImpls) {\n      return;\n    }\n\n    this._storyPointInfoImpls.forEach((storyPointInfoImpl) => {\n      const isActive = storyPointInfoImpl.storyPointId === storyPointModel.storyPointId;\n      if (isActive) {\n        // update the state\n        storyPointInfoImpl.caption = storyPointModel.caption;\n        storyPointInfoImpl.index = storyPointModel.index;\n        storyPointInfoImpl.active = true;\n        storyPointInfoImpl.updated = storyPointModel.updated;\n\n        // re-initialize activeStoryPointImpl\n        this._activeStoryPointImpl = new StoryPointImpl(\n          storyPointInfoImpl,\n          this._publishedSheetInfos,\n          this._registryId,\n          storyPointModel.containedSheetInfo,\n        );\n      } else {\n        // set old ones to false\n        storyPointInfoImpl.active = false;\n      }\n    });\n\n    if (this.activeStoryPoint) {\n      this._deferred.resolve(this.activeStoryPoint);\n    }\n  }\n\n  public get activeStoryPoint(): StoryPointImpl | undefined {\n    return this._activeStoryPointImpl;\n  }\n\n  public get storyPointsInfo(): Array<StoryPointInfoImpl> {\n    return this._storyPointInfoImpls;\n  }\n\n  public get isActive(): boolean {\n    return this._sheetInfoImpl.active;\n  }\n\n  public get isHidden(): boolean {\n    return !!this._sheetInfoImpl.isHidden;\n  }\n\n  public activateNextStoryPointAsync(): Promise<StoryPointImpl> {\n    if (this._activeStoryPointImpl.index === this._storyPointInfoImpls.length - 1) {\n      return Promise.resolve(this._activeStoryPointImpl);\n    }\n\n    let promise = this._deferred.getNewPromiseOrThrowIfBusy();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n    service.activateNextStoryPointAsync();\n    return promise;\n  }\n\n  public activatePreviousStoryPointAsync(): Promise<StoryPointImpl> {\n    if (this._activeStoryPointImpl.index === 0) {\n      return Promise.resolve(this._activeStoryPointImpl);\n    }\n\n    let promise = this._deferred.getNewPromiseOrThrowIfBusy();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n    service.activatePreviousStoryPointAsync();\n    return promise;\n  }\n\n  public activateStoryPointAsync(index: number): Promise<StoryPointImpl> {\n    ErrorHelpers.verifyParameter(index, 'index');\n    ErrorHelpers.verifyParameterType(index, 'number', 'index');\n\n    if (index < 0 || index >= this._storyPointInfoImpls.length) {\n      throw new TableauError(Contract.EmbeddingErrorCodes.IndexOutOfRange, 'The index passed to this command is out of range.');\n    }\n\n    if (index === this._activeStoryPointImpl.index) {\n      return Promise.resolve(this._activeStoryPointImpl);\n    }\n\n    let promise = this._deferred.getNewPromiseOrThrowIfBusy();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n    service.activateStoryPointAsync(index);\n    return promise;\n  }\n\n  public revertStoryPointAsync(index: number): Promise<StoryPointInfoImpl> {\n    ErrorHelpers.verifyParameter(index, 'index');\n    ErrorHelpers.verifyParameterType(index, 'number', 'index');\n\n    if (index < 0 || index >= this._storyPointInfoImpls.length) {\n      throw new TableauError(Contract.EmbeddingErrorCodes.IndexOutOfRange, 'The index passed to this command is out of range.');\n    }\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n\n    return service.revertStoryPointAsync(index).then<StoryPointInfoImpl>((response) => {\n      this.updateStoryInfo(response.index, response);\n      const storyPointInfoImpl = new StoryPointInfoImpl(\n        response.caption,\n        response.index,\n        response.storyPointId,\n        false,\n        response.updated,\n        this,\n      );\n      return storyPointInfoImpl;\n    });\n  }\n\n  public clearPendingPromises(): void {\n    if (this._deferred) {\n      this._deferred.reject('All pending promises cleared');\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ContainedSheetInfoModel, SheetInfo, SheetPath, VisualId } from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../TableauError';\nimport { SheetUtils } from '../Utils/SheetUtils';\nimport { DashboardImpl } from './DashboardImpl';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryImpl } from './StoryImpl';\nimport { StoryPointInfoImpl } from './StoryPointInfoImpl';\nimport { WorksheetImpl } from './WorksheetImpl';\n\nexport class StoryPointImpl {\n  private _containedSheetImpl: SheetImpl;\n  constructor(\n    private _storyPointInfoImpl: StoryPointInfoImpl,\n    sheetInfos: Array<SheetInfo>,\n    registryId: number,\n    containedSheetInfo?: ContainedSheetInfoModel,\n  ) {\n    if (containedSheetInfo) {\n      this._containedSheetImpl = this.createContainedSheet(containedSheetInfo, sheetInfos, registryId);\n    }\n  }\n\n  public get index(): number {\n    return this._storyPointInfoImpl.index;\n  }\n\n  public get caption(): string {\n    return this._storyPointInfoImpl.caption;\n  }\n\n  public get active(): boolean {\n    return this._storyPointInfoImpl.active;\n  }\n\n  public get updated(): boolean {\n    return this._storyPointInfoImpl.updated;\n  }\n\n  public set updated(updated: boolean) {\n    this._storyPointInfoImpl.updated = updated;\n  }\n\n  public get parentStory(): StoryImpl {\n    return this._storyPointInfoImpl.parentStory;\n  }\n\n  public get containedSheet(): SheetImpl | undefined {\n    return this._containedSheetImpl;\n  }\n\n  public get storyPointId(): number {\n    return this._storyPointInfoImpl.storyPointId;\n  }\n\n  private createContainedSheet(containedSheetInfo: ContainedSheetInfoModel, sheetInfos: Array<SheetInfo>, registryId: number): SheetImpl {\n    const containedSheetIdx = -1;\n\n    const publishedSheetInfo = SheetUtils.getPublishedSheetInfoByName(containedSheetInfo.name, sheetInfos);\n    const containedSheetSize = SheetUtils.createAutomaticSize();\n    const isContainedSheetHidden = publishedSheetInfo === undefined;\n    const containedSheetUrl = publishedSheetInfo ? publishedSheetInfo.url : '';\n    // Contained sheets aren't active - the containing sheet is active.\n    const containedSheetActive = false;\n\n    const containedSheetInfoImpl = new SheetInfoImpl(\n      containedSheetInfo.name,\n      SheetUtils.getSheetTypeEnum(containedSheetInfo.sheetType),\n      containedSheetSize,\n      containedSheetIdx,\n      containedSheetActive,\n      isContainedSheetHidden,\n      containedSheetUrl,\n    );\n\n    let sheetImpl: SheetImpl;\n    switch (containedSheetInfoImpl.sheetType) {\n      case Contract.SheetType.Worksheet: {\n        const vizId: VisualId = {\n          worksheet: containedSheetInfoImpl.name,\n        };\n\n        sheetImpl = new WorksheetImpl(containedSheetInfoImpl, registryId, vizId, null, this);\n        break;\n      }\n      case Contract.SheetType.Dashboard: {\n        const sheetPath: SheetPath = {\n          sheetName: containedSheetInfoImpl.name,\n          isDashboard: true,\n        };\n\n        sheetImpl = new DashboardImpl(containedSheetInfoImpl, containedSheetInfo.dashboardZones, sheetPath, registryId, this);\n        break;\n      }\n      default: {\n        throw new TableauError(Contract.SharedErrorCodes.ServerError, 'Invalid SheetType');\n      }\n    }\n\n    return sheetImpl;\n  }\n}\n","import { StoryImpl } from './StoryImpl';\n\nexport class StoryPointInfoImpl {\n  public constructor(\n    private _caption: string,\n    private _index: number,\n    private _storyPointId: number,\n    private _active: boolean,\n    private _updated: boolean,\n    private _parentStoryImpl: StoryImpl,\n  ) {}\n\n  public get caption() {\n    return this._caption;\n  }\n\n  public set caption(caption: string) {\n    this._caption = caption;\n  }\n\n  public get index() {\n    return this._index;\n  }\n\n  public set index(index: number) {\n    this._index = index;\n  }\n\n  public get storyPointId() {\n    return this._storyPointId;\n  }\n\n  public get active() {\n    return this._active;\n  }\n\n  public set active(isActive: boolean) {\n    this._active = isActive;\n  }\n\n  public get updated() {\n    return this._updated;\n  }\n\n  public set updated(isUpdated: boolean) {\n    this._updated = isUpdated;\n  }\n\n  public get parentStory() {\n    return this._parentStoryImpl;\n  }\n}\n","export class WorkbookImpl {}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  ApiMenuType,\n  ContextMenuOptions,\n  DateRangeType,\n  ErrorCodes,\n  FilterNullOption,\n  IncludeDataValuesOption,\n  PeriodType,\n  SelectionUpdateType,\n  SharedErrorCodes,\n  TooltipContext,\n} from '@tableau/api-external-contract-js';\nimport { DataSchema, DataSource as DataSourceInfo, VisualId, WorksheetDataSourceInfo } from '@tableau/api-internal-contract-js';\nimport { DataSource } from '../DataSource';\nimport { LogicalTable } from '../LogicalTable';\nimport { AnnotationService } from '../Services/AnnotationService';\nimport { DataSourceService } from '../Services/DataSourceService';\nimport { ExternalContextMenuService } from '../Services/ExternalContextMenuService';\nimport { FilterService } from '../Services/FilterService';\nimport { GetDataService, GetDataType } from '../Services/GetDataService';\nimport { SelectionService } from '../Services/SelectionService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { VisualModelService } from '../Services/VisualModelService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { DashboardImpl } from './DashboardImpl';\nimport { DataSourceImpl } from './DataSourceImpl';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryPointImpl } from './StoryPointImpl';\n\nexport class WorksheetImpl extends SheetImpl {\n  public constructor(\n    sheetInfoImpl: SheetInfoImpl,\n    _registryId: number,\n    private _visualId: VisualId,\n    private _parentDashboardImpl: DashboardImpl | null,\n    private _parentStoryPointImpl: StoryPointImpl | null,\n  ) {\n    super(sheetInfoImpl, _registryId);\n  }\n\n  public get parentDashboard(): DashboardImpl | null {\n    return this._parentDashboardImpl;\n  }\n\n  public get parentStoryPoint(): StoryPointImpl | null {\n    return this._parentStoryPointImpl;\n  }\n\n  public get visualId(): VisualId {\n    return this._visualId;\n  }\n\n  public getMaxPageRowLimit(): number {\n    return 10000;\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    ErrorHelpers.verifyEnumValue<Contract.FilterUpdateType>(updateType, Contract.FilterUpdateType, 'Contract.FilterUpdateType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyFilterAsync(this.visualId, fieldName, values, updateType, options);\n  }\n\n  public applyRangeFilterAsync(fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\n    ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n    ErrorHelpers.verifyParameter(filterOptions, 'filterOptions');\n    if (filterOptions.nullOption) {\n      ErrorHelpers.verifyEnumValue<FilterNullOption>(filterOptions.nullOption, FilterNullOption, 'FilterNullOption');\n    } else {\n      ErrorHelpers.verifyRangeParamType(filterOptions.min, filterOptions.max);\n    }\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyRangeFilterAsync(this.visualId, fieldName, filterOptions);\n  }\n\n  public applyHierarchicalFilterAsync(\n    fieldName: string,\n    values: Array<string> | Contract.HierarchicalLevels,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n    ErrorHelpers.verifyParameter(values, 'values');\n    ErrorHelpers.verifyEnumValue<Contract.FilterUpdateType>(updateType, Contract.FilterUpdateType, 'Contract.FilterUpdateType');\n    if (!Array.isArray(values) && !values.levels) {\n      throw new TableauError(\n        ErrorCodes.InvalidParameter,\n        'values parameter for applyHierarchicalFilterAsync must be an array or contain a levels key',\n      );\n    }\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyHierarchicalFilterAsync(this.visualId, fieldName, values, updateType, options);\n  }\n\n  public clearFilterAsync(fieldName: string): Promise<string> {\n    ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.clearFilterAsync(this.visualId, fieldName);\n  }\n\n  public applyRelativeDateFilterAsync(fieldName: string, options: Contract.RelativeDateFilterOptions): Promise<string> {\n    ErrorHelpers.verifyStringParameter(fieldName, 'fieldName');\n    ErrorHelpers.verifyParameter(options, 'options');\n    ErrorHelpers.verifyEnumValue<PeriodType>(options.periodType, PeriodType, 'PeriodType');\n    ErrorHelpers.verifyEnumValue<DateRangeType>(options.rangeType, DateRangeType, 'DateRangeType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyRelativeDateFilterAsync(this.visualId, fieldName, options);\n  }\n\n  public getDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n    return service.getDataSourcesAsync(this.visualId).then<Array<Contract.DataSource>>((result) => {\n      const dataSchema: DataSchema = result;\n      const worksheetDataSourceInfo: WorksheetDataSourceInfo = dataSchema.worksheetDataSchemaMap[this.name];\n\n      const dataSources: Array<Contract.DataSource> = [];\n\n      // First, add the primary datasource.  By convention, it comes first in the returned array.\n      const primaryId: string = worksheetDataSourceInfo.primaryDataSource;\n      dataSources.push(this.createDataSourceFromInfo(dataSchema.dataSources[primaryId]));\n\n      // Then, loop through any secondary data sources and add them.\n      for (const secondaryId of worksheetDataSourceInfo.referencedDataSourceList) {\n        if (secondaryId !== primaryId) {\n          dataSources.push(this.createDataSourceFromInfo(dataSchema.dataSources[secondaryId]));\n        }\n      }\n\n      return dataSources;\n    });\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getFiltersAsync(this.visualId);\n  }\n\n  public getSelectedMarksAsync(): Promise<Contract.MarksCollection> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getSelectedMarksAsync(this.visualId);\n  }\n\n  public getHighlightedMarksAsync(): Promise<Contract.MarksCollection> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getHighlightedMarksAsync(this.visualId);\n  }\n\n  public getSummaryDataAsync(options: Contract.GetSummaryDataOptions): Promise<Contract.DataTable> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return service.getUnderlyingDataAsync(\n      this.visualId,\n      GetDataType.Summary,\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      true,\n      options.columnsToIncludeById || [],\n      options.maxRows || 0,\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getSummaryDataReaderAsync(pageRowCount: number, options: Contract.GetSummaryDataOptions): Promise<Contract.DataTableReader> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return service.getSummaryDataReaderAsync(\n      this.visualId,\n      pageRowCount || this.getMaxPageRowLimit(),\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      true, // includeAllColumns (can be overridden by columnsToIncludeById)\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getVisualSpecificationAsync(): Promise<Contract.VisualSpecification> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<VisualModelService>(ServiceNames.VisualModel);\n\n    return service.getVisualSpecificationAsync(this.visualId);\n  }\n\n  public getSummaryColumnsInfoAsync(): Promise<Array<Contract.Column>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getSummaryColumnsInfoAsync(this.visualId);\n  }\n\n  public getUnderlyingDataAsync(options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n    return service.getUnderlyingDataAsync(\n      this.visualId,\n      GetDataType.Underlying,\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      !!options.includeAllColumns,\n      options.columnsToIncludeById || [],\n      options.maxRows || 0,\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getUnderlyingTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n    return service.getUnderlyingTablesAsync(this.visualId).then<Array<Contract.LogicalTable>>((logicalTableInfos) => {\n      return logicalTableInfos.map((logicalTableInfo) => new LogicalTable(logicalTableInfo));\n    });\n  }\n\n  public getUnderlyingTableDataAsync(logicalTableId: string, options?: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n    return service.getUnderlyingTableDataAsync(\n      this.visualId,\n      logicalTableId,\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      !!options.includeAllColumns,\n      options.columnsToIncludeById || [],\n      options.maxRows || 0,\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getUnderlyingTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount?: number,\n    options?: Contract.GetUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n    return service.getUnderlyingTableDataReaderAsync(\n      this.visualId,\n      logicalTableId,\n      pageRowCount || this.getMaxPageRowLimit(),\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      !!options.includeAllColumns,\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public clearSelectedMarksAsync(): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.clearSelectedMarksAsync(this.visualId);\n  }\n\n  public selectMarksByValueAsync(selections: Array<Contract.SelectionCriteria>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    ErrorHelpers.verifyParameter(selections, 'fieldName');\n    ErrorHelpers.verifyEnumValue<SelectionUpdateType>(selectionUpdateType, SelectionUpdateType, 'SelectionUpdateType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.selectMarksByValueAsync(this.visualId, selections, selectionUpdateType);\n  }\n\n  public selectMarksByIdAsync(selections: Array<Contract.MarkInfo>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    ErrorHelpers.verifyParameter(selections, 'fieldName');\n    ErrorHelpers.verifyEnumValue<SelectionUpdateType>(selectionUpdateType, SelectionUpdateType, 'SelectionUpdateType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.selectMarksByIdAsync(this.visualId, selections, selectionUpdateType);\n  }\n\n  public annotateMarkAsync(mark: Contract.MarkInfo, annotationText: string): Promise<void> {\n    ErrorHelpers.verifyParameter(mark, 'mark');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<AnnotationService>(ServiceNames.Annotation);\n    return service.annotateMarkAsync(this.visualId, mark, annotationText);\n  }\n\n  public getAnnotationsAsync(): Promise<Array<Contract.Annotation>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<AnnotationService>(ServiceNames.Annotation);\n    return service.getAnnotationsAsync(this.visualId);\n  }\n\n  public removeAnnotationAsync(annotation: Contract.Annotation) {\n    ErrorHelpers.verifyParameter(annotation, 'annotation');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<AnnotationService>(ServiceNames.Annotation);\n    return service.removeAnnotationAsync(this.visualId, annotation);\n  }\n\n  public appendContextMenuAsync(targetMenu: ApiMenuType, config: ContextMenuOptions): Promise<string> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.appendContextMenuAsync(this.visualId.worksheet, targetMenu, config);\n  }\n\n  public removeContextMenuAsync(targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.removeContextMenuAsync(this.visualId.worksheet, targetMenu, menuItemId);\n  }\n\n  public executeContextMenuAsync(targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.executeContextMenuAsync(this.visualId.worksheet, targetMenu, menuItemId);\n  }\n\n  public renameContextMenuAsync(targetMenu: ApiMenuType, menuHeader: string, menuDescription: string): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.renameContextMenuAsync(this.visualId.worksheet, targetMenu, menuHeader, menuDescription);\n  }\n\n  public hoverTupleAsync(hoveredTuple: number, tooltip?: TooltipContext): Promise<void> {\n    if (this.isInsideDashboardExtension()) {\n      return Promise.reject(\n        new TableauError(Contract.SharedErrorCodes.ImplementationError, `hoverTupleAsync is not supported in dashboard extensions`),\n      );\n    }\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.hoverTupleAsync(this.visualId, hoveredTuple, tooltip);\n  }\n\n  public selectTuplesAsync(selectedTuples: Array<number>, selectOption: Contract.SelectOptions, tooltip?: TooltipContext): Promise<void> {\n    if (this.isInsideDashboardExtension()) {\n      return Promise.reject(\n        new TableauError(Contract.SharedErrorCodes.ImplementationError, `selectTuplesAsync is not supported in dashboard extensions`),\n      );\n    }\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.selectTuplesAsync(this.visualId, selectedTuples, selectOption, tooltip);\n  }\n\n  private createDataSourceFromInfo(dataSourceInfo: DataSourceInfo): Contract.DataSource {\n    const dataSourceImpl = new DataSourceImpl(dataSourceInfo, this._registryId);\n    const dataSource = new DataSource(dataSourceImpl);\n    dataSourceImpl.initializeWithPublicInterfaces(dataSource);\n    return dataSource;\n  }\n\n  private verifyActiveSheet() {\n    const isRootAndActiveWorksheet = this.active;\n    const isInsideActiveDashboard = this.isInsideActiveDashboard();\n    const isInsideActiveStoryPoint = this.isInsideActiveStoryPoint();\n\n    if (!isRootAndActiveWorksheet && !isInsideActiveDashboard && !isInsideActiveStoryPoint) {\n      throw new TableauError(SharedErrorCodes.NotActiveSheet, 'Operation not allowed on non-active sheet');\n    }\n  }\n\n  private isInsideActiveStoryPoint() {\n    return this._parentStoryPointImpl && this._parentStoryPointImpl.active;\n  }\n\n  private isInsideActiveDashboard() {\n    return this._parentDashboardImpl && this._parentDashboardImpl.active;\n  }\n\n  private isInsideDashboardExtension() {\n    return this._parentDashboardImpl !== null;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { LogicalTableInfo } from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of a logical table.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class LogicalTable implements Contract.LogicalTable {\n  public constructor(private _logicalTable: LogicalTableInfo) {}\n\n  public get id(): string {\n    return this._logicalTable.id;\n  }\n\n  public get caption(): string {\n    return this._logicalTable.caption;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DateRangeType, FilterDomainType, FilterType, PeriodType } from '@tableau/api-external-contract-js';\nimport { HierarchicalLevelSelectionState } from '@tableau/api-external-contract-js/lib/src/ExternalContract/Shared/Namespaces/Tableau';\nimport { DataSourceService } from '../Services/DataSourceService';\nimport { FilterService } from '../Services/FilterService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\n\nexport class Filter implements Contract.Filter {\n  public constructor(\n    protected _worksheetName: string,\n    protected _fieldName: string,\n    protected _filterType: FilterType,\n    protected _fieldId: string,\n    protected _registryId: number,\n  ) {}\n\n  public get worksheetName(): string {\n    return this._worksheetName;\n  }\n\n  public get fieldName(): string {\n    return this._fieldName;\n  }\n\n  public get fieldId(): string {\n    return this._fieldId;\n  }\n\n  public get filterType(): FilterType {\n    return this._filterType;\n  }\n\n  public getFieldAsync(): Promise<Contract.Field> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n    return service.getFieldAsync(this._fieldId);\n  }\n\n  public getAppliedWorksheetsAsync(): Promise<Array<string>> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getAppliedWorksheetsAsync(this._worksheetName, this._fieldId);\n  }\n\n  public setAppliedWorksheetsAsync(applyToWorksheets: Array<string>): Promise<Array<string>> {\n    ErrorHelpers.verifyParameter(applyToWorksheets, 'applyToWorksheets');\n    const uniqueWorksheets = new Set(applyToWorksheets);\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.setAppliedWorksheetsAsync(this._worksheetName, this._fieldName, this._fieldId, Array.from(uniqueWorksheets));\n  }\n}\n\nexport class CategoricalFilter extends Filter implements Contract.CategoricalFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _appliedValues: Array<Contract.DataValue>,\n    private _isExcludeMode: boolean,\n    private _isAllSelected?: boolean,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n\n  public get isAllSelected(): boolean | undefined {\n    return this._isAllSelected;\n  }\n\n  public get appliedValues(): Array<Contract.DataValue> {\n    return this._appliedValues;\n  }\n\n  public get isExcludeMode(): boolean {\n    return this._isExcludeMode;\n  }\n\n  public getDomainAsync(domainType?: FilterDomainType): Promise<Contract.CategoricalDomain> {\n    if (!domainType) {\n      domainType = FilterDomainType.Relevant;\n    }\n\n    ErrorHelpers.verifyEnumValue<FilterDomainType>(domainType, FilterDomainType, 'FilterDomainType');\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getCategoricalDomainAsync(this._worksheetName, this._fieldId, domainType);\n  }\n}\n\nexport class HierarchicalDataValue implements Contract.HierarchicalFilterDataValue {\n  public constructor(private _value: Contract.DataValue, private _hierarchicalPath: string, private _level: number) {}\n\n  public get value(): Contract.DataValue {\n    return this._value;\n  }\n\n  public get hierarchicalPath(): string {\n    return this._hierarchicalPath;\n  }\n\n  public get level(): number {\n    return this._level;\n  }\n}\n\nexport class HierarchicalLevelDetail implements Contract.HierarchicalLevelDetail {\n  public constructor(private _name: string, private _levelSelectionState: HierarchicalLevelSelectionState) {}\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get levelSelectionState(): HierarchicalLevelSelectionState {\n    return this._levelSelectionState;\n  }\n}\n\nexport class HierarchicalFilter extends Filter implements Contract.HierarchicalFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _dimensionName: string,\n    private _hierarchyCaption: string,\n    private _numberOfLevels: number,\n    private _levelDetails: Array<Contract.HierarchicalLevelDetail>,\n    private _appliedValues: Array<Contract.HierarchicalFilterDataValue>,\n    private _isAllSelected: boolean,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n  getDomainAsync(domainType?: Contract.FilterDomainType): Promise<Contract.CategoricalDomain> {\n    throw new Error('Method not implemented.');\n  }\n\n  public get dimensionName(): string {\n    return this._dimensionName;\n  }\n\n  public get hierarchyCaption(): string {\n    return this._hierarchyCaption;\n  }\n\n  public get numberOfLevels(): number {\n    return this._numberOfLevels;\n  }\n\n  public get levelDetails(): Contract.HierarchicalLevelDetail[] {\n    return this._levelDetails;\n  }\n\n  public get isAllSelected(): boolean {\n    return this._isAllSelected;\n  }\n\n  public get appliedValues(): Array<Contract.HierarchicalFilterDataValue> {\n    return this._appliedValues;\n  }\n}\n\nexport class RangeFilter extends Filter implements Contract.RangeFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _min: Contract.DataValue,\n    private _max: Contract.DataValue,\n    private _includeNullValues: boolean,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n\n  public get minValue(): Contract.DataValue {\n    return this._min;\n  }\n\n  public get maxValue(): Contract.DataValue {\n    return this._max;\n  }\n\n  public get includeNullValues(): boolean {\n    return this._includeNullValues;\n  }\n\n  public getDomainAsync(domainType?: FilterDomainType): Promise<Contract.RangeDomain> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    if (!domainType) {\n      domainType = FilterDomainType.Relevant;\n    }\n\n    ErrorHelpers.verifyEnumValue<FilterDomainType>(domainType, FilterDomainType, 'FilterDomainType');\n\n    return service.getRangeDomainAsync(this._worksheetName, this._fieldId, domainType);\n  }\n}\n\nexport class RelativeDateFilter extends Filter implements Contract.RelativeDateFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _anchorDate: Contract.DataValue,\n    private _periodType: PeriodType,\n    private _rangeType: DateRangeType,\n    private _rangeN: number,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n\n  public get anchorDate(): Contract.DataValue {\n    return this._anchorDate;\n  }\n\n  public get periodType(): PeriodType {\n    return this._periodType;\n  }\n\n  public get rangeType(): DateRangeType {\n    return this._rangeType;\n  }\n\n  public get rangeN(): number {\n    return this._rangeN;\n  }\n}\n\nexport class CategoricalDomain implements Contract.CategoricalDomain {\n  public constructor(private _values: Array<Contract.DataValue>, private _domainType: FilterDomainType) {}\n\n  public get values(): Array<Contract.DataValue> {\n    return this._values;\n  }\n\n  public get type(): FilterDomainType {\n    return this._domainType;\n  }\n}\n\nexport class RangeDomain implements Contract.RangeDomain {\n  public constructor(private _min: Contract.DataValue, private _max: Contract.DataValue, private _domainType: FilterDomainType) {}\n\n  public get type(): FilterDomainType {\n    return this._domainType;\n  }\n\n  public get min(): Contract.DataValue {\n    return this._min;\n  }\n\n  public get max(): Contract.DataValue {\n    return this._max;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataType, MarkType } from '@tableau/api-external-contract-js';\n\nexport class DataTable implements Contract.DataTable {\n  private _name: string;\n\n  public constructor(\n    private _data: Array<Array<Contract.DataValue>>,\n    private _columns: Array<Contract.Column>,\n    private _totalRowCount: number,\n    private _isTotalRowCountLimited: boolean,\n    private _isSummaryData: boolean,\n    private _marksInfo?: Array<MarkInfo>,\n  ) {\n    this._name = _isSummaryData ? 'Summary Data Table' : 'Underlying Data Table';\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get data(): Array<Array<Contract.DataValue>> {\n    return this._data;\n  }\n\n  public get columns(): Array<Contract.Column> {\n    return this._columns;\n  }\n\n  public get marksInfo(): Array<Contract.MarkInfo> | undefined {\n    return this._marksInfo;\n  }\n\n  public get totalRowCount(): number {\n    return this._totalRowCount;\n  }\n\n  public get isTotalRowCountLimited(): boolean | undefined {\n    return this._isTotalRowCountLimited;\n  }\n\n  public get isSummaryData(): boolean | undefined {\n    return this._isSummaryData;\n  }\n}\n\nexport class MarkInfo implements Contract.MarkInfo {\n  public constructor(private _type: MarkType, private _color: string, private _tupleId?: number) {}\n\n  public get type(): MarkType {\n    return this._type;\n  }\n\n  public get color(): string {\n    return this._color;\n  }\n\n  public get tupleId(): number | undefined {\n    return this._tupleId;\n  }\n}\n\nexport class Column implements Contract.Column {\n  public constructor(\n    private _fieldName: string,\n    private _fieldId: string,\n    private _dataType: DataType,\n    private _isReferenced: boolean,\n    private _index: number,\n  ) {}\n\n  public get fieldName(): string {\n    return this._fieldName;\n  }\n\n  public get fieldId(): string {\n    return this._fieldId;\n  }\n\n  public get dataType(): DataType {\n    return this._dataType;\n  }\n\n  public get isReferenced(): boolean {\n    return this._isReferenced;\n  }\n\n  public get index(): number {\n    return this._index;\n  }\n}\n\nexport class DataValue implements Contract.DataValue {\n  /* tslint:disable:no-any */\n  public constructor(private _value: any, private _nativeValue: any, private _formattedValue?: string) {}\n\n  public get value(): any {\n    return this._value;\n  }\n\n  public get nativeValue(): any {\n    return this._nativeValue;\n  }\n\n  public get formattedValue(): string | undefined {\n    return this._formattedValue;\n  }\n  /* tslint:enable:no-any */\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { GetDataService } from '../Services/GetDataService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\n\nexport class DataTableReader implements Contract.DataTableReader {\n  public constructor(protected _id: string, protected _totalRowCount: number, protected _pageRowCount, private _registryId: number) {\n    this._pageCount = Math.ceil(_totalRowCount / _pageRowCount);\n  }\n  protected _pageCount: number;\n\n  public get totalRowCount(): number {\n    return this._totalRowCount;\n  }\n\n  public get pageCount(): number {\n    return this._pageCount;\n  }\n\n  public getPageAsync(pageNumber: number): Promise<Contract.DataTable> {\n    ErrorHelpers.verifyRange(pageNumber, 0, this._pageCount);\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getPageAsync(this._id, pageNumber, this._pageRowCount);\n  }\n\n  public async getAllPagesAsync(maxRows?: number): Promise<Contract.DataTable> {\n    const firstPage: Contract.DataTable = await this.getPageAsync(0);\n    maxRows = maxRows || this.totalRowCount;\n    const rowsRequested = Math.min(maxRows, this.totalRowCount);\n    const pagesRequested = Math.ceil(rowsRequested / this._pageRowCount);\n\n    // Fetch up to 400 pages, with a default of 10,000 pageRowCount that gives us 4,000,000 rows\n    const pagesToFetch = Math.min(pagesRequested, 400);\n    const isDataLimited = pagesToFetch < pagesRequested;\n    let remainingData: Array<Array<Array<Contract.DataValue>>> = [];\n    for (let i = 1; i < pagesToFetch; i++) {\n      const page = await this.getPageAsync(i);\n      remainingData.push(page.data);\n    }\n\n    let fullData = firstPage.data.concat(...remainingData);\n    // This slices the array only if maxRows has been set and is less than totalRowCount\n    fullData.length = rowsRequested;\n\n    return {\n      name: firstPage.name,\n      data: fullData,\n      columns: firstPage.columns,\n      totalRowCount: isDataLimited ? pagesToFetch * this._pageRowCount : rowsRequested,\n      isTotalRowCountLimited: isDataLimited,\n      isSummaryData: firstPage.isSummaryData,\n    };\n  }\n\n  public releaseAsync(): Promise<void> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.releaseAsync(this._id);\n  }\n}\n","import { TooltipContext } from '@tableau/api-external-contract-js';\nimport { VisualId } from '@tableau/api-internal-contract-js';\n\n/**\n * Selection Model.\n */\nexport class SelectionModel {\n  public qualifiedFieldCaption: string;\n}\n\n/**\n * Value based selection model. Meant for hierarchical, range and categorical selections.\n */\nexport class ValueSelectionModel extends SelectionModel {\n  public selectValues: Array<string> = [];\n}\n\n/**\n * Hierarchical value selection model\n */\nexport class HierarchicalSelectionModel extends ValueSelectionModel {}\n\n/**\n * Range based value selection model\n */\nexport class RangeSelectionModel extends SelectionModel {\n  public minValue: string;\n  public maxValue: string;\n  public included: string;\n}\n\n/**\n * Dimension value selection model\n */\nexport class DimensionSelectionModel extends ValueSelectionModel {}\n/**\n * Tuple based selection model\n */\nexport class TupleSelectionModel {\n  public selectionType: string;\n  public objectIds: Array<string> = [];\n}\n\n/**\n * Container class to populate all the selection models when parsing input\n */\nexport class SelectionModelsContainer {\n  public hierModelArr: Array<HierarchicalSelectionModel> = [];\n  public dimModelArr: Array<DimensionSelectionModel> = [];\n  public quantModelArr: Array<RangeSelectionModel> = [];\n  public selection: TupleSelectionModel;\n}\n\nexport class SelectTuplesInteractionModel {\n  public constructor(\n    public visualIdPresModel: VisualId,\n    public tupleIds: Array<number> = [],\n    public selectOptions: string,\n    public tooltipContext?: TooltipContext,\n  ) {}\n}\n\nexport class HoverTupleInteractionModel {\n  public constructor(public visualIdPresModel: VisualId, public tupleId: number, public tooltipContext?: TooltipContext) {}\n}\n","import * as Contract from '@tableau/api-external-contract-js';\n\nexport class Point implements Contract.Point {\n  public constructor(private _x: number, private _y: number) {}\n\n  public get x(): number {\n    return this._x;\n  }\n\n  public get y(): number {\n    return this._y;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { IncludeDataValuesOption } from '@tableau/api-external-contract-js';\nimport { VisualId } from '@tableau/api-internal-contract-js';\nimport { ApiService } from './ServiceRegistry';\n\n/**\n * Defines which type of getData call to make.\n */\nexport enum GetDataType {\n  Summary = 'summary',\n  Underlying = 'underlying',\n}\n\n/**\n * Service for implementing the logic for various getData calls\n *\n * @interface GetDataService\n * @extends {ApiService}\n */\nexport interface GetDataService extends ApiService {\n  /**\n   * Gets the limit of rows for getUnderlyingDataAsync\n   */\n  getMaxRowLimit(): number;\n\n  /**\n   * Gets the underlying data for a particular visual\n   *\n   * @param {VisualId} visualId  The visual id\n   * @param {GetDataType} getType  The type of getData call to make\n   * @param {boolean} ignoreAliases  Whether or not aliases should be ignored\n   * @param {boolean} ignoreSelection  Whether or not selection should be ignored\n   * @param {boolean} includeAllColumns  Should all columns be included\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns.\n   * @param {number} maxRows  Maximum number of rows to return\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getUnderlyingDataAsync(\n    visualId: VisualId,\n    getType: GetDataType,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   * @param {number} pageRowCount The number of rows per page. The default and maximum is 10,000 rows.\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {boolean} ignoreSelection  Whether selections in this viz should be ignored in the returned data\n   * @param {boolean} includeAllColumns  Should all columns be included\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns\n   * @returns {Promise<Contract.DataTableReader>}  Data table reader to access the underlying data\n   */\n  getSummaryDataReaderAsync(\n    visualId: VisualId,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader>;\n\n  /**\n   * Gets the currently selected marks for a given visual\n   *\n   * @param {VisualId} visualId  The visual id\n   * @returns {Promise<ActiveMarks>}  Collection of data tables with the active marks\n   */\n  getSelectedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection>;\n\n  /**\n   * Gets the currently highlighted marks for a given visual\n   *\n   * @param {VisualId} visualId  The visual id\n   * @returns {Promise<ActiveMarks>}  Collection of data tables with the active marks\n   */\n  getHighlightedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection>;\n\n  /**\n   * @param {string} datasourceId  The id of the datasource\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {number} maxRows The maximum number of rows to retrieve\n   * @param {Array<string>} columnsToInclude Columns which should be returned specified by caption. Empty means all columns\n   * @param {Array<string>} columnsToIncludeById Columns which should be returned specified by name. Empty means all columns\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getDataSourceDataAsync(\n    datasourceId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {string} datasourceId  The id of the datasource\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {number} maxRows The maximum number of rows to retrieve\n   * @param {Array<string>} columnsToInclude Columns which should be returned specified by caption. Empty means all columns\n   * @param {Array<string>} columnsToIncludeById Columns which should be returned specified by name. Empty means all columns\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getLogicalTableDataAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {string} datasourceId  The id of the datasource\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {number} pageRowCount The number of rows per page. The default and maximum is 10,000 rows.\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {Array<string>} columnsToIncludeById Columns which should be returned specified by name. Empty means all columns\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getLogicalTableDataReaderAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {boolean} ignoreSelection  Whether selections in this viz should be ignored in the returned data\n   * @param {boolean} includeAllColumns  Whether to include all columns or only the referenced columns\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns.\n   * @param {number} maxRows The maximum number of rows to retrieve\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getUnderlyingTableDataAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {number} pageRowCount The number of rows per page. The default and maximum is 10,000 rows.\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {boolean} ignoreSelection  Whether selections in this viz should be ignored in the returned data\n   * @param {boolean} includeAllColumns  Whether to include all columns or only the referenced columns\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns.\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getUnderlyingTableDataReaderAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   */\n  getSummaryColumnsInfoAsync(visualId: VisualId): Promise<Array<Contract.Column>>;\n\n  /**\n   * @param tableId     The table id used to fetch data.\n   * @param pageNumber  The page number (zero-based).\n   * @param pageSize    The page size of the owning DataTableReader\n   * @returns           A DataTable containing the requested page. The number of rows returned\n   *                    can be less than requested at the end of the data.\n   */\n  getPageAsync(tableId: string, pageNumber: number, pageSize: number): Promise<Contract.DataTable>;\n\n  /**\n   * @param tableId     The table id used to fetch data.\n   */\n  releaseAsync(tableId: string): Promise<void>;\n}\n","import { InternalApiDispatcher, VersionNumber } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry } from './ServiceRegistry';\nimport { AnimationServiceImpl } from './impl/AnimationServiceImpl';\nimport { AnnotationServiceImpl } from './impl/AnnotationServiceImpl';\nimport { DataSourceServiceImpl } from './impl/DataSourceServiceImpl';\nimport { ExportServiceImpl } from './impl/ExportServiceImpl';\nimport { ExternalContextMenuServiceImpl } from './impl/ExternalContextMenuServiceImpl';\nimport { FilterServiceImpl } from './impl/FilterServiceImpl';\nimport { GetDataServiceImpl } from './impl/GetDataServiceImpl';\nimport { NotificationServiceImpl } from './impl/NotificationServiceImpl';\nimport { ParametersServiceImpl } from './impl/ParametersServiceImpl';\nimport { SelectionServiceImpl } from './impl/SelectionServiceImpl';\nimport { SizeServiceImpl } from './impl/SizeServiceImpl';\nimport { VisualModelServiceImpl } from './impl/VisualModelServiceImpl';\nimport { VizServiceImpl } from './impl/VizServiceImpl';\nimport { ZoneServiceImpl } from './impl/ZoneServiceImpl';\n\nexport function registerAllSharedServices(dispatcher: InternalApiDispatcher, registryId: number, platformVersion?: VersionNumber): void {\n  ApiServiceRegistry.get(registryId).registerService(new AnimationServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new DataSourceServiceImpl(dispatcher, registryId, platformVersion));\n  ApiServiceRegistry.get(registryId).registerService(new ExportServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new GetDataServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new FilterServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new NotificationServiceImpl(dispatcher));\n  ApiServiceRegistry.get(registryId).registerService(new ParametersServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new SelectionServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new AnnotationServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new ZoneServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new SizeServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new VisualModelServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new VizServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new ExternalContextMenuServiceImpl(dispatcher, registryId));\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * Base interface for an api service\n */\nexport interface ApiService {\n  /**\n   * Gets the name for this service.\n   */\n  readonly serviceName: string;\n}\n\n/**\n * Collection of service name which will be registered in the api-shared project\n */\nexport const enum ServiceNames {\n  Authentication = 'authentication',\n  ClientInfo = 'client-info-service',\n  DataSourceService = 'data-source-service',\n  GetData = 'get-data-service',\n  Filter = 'filter-service',\n  Notification = 'notification-service',\n  Parameters = 'parameters-service',\n  Selection = 'selection-service',\n  Annotation = 'annotation-service',\n  Zone = 'zone-service',\n  Animation = 'animation-service',\n  Viz = 'viz-service',\n  ExternalContextMenu = 'external-context-menu-service',\n  Initialization = 'initialization-service',\n  StoryActivation = 'story-activation-service',\n  Size = 'size-service',\n  Export = 'export-service',\n  VisualModel = 'visual-model-service',\n}\n\n/**\n * Do some global declarations so we can create a singleton on the window object\n */\ndeclare global {\n  interface Window {\n    __tableauApiServiceRegistry: { [registryId: number]: ServiceRegistry };\n  }\n}\n\nwindow.__tableauApiServiceRegistry = window.__tableauApiServiceRegistry || {};\n\nexport interface ServiceRegistry {\n  /**\n   * Registers a new service into the service registry. Any existing one will\n   * be overwritten. the service is registered under service.serviceName\n   *\n   * @param {ApiService} service The servive to register\n   */\n  registerService(service: ApiService): void;\n\n  /**\n   * Retrieves the given service from the registry. If there is not a\n   * service registered under that name, throws and error\n   *\n   * @template T The type of the service\n   * @param {string} serviceName The name of the service.\n   * @returns {T} The requested service\n   */\n  getService<T extends ApiService>(serviceName: string): T;\n}\n\nclass ServiceRegistryImpl implements ServiceRegistry {\n  private _services: { [serviceName: string]: ApiService };\n\n  public constructor() {\n    this._services = {};\n  }\n\n  public registerService(service: ApiService): void {\n    this._services[service.serviceName] = service;\n  }\n\n  public getService<T extends ApiService>(serviceName: string): T {\n    if (!this._services.hasOwnProperty(serviceName)) {\n      throw new TableauError(ErrorCodes.InternalError, `Service not registered: ${serviceName}`);\n    }\n\n    return this._services[serviceName] as T;\n  }\n}\n\n/**\n * Static class used for getting access to the single instance\n * of the ApiServiceRegistry associated with the registryId.\n *\n * Extensions by design don't need to store/access multiple service registries. Their single instance of ServiceRegistry is\n * stored/access with registryId = 0.\n *\n * Whereas Embedding needs to be aware of which ServiceRegistry to use when there are multiple vizzes embedded.\n * An example of how window.__tableauApiServiceRegistry will look when there are two vizzes: { 0 : ServiceRegistry, 1 : ServiceRegistry}\n * where registry ID of 0 & 1 refers to viz's internal identifier (which is generated by VizManager).\n */\nexport class ApiServiceRegistry {\n  /**\n   * Gets the singleton instance of the ServiceRegistry\n   */\n  public static get(registryId: number): ServiceRegistry {\n    if (!window.__tableauApiServiceRegistry || !window.__tableauApiServiceRegistry[registryId]) {\n      ApiServiceRegistry.setInstance(registryId, new ServiceRegistryImpl());\n    }\n\n    if (!window.__tableauApiServiceRegistry[registryId]) {\n      throw new TableauError(ErrorCodes.InternalError, 'Service registry failed');\n    }\n\n    return window.__tableauApiServiceRegistry[registryId];\n  }\n\n  /**\n   * Helper method that sets the service registry instance for the corresponding registryId. Can be used by unit tests\n   *\n   * @param {ServiceRegistry} serviceRegistry The new registry\n   */\n  public static setInstance(registryId: number, serviceRegistry: ServiceRegistry): void {\n    if (!window.__tableauApiServiceRegistry) {\n      window.__tableauApiServiceRegistry = {};\n    }\n    window.__tableauApiServiceRegistry[registryId] = serviceRegistry;\n  }\n\n  /**\n   * Only used by unit tests\n   */\n  public static clearRegistry(): void {\n    window.__tableauApiServiceRegistry = {};\n  }\n\n  // Private to avoid anyone constructing this\n  private constructor() {}\n}\n","import { ReplaySpeedType } from '@tableau/api-external-contract-js';\nimport { ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ExternalToInternalEnumMappings as ExternalEnumConverter } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { ErrorHelpers } from '../../Utils/ErrorHelpers';\nimport { AnimationService } from '../AnimationService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class AnimationServiceImpl extends ServiceImplBase implements AnimationService {\n  public get serviceName(): string {\n    return ServiceNames.Animation;\n  }\n\n  public replayAsync(replaySpeed: ReplaySpeedType): Promise<void> {\n    const parameters = {\n      [ParameterId.ReplaySpeed]: 1.0,\n    };\n\n    ErrorHelpers.verifyEnumValue<ReplaySpeedType>(replaySpeed, ReplaySpeedType, 'ReplaySpeedType');\n    parameters[ParameterId.ReplaySpeed] = ExternalEnumConverter.setReplaySpeedType.convert(replaySpeed);\n\n    return this.execute(VerbId.ReplayAnimation, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { AnnotateEnum, Annotation, ExecuteParameters, ParameterId, VerbId, VisualId } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../../EnumMappings/InternalToExternalEnumMappings';\nimport { SelectionModelsContainer, TupleSelectionModel } from '../../Models/SelectionModels';\nimport { TableauError } from '../../TableauError';\nimport { AnnotationService } from '../AnnotationService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class AnnotationServiceImpl extends ServiceImplBase implements AnnotationService {\n  public get serviceName(): string {\n    return ServiceNames.Annotation;\n  }\n\n  /**\n   * Method to annotate a mark on the given worksheet.\n   *\n   * @param visualId\n   * @param mark\n   * @param annotationText\n   */\n  public annotateMarkAsync(visualId: VisualId, mark: Contract.MarkInfo, annotationText: string): Promise<void> {\n    const selectionModelContainer: SelectionModelsContainer = this.parseMarkSelectionIds([mark]);\n    const dummyTargetPoint = { x: 0, y: 0 };\n    const formattedText = `<formatted-text><run>${annotationText}</run></formatted-text>`;\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'annotateMarkAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.AnnotateEnum]: AnnotateEnum.Mark,\n      [ParameterId.TargetPoint]: dummyTargetPoint,\n      [ParameterId.SelectionList]: [selectionModelContainer.selection],\n      [ParameterId.FormattedText]: formattedText,\n    };\n    return this.execute(VerbId.CreateAnnotation, parameters).then<void>((response) => {\n      // Expecting an empty model and hence the void response.\n      return;\n    });\n  }\n\n  /**\n   * Method to retrieve annotations for the given worksheet.\n   *\n   * @param visualId\n   * @returns {Promise<Array<Annotation>>}\n   */\n  public getAnnotationsAsync(visualId: VisualId): Promise<Array<Contract.Annotation>> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getAnnotationsAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetAnnotations, parameters).then<Array<Contract.Annotation>>((response) => {\n      const annotationsList = response.result as Array<Annotation>;\n      return this.annotationFilterMap(annotationsList);\n    });\n  }\n\n  /**\n   * Method to remove an annotation from a given worksheet.\n   *\n   * @param visualId\n   * @param annotation\n   */\n  public removeAnnotationAsync(visualId: VisualId, annotation: Contract.Annotation): Promise<void> {\n    const selectionModelContainer: SelectionModelsContainer = this.parseAnnotationSelectionIds([annotation]);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'removeAnnotationAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.SelectionList]: [selectionModelContainer.selection],\n    };\n    return this.execute(VerbId.RemoveAnnotation, parameters).then<void>((response) => {\n      // Expecting an empty model and hence the void response.\n      return;\n    });\n  }\n\n  /**\n   * Method to prepare the pres models for selection by MarksInfo\n   * @param marks\n   */\n  private parseMarkSelectionIds(marks: Array<Contract.MarkInfo>): SelectionModelsContainer {\n    const ids: Array<string> = [];\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n    marks.forEach((mark) => {\n      const tupleId: number | undefined = mark.tupleId;\n      if (tupleId !== undefined && tupleId !== null && tupleId > 0) {\n        ids.push(tupleId.toString()); // collect the tuple ids\n      } else {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'invalid tupleId');\n      }\n    });\n    if (ids.length !== 0) {\n      // tuple ids based selection\n      const tupleSelectionModel: TupleSelectionModel = new TupleSelectionModel();\n      tupleSelectionModel.selectionType = 'tuples';\n      tupleSelectionModel.objectIds = ids;\n      selectionModelContainer.selection = tupleSelectionModel;\n    }\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to prepare the pres models for selection by MarkAnnotationInfo\n   * @param marks\n   */\n  private parseAnnotationSelectionIds(annotations: Array<Contract.Annotation>): SelectionModelsContainer {\n    const ids: Array<string> = [];\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n    annotations.forEach((annotation) => {\n      const annotationId: number | undefined = annotation.annotationId;\n      if (annotationId !== undefined && annotationId !== null && annotationId >= 0) {\n        ids.push(annotationId.toString()); // collect the annotation ids\n      } else {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'invalid annotationId');\n      }\n    });\n    if (ids.length !== 0) {\n      // annotation ids based selection\n      const tupleSelectionModel: TupleSelectionModel = new TupleSelectionModel();\n      tupleSelectionModel.selectionType = 'annotations';\n      tupleSelectionModel.objectIds = ids;\n      selectionModelContainer.selection = tupleSelectionModel;\n    }\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to map Annotation to MarkAnnotationInfo\n   * @param annotation\n   * @returns {Annotation}\n   */\n  private mapAnnotation(annotation: Annotation): Contract.Annotation {\n    return {\n      annotationHTML: annotation.annotationText,\n      annotationId: annotation.annotationId,\n      annotationText: annotation.annotationPlainText,\n      annotationType: InternalToExternalEnumMappings.annotationType.convert(annotation.annotateEnum),\n      tupleId: annotation.tupleId!,\n    };\n  }\n\n  /**\n   * Filter the Annotations to Mark Annotations, and map them to MarkAnnotationInfo\n   * @param annotations\n   * @returns {Array<Annotation>}\n   */\n  private annotationFilterMap(annotations: Array<Annotation>): Array<Contract.Annotation> {\n    const annotationInfos = annotations.map((annotation) => this.mapAnnotation(annotation));\n\n    return annotationInfos;\n  }\n}\n","import { EmbeddingBootstrapInfo, ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ClientInfoService } from '../ClientInfoService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ClientInfoServiceImpl extends ServiceImplBase implements ClientInfoService {\n  public get serviceName(): string {\n    return ServiceNames.ClientInfo;\n  }\n\n  public getClientInfoAsync(): Promise<EmbeddingBootstrapInfo> {\n    const verb = VerbId.GetEmbeddingClientInfo;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getClientInfoAsync',\n    };\n\n    return this.execute(verb, parameters).then<EmbeddingBootstrapInfo>((response) => {\n      const clientInfo = response.result as EmbeddingBootstrapInfo;\n      return clientInfo;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes } from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport {\n  ConnectionDescriptionSummary,\n  DataSchema,\n  ExecuteParameters,\n  InternalApiDispatcher,\n  LogicalTableInfo,\n  ParameterId,\n  TableInfo,\n  TableInfos,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport { DataSource } from '../../DataSource';\nimport { Field } from '../../Field';\nimport { DataSourceImpl } from '../../Impl/DataSourceImpl';\nimport { FieldImpl } from '../../Impl/FieldImpl';\nimport { TableauError } from '../../TableauError';\nimport { DataSourceService } from '../DataSourceService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport const SENTINEL_LOGICAL_TABLE_INFO: LogicalTableInfo = {\n  id: InternalContract.ApiShowDataTableSentinel.SingleTableId,\n  caption: InternalContract.ApiShowDataTableSentinel.SingleTableCaption,\n};\n\n// The minimum platform version when Object Model was supported\nconst platformVersionObjectModelSupport = { major: 1, minor: 20, fix: 1 };\n\nexport class DataSourceServiceImpl extends ServiceImplBase implements DataSourceService {\n  // Since Object Model is supported since Tableau 2020.2, DataSourceServiceImpl can be initialized with the\n  // platform version when OM was supported. Once we drop support for Tableau versions <= 2020.1, all additional\n  // code in here for Object Model can be removed.\n  public constructor(\n    dispatcher: InternalApiDispatcher,\n    registryId: number,\n    private _platformVersion: InternalContract.VersionNumber = platformVersionObjectModelSupport,\n  ) {\n    super(dispatcher, registryId);\n  }\n  public get serviceName(): string {\n    return ServiceNames.DataSourceService;\n  }\n\n  public refreshAsync(dataSourceId?: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'refreshAsync',\n      [ParameterId.DeltaTimeMs]: 0,\n      [ParameterId.ShouldRefreshDS]: true,\n    };\n\n    // On server: Not passing the datasource id will refresh all datasources.\n    if (dataSourceId) {\n      parameters[ParameterId.DataSourceId] = dataSourceId;\n    }\n\n    return this.execute(VerbId.RefreshDataSource, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public getActiveTablesAsync(dataSourceId: string): Promise<Array<TableInfo>> {\n    const joinParameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getActiveTablesAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n    };\n\n    // Get the description of the tables used by this connection\n    return this.execute(VerbId.GetActiveTables, joinParameters).then<Array<TableInfo>>((joinResponse) => {\n      const tableInfos = joinResponse.result as TableInfos;\n\n      // getActiveTables is unsupported for cubes and GA. We do not have a connection type property\n      // available from the platform (intentionally, to reduce code churn as new connections are added).\n      // Instead,just check if any tables are returned. This array will be empty for any non-table based datasource.\n      if (tableInfos.tables.length === 0) {\n        throw new TableauError(ErrorCodes.UnsupportedMethodForDataSourceType, `getActiveTables is not supported for: ${dataSourceId}`);\n      }\n\n      return tableInfos.tables;\n    });\n  }\n\n  public getDataSourcesAsync(visualId: VisualId): Promise<DataSchema> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getDataSourcesAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetDataSources, parameters).then<DataSchema>((response) => {\n      const dataSchema = response.result as DataSchema;\n      return dataSchema;\n    });\n  }\n\n  public getAllDataSourcesAsync(): Promise<DataSchema> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getAllDataSourcesAsync',\n    };\n    return this.execute(VerbId.GetAllDataSources, parameters).then<DataSchema>((response) => {\n      const dataSchema = response.result as DataSchema;\n      return dataSchema;\n    });\n  }\n\n  public getConnectionSummariesAsync(dataSourceId: string): Promise<ConnectionDescriptionSummary[]> {\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getConnectionSummariesAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n    };\n\n    // Get the description of the tables used by this connection\n    return this.execute(VerbId.GetConnectionDescriptionSummaries, params).then<ConnectionDescriptionSummary[]>((response) => {\n      const descriptionSummaries = response.result as ConnectionDescriptionSummary[];\n      return descriptionSummaries;\n    });\n  }\n\n  public getFieldAsync(globalfieldName: string): Promise<Contract.Field> {\n    const verb = VerbId.GetFieldAndDataSource;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getFieldAsync',\n      [ParameterId.FieldId]: globalfieldName,\n    };\n\n    return this.execute(verb, parameters).then<Contract.Field>((response) => {\n      const dataSource = response.result[ParameterId.DataSource] as InternalContract.DataSource;\n      const field = response.result[ParameterId.Field] as Field;\n      return this.convertField(field, this.convertDataSource(dataSource));\n    });\n  }\n\n  public getLogicalTablesAsync(dataSourceId: string): Promise<Array<LogicalTableInfo>> {\n    if (!this.isObjectModelSupportedByPlatform()) {\n      /**\n       * This sentinel ID can be passed to datasource.getLogicalTableData.\n       * Once the desktop is upgraded to a version that supports object model,\n       * the sentinel ID will automatically fetch the upgraded table.\n       * */\n      return new Promise<Array<LogicalTableInfo>>((resolve) => resolve([SENTINEL_LOGICAL_TABLE_INFO]));\n    }\n\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getLogicalTablesAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n    };\n    return this.execute(VerbId.GetLogicalTables, params).then<Array<LogicalTableInfo>>((response) => {\n      return response.result as Array<LogicalTableInfo>;\n    });\n  }\n\n  public getUnderlyingTablesAsync(visualId: VisualId): Promise<Array<LogicalTableInfo>> {\n    if (!this.isObjectModelSupportedByPlatform()) {\n      /**\n       * This sentinel ID can be passed to worksheet.getUnderlyingTableData.\n       * Once the desktop is upgraded to a version that supports object model,\n       * the sentinel ID will automatically fetch the upgraded table.\n       * */\n      return new Promise<Array<LogicalTableInfo>>((resolve) => resolve([SENTINEL_LOGICAL_TABLE_INFO]));\n    }\n\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getUnderlyingTablesAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetUnderlyingTables, params).then<Array<LogicalTableInfo>>((response) => {\n      return response.result as Array<LogicalTableInfo>;\n    });\n  }\n\n  private convertField(field: InternalContract.Field, dataSource: Contract.DataSource): Contract.Field {\n    return new Field(new FieldImpl(field, dataSource));\n  }\n\n  private convertDataSource(dataSource: InternalContract.DataSource): Contract.DataSource {\n    return new DataSource(new DataSourceImpl(dataSource, this._registryId));\n  }\n\n  private isObjectModelSupportedByPlatform(): boolean {\n    const platformVersionNoObjectModelSupport = { major: 1, minor: 13, fix: 0 };\n    return InternalContract.VersionLessThan(platformVersionNoObjectModelSupport, this._platformVersion);\n  }\n}\n","import {\n  ExecuteParameters,\n  ExportCrosstabSheetMap,\n  ExportFile,\n  ExportPDFOptions as InternalExportPDFOptions,\n  ParameterId,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport {\n  CrosstabFileFormat,\n  ExportDataOptions,\n  ExportPDFOptions as ExternalExportPDFOptions,\n  ExportScenariosForPDFAndPowerPoint,\n  SharedErrorCodes,\n  SheetType as ExternalSheetType,\n} from '@tableau/api-external-contract-js';\nimport { ExternalToInternalEnumMappings } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { ExportHelpers } from '../../Utils/ExportHelpers';\nimport { ExportService } from '../ExportService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ErrorHelpers } from '../../Utils/ErrorHelpers';\nimport { TableauError } from '../../TableauError';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ExportServiceImpl extends ServiceImplBase implements ExportService {\n  public get serviceName(): string {\n    return ServiceNames.Export;\n  }\n\n  public getExportCrosstabSheetMapAsync(currentSheetType: ExternalSheetType): Promise<ExportCrosstabSheetMap> {\n    const verb = VerbId.GetExportCrosstabSheetMap;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getExportCrosstabSheetMapAsync',\n      [ParameterId.CurrentSheetType]: ExternalToInternalEnumMappings.sheetType.convert(currentSheetType),\n    };\n    return this.execute(verb, parameters).then<ExportCrosstabSheetMap>((response) => {\n      const result = response.result as ExportCrosstabSheetMap;\n      return result;\n    });\n  }\n\n  public async exportCrosstabAsync(\n    sheetName: string,\n    format: CrosstabFileFormat,\n    exportableWorksheetNames: Array<string>,\n    currentSheetType: ExternalSheetType,\n  ): Promise<ExportFile> {\n    ErrorHelpers.verifySheetName(exportableWorksheetNames, sheetName);\n    ErrorHelpers.verifyEnumValue<CrosstabFileFormat>(format, CrosstabFileFormat, 'CrosstabFileFormat');\n\n    // The pres layer command for exporting Crosstab uses SimpleSheetIdentifiers instead of sheet names.\n    // The extensions-and-embedding-api current does not store references to the SimpleSheetIdentifiers of its sheets\n    // so we call a pres layer command that gives us the SimpleSheetIdentifier for each sheet name that appears in the\n    // export Crosstab dialog popup.\n    const sheetNameToIdMap = await this.getExportCrosstabSheetMapAsync(currentSheetType);\n    if (!sheetNameToIdMap[sheetName]) {\n      throw new TableauError(SharedErrorCodes.InternalError, 'missing sheet doc id from sheetMap');\n    }\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportCrosstabAsync',\n      [ParameterId.SheetIdentifier]: sheetNameToIdMap[sheetName],\n      [ParameterId.SendNotifications]: true, // send notification on pres layer that triggers file download\n    };\n\n    // pres layer command invoked depends on the crosstab file format\n    let verb;\n    switch (format) {\n      case CrosstabFileFormat.CSV:\n        verb = VerbId.ExportCrosstabCsvDownload;\n        // CSV only parameter: see browser-clients/export-crosstab-options-dialog repo\n        parameters[ParameterId.UseTabDelimiters] = true;\n        break;\n      case CrosstabFileFormat.Excel:\n        verb = VerbId.ExportCrosstabExcelDownload;\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'unsupported Crosstab file format.');\n    }\n\n    return this.execute(verb, parameters)\n      .then<ExportFile>((response) => {\n        const result = response.result as ExportFile;\n        return result;\n      })\n      .catch(() => {\n        throw new TableauError(SharedErrorCodes.CrosstabCreationError, 'An unexpected error occurred while generating the document.');\n      });\n  }\n\n  public exportDataAsync(visualId: VisualId, options: ExportDataOptions): Promise<void> {\n    ErrorHelpers.verifyExportDataOptions(options);\n\n    // Remove any duplicates from the input array\n    const columnsAsSet: Set<string> = new Set(options.columnsToIncludeById);\n    const columnsToIncludeById = Array.from(columnsAsSet);\n\n    const verb = VerbId.ExportDataDownload;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportDataAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.IgnoreAliases]: options.ignoreAliases ?? false,\n      [ParameterId.ColumnsToIncludeById]: columnsToIncludeById,\n    };\n\n    return this.execute(verb, parameters)\n      .then<void>(() => {})\n      .catch(() => {\n        throw new TableauError(SharedErrorCodes.DataCreationError, 'An unexpected error occurred while generating the document.');\n      });\n  }\n\n  public exportPowerPointAsync(sheetNames: Array<string>, exportScenarios: ExportScenariosForPDFAndPowerPoint): Promise<ExportFile> {\n    ErrorHelpers.verifySheetNamesForPDFAndPPT(sheetNames, exportScenarios);\n\n    // Note: the ExportOriginUrl param is listed as optional for the pres layer command we are invoking; however,\n    // recent changes were made that enforced the use of the empty string when invoking this command with no ExportOriginUrl.\n    // see browser-clients/export-powerpoint-options-dialog repo.\n    const verb = VerbId.ExportPowerpointDownload;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportPowerPointAsync',\n      [ParameterId.ExportOriginUrl]: '',\n      [ParameterId.SelectedSheetNames]: sheetNames,\n    };\n\n    return this.execute(verb, parameters)\n      .then<ExportFile>((response) => {\n        const result = response.result as ExportFile;\n        return result;\n      })\n      .catch(() => {\n        throw new TableauError(\n          SharedErrorCodes.PowerPointCreationError,\n          'An error occured while attempting to generate the PowerPoint file.',\n        );\n      });\n  }\n\n  public async exportPDFAsync(\n    sheetNames: Array<string>,\n    externalExportPdfOptions: ExternalExportPDFOptions,\n    exportScenarios: ExportScenariosForPDFAndPowerPoint,\n  ): Promise<ExportFile> {\n    ErrorHelpers.verifyExportPDFOptions(externalExportPdfOptions);\n    ErrorHelpers.verifySheetNamesForPDFAndPPT(sheetNames, exportScenarios);\n\n    const internalExportPdfOptions: InternalExportPDFOptions = await this.getExportPDFOptionsAsync();\n    ExportHelpers.updateInternalExportPDFOptions(internalExportPdfOptions, externalExportPdfOptions, sheetNames);\n\n    const verb = VerbId.ExportPdfDownload;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportPDFAsync',\n      [ParameterId.ExportPdfOptions]: internalExportPdfOptions,\n    };\n\n    return this.execute(verb, parameters)\n      .then<ExportFile>((response) => {\n        const result = response.result as ExportFile;\n        return result;\n      })\n      .catch(() => {\n        throw new TableauError(SharedErrorCodes.PDFCreationError, 'Unable to create PDF because something went wrong. Try again.');\n      });\n  }\n\n  public getExportPDFOptionsAsync(): Promise<InternalExportPDFOptions> {\n    const verb = VerbId.GetExportPdfOptions;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getExportPdfOptionsAsync',\n    };\n    return this.execute(verb, parameters).then<InternalExportPDFOptions>((response) => {\n      const result = response.result as InternalExportPDFOptions;\n      return result;\n    });\n  }\n}\n","import { ApiMenuType, ContextMenuOptions } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ExternalContextMenuService } from '../ExternalContextMenuService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ExternalContextMenuServiceImpl extends ServiceImplBase implements ExternalContextMenuService {\n  public get serviceName(): string {\n    return ServiceNames.ExternalContextMenu;\n  }\n\n  public appendContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, config: ContextMenuOptions): Promise<string> {\n    const verb = VerbId.AppendExternalMenuItem;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'appendContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuItemDisplayName]: config.displayName,\n    };\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      const newMenuItemId = response.result as string;\n      return newMenuItemId;\n    });\n  }\n\n  public removeContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    const verb = VerbId.RemoveExternalMenuItem;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'removeContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuItemId]: menuItemId,\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public executeContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    const verb = VerbId.ExecuteExternalMenuItem;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'executeContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuItemId]: menuItemId,\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public renameContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, menuHeader: string, menuDescription: string): Promise<void> {\n    const verb = VerbId.RenameExternalMenu;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'renameContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuHeader]: menuHeader,\n      [ParameterId.ExternalMenuDescription]: menuDescription,\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  DateRangeType,\n  EmbeddingErrorCodes,\n  ErrorCodes,\n  FilterDomainType,\n  FilterType as ExternalFilterType,\n  SharedErrorCodes,\n} from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport { ExecuteParameters, FilterType, ParameterId, VerbId, VisualId } from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../../../ApiShared';\nimport { ExternalToInternalEnumMappings as ExternalEnumConverter } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { InternalToExternalEnumMappings as InternalEnumConverter } from '../../EnumMappings/InternalToExternalEnumMappings';\nimport {\n  CategoricalDomain,\n  CategoricalFilter,\n  HierarchicalDataValue,\n  HierarchicalFilter,\n  HierarchicalLevelDetail,\n  RangeDomain,\n  RangeFilter,\n  RelativeDateFilter,\n} from '../../Models/FilterModels';\nimport { DataValue } from '../../Models/GetDataModels';\nimport { DataValueFactory } from '../../Utils/DataValueFactory';\nimport { Param } from '../../Utils/Param';\nimport { FilterService } from '../FilterService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class FilterServiceImpl extends ServiceImplBase implements FilterService {\n  public get serviceName(): string {\n    return ServiceNames.Filter;\n  }\n\n  public applyFilterAsync(\n    visualId: VisualId,\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    filterOptions: Contract.FilterOptions,\n  ): Promise<string> {\n    const verb = VerbId.ApplyCategoricalFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n    if (!Array.isArray(values)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'values parameter for applyFilterAsync must be an array');\n    }\n    parameters[ParameterId.FilterValues] = values;\n    parameters[ParameterId.FilterUpdateType] = ExternalEnumConverter.filterUpdateType.convert(updateType);\n    parameters[ParameterId.IsExcludeMode] =\n      filterOptions === undefined || filterOptions.isExcludeMode === undefined ? false : filterOptions.isExcludeMode;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return fieldName;\n    });\n  }\n\n  public applyRangeFilterAsync(visualId: VisualId, fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\n    const verb = VerbId.ApplyRangeFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyRangeFilterAsync',\n    };\n\n    if (filterOptions.min !== undefined && filterOptions.min !== null) {\n      let min: string | number;\n      if (filterOptions.min instanceof Date) {\n        min = Param.serializeDateForPlatform(filterOptions.min);\n      } else {\n        min = filterOptions.min;\n      }\n      parameters[ParameterId.FilterRangeMin] = min;\n    }\n\n    if (filterOptions.max !== undefined && filterOptions.max !== null) {\n      let max: string | number;\n      if (filterOptions.max instanceof Date) {\n        max = Param.serializeDateForPlatform(filterOptions.max);\n      } else {\n        max = filterOptions.max;\n      }\n      parameters[ParameterId.FilterRangeMax] = max;\n    }\n\n    // The null option is used with min+max for 'include-range' or 'include-range-or-null'\n    if (filterOptions.nullOption) {\n      parameters[ParameterId.FilterRangeNullOption] = ExternalEnumConverter.nullOptions.convert(filterOptions.nullOption);\n    }\n\n    parameters[ParameterId.FieldName] = fieldName;\n    parameters[ParameterId.VisualId] = visualId;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      this.apiFilterHandlerCheckForCommandError(response.result as { [key: string]: string });\n      return fieldName;\n    });\n  }\n\n  public applyHierarchicalFilterAsync(\n    visualId: VisualId,\n    fieldName: string,\n    values: Array<string> | Contract.HierarchicalLevels,\n    updateType: Contract.FilterUpdateType,\n    filterOptions: Contract.FilterOptions,\n  ): Promise<string> {\n    const verb = VerbId.HierarchicalFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyHierarchicalFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n\n    const hierarchicalLevels = (values as Contract.HierarchicalLevels).levels;\n\n    if (Array.isArray(hierarchicalLevels) && hierarchicalLevels.length > 0) {\n      parameters[ParameterId.FilterLevels] = hierarchicalLevels;\n    } else if ((values as Array<String>).length > 0) {\n      parameters[ParameterId.FilterValues] = values;\n    } else {\n      // the server command expects empty list for clearing the filter\n      // it also expects eithers FilterLevels or FilterValues to be set\n      parameters[ParameterId.FilterLevels] = [];\n    }\n\n    parameters[ParameterId.FilterUpdateType] = ExternalEnumConverter.filterUpdateType.convert(updateType);\n    parameters[ParameterId.IsExcludeMode] = filterOptions && !!filterOptions.isExcludeMode;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return fieldName;\n    });\n  }\n\n  public clearFilterAsync(visualId: VisualId, fieldName: string): Promise<string> {\n    const verb = VerbId.ClearFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'clearFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n    return this.execute(verb, parameters).then<string>((resposne) => {\n      return fieldName;\n    });\n  }\n\n  public applyRelativeDateFilterAsync(visualId: VisualId, fieldName: string, options: Contract.RelativeDateFilterOptions) {\n    const verb = VerbId.ApplyRelativeDateFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyRelativeDateFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n    parameters[ParameterId.PeriodType] = ExternalEnumConverter.periodType.convert(options.periodType);\n    parameters[ParameterId.DateRangeType] = ExternalEnumConverter.dateRangeType.convert(options.rangeType);\n    if (options.rangeType === DateRangeType.LastN || options.rangeType === DateRangeType.NextN) {\n      if (options.rangeN === undefined || options.rangeN === null) {\n        throw new TableauError(\n          EmbeddingErrorCodes.MissingRangeNForRelativeDateFilters,\n          'Missing rangeN field for a relative date filter of LASTN or NEXTN.',\n        );\n      }\n      parameters[ParameterId.RangeN] = options.rangeN;\n    }\n\n    if (options.anchorDate !== undefined && options.anchorDate !== null) {\n      parameters[ParameterId.AnchorDate] = this.convertAnchorDate(options.anchorDate);\n    }\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return response.result as string;\n    });\n  }\n\n  public getFiltersAsync(visualId: VisualId): Promise<Array<Contract.Filter>> {\n    const verb = VerbId.GetFilters;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getFiltersAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    return this.execute(verb, parameters).then<Array<Contract.Filter>>((response) => {\n      const filters = response.result as Array<InternalContract.Filter>;\n      return this.convertDomainFilters(filters);\n    });\n  }\n\n  public getCategoricalDomainAsync(\n    worksheetName: string,\n    fieldId: string,\n    domainType: FilterDomainType,\n  ): Promise<Contract.CategoricalDomain> {\n    const verb = VerbId.GetCategoricalDomain;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getCategoricalDomainAsync',\n    };\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n\n    parameters[ParameterId.FieldId] = fieldId;\n    parameters[ParameterId.DomainType] = ExternalEnumConverter.filterDomainType.convert(domainType);\n    return this.execute(verb, parameters).then<Contract.CategoricalDomain>((response) => {\n      const domain = response.result as InternalContract.CategoricalDomain;\n      return this.convertCategoricalDomain(domain, domainType);\n    });\n  }\n\n  public getRangeDomainAsync(worksheetName: string, fieldId: string, domainType: FilterDomainType): Promise<Contract.RangeDomain> {\n    const verb = VerbId.GetRangeDomain;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getRangeDomainAsync',\n    };\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n\n    parameters[ParameterId.FieldId] = fieldId;\n    parameters[ParameterId.DomainType] = ExternalEnumConverter.filterDomainType.convert(domainType);\n    return this.execute(verb, parameters).then<Contract.RangeDomain>((response) => {\n      const domain = response.result as InternalContract.RangeDomain;\n\n      return this.convertRangeDomain(domain, domainType);\n    });\n  }\n\n  public getDashboardFiltersAsync(): Promise<Array<Contract.Filter>> {\n    const verb = VerbId.GetDashboardFilters;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getDashboardFiltersAsync',\n    };\n    return this.execute(verb, parameters).then<Array<Contract.Filter>>((response) => {\n      const filters = response.result as Array<InternalContract.Filter>;\n      return this.convertDomainFilters(filters);\n    });\n  }\n\n  public applyDashboardFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    filterOptions: Contract.FilterOptions,\n  ): Promise<string> {\n    const verb = VerbId.DashboardCategoricalFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyDashboardFilterAsync',\n    };\n    parameters[ParameterId.FieldName] = fieldName;\n    parameters[ParameterId.FilterValues] = values;\n    parameters[ParameterId.FilterUpdateType] = ExternalEnumConverter.filterUpdateType.convert(updateType);\n    parameters[ParameterId.IsExcludeMode] = filterOptions && !!filterOptions.isExcludeMode;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return response.result as string;\n    });\n  }\n\n  public async getAppliedWorksheetsAsync(worksheetName: string, fieldId: string): Promise<Array<string>> {\n    const sharedFilterModel = await this.executeGetAppliedWorksheets(worksheetName, fieldId, 'getAppliedWorksheetsAsync');\n    const worksheetNames: string[] = [];\n    sharedFilterModel.worksheets?.map((worksheetInfo: InternalContract.SharedFilterWorksheetModel) => {\n      if (worksheetInfo.isSelected) {\n        worksheetNames.push(worksheetInfo.worksheetName);\n      }\n    });\n    return worksheetNames;\n  }\n\n  public async setAppliedWorksheetsAsync(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    applyToWorksheets: Array<string>,\n  ): Promise<Array<string>> {\n    const sharedFilterModel = await this.executeGetAppliedWorksheets(worksheetName, fieldId, 'getAppliedWorksheetsAsyncInternal');\n    if (!sharedFilterModel || !sharedFilterModel.worksheets) {\n      throw new TableauError(SharedErrorCodes.InternalError, 'This filter does not apply to multiple worksheets');\n    }\n\n    const allowedWorksheets: string[] = [];\n    let activeWorksheet = '';\n    sharedFilterModel.worksheets.forEach((worksheet) => {\n      // Get active worksheet\n      if (worksheet.isActive) {\n        activeWorksheet = worksheet.worksheetName;\n      }\n\n      // Populate allowed worksheets\n      if (worksheet.isSelected || worksheet.isEnabled) {\n        allowedWorksheets.push(worksheet.worksheetName);\n      }\n    });\n\n    if (activeWorksheet === '') {\n      throw new TableauError(SharedErrorCodes.InternalError, 'No active worksheet');\n    }\n\n    if (!applyToWorksheets.includes(activeWorksheet)) {\n      throw new TableauError(SharedErrorCodes.InternalError, `${activeWorksheet} must be included in the applied worksheets`);\n    }\n\n    applyToWorksheets.forEach((sheet) => {\n      // check if it's present within compatible sheets\n      if (!allowedWorksheets.includes(sheet)) {\n        throw new TableauError(SharedErrorCodes.InternalError, `The field ${fieldName} isn't applicable to the worksheet ${sheet}`);\n      }\n    });\n\n    const verb = VerbId.ChangeSharedFilter;\n    const parameters: ExecuteParameters = {};\n    parameters[ParameterId.FunctionName] = 'setAppliedWorksheetsAsync';\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n    parameters[ParameterId.FieldId] = fieldId;\n    parameters[ParameterId.SharedFilterSheets] = applyToWorksheets;\n\n    return this.execute(verb, parameters).then<string[]>((response) => {\n      return applyToWorksheets;\n    });\n  }\n\n  // Helper Methods\n\n  private executeGetAppliedWorksheets(\n    worksheetName: string,\n    fieldId: string,\n    telemetryFunctionName: string,\n  ): Promise<InternalContract.SharedFilterModel> {\n    const verb = VerbId.GetSharedFilter;\n    const parameters: ExecuteParameters = {};\n    parameters[ParameterId.FunctionName] = telemetryFunctionName;\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n    parameters[ParameterId.FieldId] = fieldId;\n\n    return this.execute(verb, parameters).then<InternalContract.SharedFilterModel>((response) => {\n      const sharedFilterModel = response.result as InternalContract.SharedFilterModel;\n      return sharedFilterModel;\n    });\n  }\n\n  private convertDomainFilters(domainFilters: Array<InternalContract.Filter>): Array<Contract.Filter> {\n    const filters: Array<Contract.Filter> = [];\n    domainFilters.forEach((domainFilter) => {\n      switch (domainFilter.filterType) {\n        case FilterType.Categorical: {\n          const filter = domainFilter as InternalContract.CategoricalFilter;\n          if (filter) {\n            filters.push(this.convertCategoricalFilter(filter));\n          } else {\n            throw new Error('Invalid Categorical Filter');\n          }\n          break;\n        }\n\n        case FilterType.Hierarchical: {\n          const filter = domainFilter as InternalContract.HierarchicalFilter;\n          if (filter) {\n            filters.push(this.convertHierarchicalFilter(filter));\n          } else {\n            throw new Error('Invalid Hierarchical Filter');\n          }\n          break;\n        }\n\n        case FilterType.Range: {\n          const filter = domainFilter as InternalContract.RangeFilter;\n          if (filter) {\n            filters.push(this.convertRangeFilter(filter));\n          } else {\n            throw new Error('Invalid Range Filter');\n          }\n          break;\n        }\n\n        case FilterType.RelativeDate: {\n          const filter = domainFilter as InternalContract.RelativeDateFilter;\n          if (filter) {\n            filters.push(this.convertRelativeDateFilter(filter));\n          } else {\n            throw new Error('Invalid Relative Date Filter');\n          }\n          break;\n        }\n\n        default: {\n          break;\n        }\n      }\n    });\n    return filters;\n  }\n\n  private convertCategoricalFilter(domainFilter: InternalContract.CategoricalFilter): Contract.CategoricalFilter {\n    const appliedValues: Array<Contract.DataValue> = domainFilter.values.map((dv) => {\n      return DataValueFactory.MakeFilterDataValue(dv);\n    });\n\n    return new CategoricalFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      FilterType.Categorical,\n      this._registryId,\n      appliedValues,\n      domainFilter.isExclude,\n      domainFilter.isAllSelected,\n    );\n  }\n\n  private convertHierarchicalFilter(domainFilter: InternalContract.HierarchicalFilter): Contract.HierarchicalFilter {\n    const appliedValues: Array<Contract.HierarchicalFilterDataValue> = domainFilter.values.map((hierarchicalDataValue) => {\n      return new HierarchicalDataValue(\n        DataValueFactory.MakeFilterDataValue(hierarchicalDataValue.value),\n        hierarchicalDataValue.hierarchicalPath,\n        hierarchicalDataValue.level,\n      );\n    });\n\n    const levelDetails: Array<Contract.HierarchicalLevelDetail> = domainFilter.levelInfo.map((aLevel) => {\n      return new HierarchicalLevelDetail(\n        aLevel.name,\n        InternalEnumConverter.hierarchicalLevelSelectionState.convert(aLevel.levelSelectionState),\n      );\n    });\n\n    return new HierarchicalFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      FilterType.Hierarchical,\n      this._registryId,\n      domainFilter.dimensionName,\n      domainFilter.hierarchyCaption,\n      domainFilter.levels,\n      levelDetails,\n      appliedValues,\n      domainFilter.isAllSelected,\n    );\n  }\n\n  private convertRangeFilter(domainFilter: InternalContract.RangeFilter): Contract.RangeFilter {\n    const minValue: DataValue = DataValueFactory.MakeFilterDataValue(domainFilter.min);\n    const maxValue: DataValue = DataValueFactory.MakeFilterDataValue(domainFilter.max);\n    return new RangeFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      FilterType.Range,\n      this._registryId,\n      minValue,\n      maxValue,\n      domainFilter.includeNullValues,\n    );\n  }\n\n  private convertRelativeDateFilter(domainFilter: InternalContract.RelativeDateFilter): Contract.RelativeDateFilter {\n    const anchorDateValue: DataValue = DataValueFactory.MakeFilterDataValue(domainFilter.anchorDate);\n    return new RelativeDateFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      ExternalFilterType.RelativeDate,\n      this._registryId,\n      anchorDateValue,\n      InternalEnumConverter.dateStepPeriod.convert(domainFilter.periodType),\n      InternalEnumConverter.dateRangeType.convert(domainFilter.rangeType),\n      domainFilter.rangeN,\n    );\n  }\n\n  private convertCategoricalDomain(domain: InternalContract.CategoricalDomain, domainType: FilterDomainType): Contract.CategoricalDomain {\n    const values: Array<DataValue> = domain.values.map((domainDv) => {\n      return DataValueFactory.MakeFilterDataValue(domainDv);\n    });\n    return new CategoricalDomain(values, domainType);\n  }\n\n  private convertRangeDomain(domain: InternalContract.RangeDomain, domainType: FilterDomainType): Contract.RangeDomain {\n    const min: DataValue = DataValueFactory.MakeFilterDataValue(domain.min);\n    const max: DataValue = DataValueFactory.MakeFilterDataValue(domain.max);\n    return new RangeDomain(min, max, domainType);\n  }\n\n  private convertAnchorDate(anchorDate: Date): string {\n    // Converts a Date object into a string format that the server expects for date/time values.\n    // If anchorDate doesn't represent a valid Date object, any of these would be NaN.\n    const year = anchorDate.getUTCFullYear();\n    const month = anchorDate.getUTCMonth() + 1;\n    const day = anchorDate.getUTCDate();\n    const hh = anchorDate.getUTCHours();\n    const mm = anchorDate.getUTCMinutes();\n    const sec = anchorDate.getUTCSeconds();\n\n    if (isNaN(year) || isNaN(month) || isNaN(day) || isNaN(hh) || isNaN(mm) || isNaN(sec)) {\n      throw new TableauError(EmbeddingErrorCodes.InvalidDateParameter, 'Invalid date parameter: anchorDate');\n    }\n\n    const result = `${year}-${month}-${day} ${hh}:${mm}:${sec}`;\n    return result;\n  }\n\n  private apiFilterHandlerCheckForCommandError(serverPm: { [key: string]: string }) {\n    if (!serverPm[InternalContract.ParameterId.ParameterError]) {\n      return;\n    }\n    if (serverPm[InternalContract.ParameterId.InvalidFieldCaption]) {\n      throw new TableauError(SharedErrorCodes.InvalidFilterFieldName, serverPm[InternalContract.ParameterId.InvalidFieldCaption]);\n    }\n    if (serverPm[InternalContract.ParameterId.InvalidValues]) {\n      throw new TableauError(SharedErrorCodes.InvalidFilterFieldValue, serverPm[InternalContract.ParameterId.InvalidValues]);\n    }\n    if (serverPm[InternalContract.ParameterId.InvalidAggFieldName]) {\n      throw new TableauError(SharedErrorCodes.InvalidAggregationFieldName, serverPm[InternalContract.ParameterId.InvalidAggFieldName]);\n    }\n    throw new TableauError(SharedErrorCodes.ServerError, 'Server Error');\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, IncludeDataValuesOption } from '@tableau/api-external-contract-js';\nimport {\n  ApiShowDataTableFormat,\n  DataTable as DataTableInternalContract,\n  DataTableReader as DataTableReaderInternalContract,\n  ExecuteParameters,\n  HighlightedMarksTable,\n  ParameterId,\n  SelectedMarksTable,\n  UnderlyingDataTable,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport { v4 as uuidv4 } from 'uuid';\nimport { TableauError } from '../../../ApiShared';\nimport { ExternalToInternalEnumMappings } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { Column, DataTable, MarkInfo } from '../../Models/GetDataModels';\nimport { DataTableReader } from '../../Models/GetDataTableReaderModels';\nimport { DataValueFactory } from '../../Utils/DataValueFactory';\nimport { GetDataService, GetDataType } from '../GetDataService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class GetDataServiceImpl extends ServiceImplBase implements GetDataService {\n  // The extension/embedding instance uses the same cache for all DataTableReaders.\n  private viewDataTableCacheId: string = uuidv4();\n\n  public get serviceName(): string {\n    return ServiceNames.GetData;\n  }\n\n  public getMaxRowLimit(): number {\n    return 10000;\n  }\n\n  public getViewDataTableCacheId(): string {\n    return this.viewDataTableCacheId;\n  }\n\n  private getLimitedMaxRows(requestedRows: number): number {\n    const rowCountLimit = this.getMaxRowLimit() + 1;\n    return requestedRows > 0 && requestedRows < rowCountLimit ? requestedRows : rowCountLimit;\n  }\n\n  public getUnderlyingDataAsync(\n    visualId: VisualId,\n    getType: GetDataType,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTable> {\n    // Create all of our parameters\n    const summaryData = getType === GetDataType.Summary;\n    const functionName = summaryData ? 'getSummaryDataAsync' : 'getUnderlyingDataAsync';\n    const verb = summaryData ? VerbId.GetDataSummaryData : VerbId.GetUnderlyingData;\n    const requestMaxRows = verb === VerbId.GetUnderlyingData ? this.getLimitedMaxRows(maxRows) : maxRows;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: functionName,\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.IgnoreAliases] = ignoreAliases;\n    parameters[ParameterId.IgnoreSelection] = ignoreSelection;\n    parameters[ParameterId.IncludeAllColumns] = includeAllColumns;\n    parameters[ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById);\n    parameters[ParameterId.MaxRows] = requestMaxRows;\n    parameters[ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption);\n\n    return this.execute(verb, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, responseData.isSummary);\n    });\n  }\n\n  public getSummaryDataReaderAsync(\n    visualId: VisualId,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTableReader> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getSummaryDataReaderAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.PageRowCount]: pageRowCount,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.IgnoreSelection]: ignoreSelection,\n      [ParameterId.IncludeAllColumns]: includeAllColumns,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetDataSummaryDataReader, parameters).then<DataTableReader>((response) => {\n      const responseData = response.result as DataTableReaderInternalContract;\n\n      return new DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, this._registryId);\n    });\n  }\n\n  public getSummaryColumnsInfoAsync(visualId: VisualId): Promise<Array<Contract.Column>> {\n    // Create all the parameters for GetDataType of Summary with 1 row, and only native values\n    // Then return just the columns\n    const verb = VerbId.GetDataSummaryData;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getSummaryColumnsInfoAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.IgnoreAliases]: true,\n      [ParameterId.IgnoreSelection]: true,\n      [ParameterId.IncludeAllColumns]: true,\n      [ParameterId.MaxRows]: 1,\n      [ParameterId.ShowDataTableFormat]: ApiShowDataTableFormat.NativeValuesOnly,\n    };\n\n    return this.execute(verb, parameters).then<Array<Contract.Column>>((response) => {\n      const underlyingDataTable = response.result as UnderlyingDataTable;\n      const dataTable = underlyingDataTable.data;\n      const columns = dataTable.headers.map((h) => new Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index));\n      return columns;\n    });\n  }\n\n  public getSelectedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getSelectedMarksAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetSelectedMarks, parameters).then<Contract.MarksCollection>((response) => {\n      const responseData = response.result as SelectedMarksTable;\n      return {\n        data: responseData.data.map((table) => this.processResultsTable(table, true)),\n      };\n    });\n  }\n\n  public getHighlightedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getHighlightedMarksAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetHighlightedMarks, parameters).then<Contract.MarksCollection>((response) => {\n      const responseData = response.result as HighlightedMarksTable;\n      return {\n        data: responseData.data.map((table) => this.processResultsTable(table, true)),\n      };\n    });\n  }\n\n  public getDataSourceDataAsync(\n    dataSourceId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getDataSourceDataAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.MaxRows]: this.getLimitedMaxRows(maxRows),\n      [ParameterId.ColumnsToInclude]: this.verifyIncludeColumnArray(columnsToInclude),\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetDataSourceData, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, false);\n    });\n  }\n\n  public getLogicalTableDataAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getLogicalTableDataAsync',\n      [ParameterId.ColumnsToInclude]: columnsToInclude,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.DataSourceId]: datasourceId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.MaxRows]: this.getLimitedMaxRows(maxRows),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetLogicalTableData, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, false);\n    });\n  }\n\n  public getLogicalTableDataReaderAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTableReader> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getLogicalTableDataReaderAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.DataSourceId]: datasourceId,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.PageRowCount]: pageRowCount,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetLogicalTableDataReader, parameters).then<DataTableReader>((response) => {\n      const responseData = response.result as DataTableReaderInternalContract;\n\n      return new DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, this._registryId);\n    });\n  }\n\n  public getUnderlyingTableDataAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getUnderlyingTableDataAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.IgnoreSelection]: ignoreSelection,\n      [ParameterId.IncludeAllColumns]: includeAllColumns,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.MaxRows]: this.getLimitedMaxRows(maxRows),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetUnderlyingTableData, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, false);\n    });\n  }\n\n  public getUnderlyingTableDataReaderAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getUnderlyingTableDataReaderAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.IgnoreSelection]: ignoreSelection,\n      [ParameterId.IncludeAllColumns]: includeAllColumns,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n      [ParameterId.PageRowCount]: pageRowCount,\n    };\n\n    return this.execute(VerbId.GetUnderlyingTableDataReader, parameters).then<DataTableReader>((response) => {\n      const responseData = response.result as DataTableReaderInternalContract;\n\n      return new DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, this._registryId);\n    });\n  }\n\n  private static summaryTableId = '';\n\n  public getPageAsync(tableId: string, pageNumber: number, pageSize: number): Promise<Contract.DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getPageAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.ViewDataTableId]: tableId,\n      [ParameterId.DataRowIndex]: pageNumber * pageSize,\n    };\n\n    return this.execute(VerbId.GetDataTableReaderPage, parameters).then<DataTable>((response) => {\n      const responseData = response.result as DataTableInternalContract;\n      return this.processResultsPage(responseData, tableId === GetDataServiceImpl.summaryTableId ? true : false);\n    });\n  }\n\n  public releaseAsync(tableId: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'release',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.ViewDataTableId]: tableId,\n    };\n\n    return this.execute(VerbId.ReleaseDataTableReader, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  private verifyIncludeColumnArray(columns: Array<string>): Array<string> {\n    // columns must be a valid array\n    if (!Array.isArray(columns)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'columnsToInclude and columnsToIncludeById must be valid arrays');\n    }\n\n    // Remove any duplicates from the input array\n    const columnsAsSet: Set<string> = new Set(columns);\n    return Array.from(columnsAsSet);\n  }\n\n  protected processResultsTable(responseData: DataTableInternalContract, isSummary: boolean): DataTable {\n    const headers = responseData.headers.map((h) => new Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index));\n\n    // TODO This should be controlled by a flag indicating whether this api will respond marks info or not\n    let marks;\n    if (responseData.marks) {\n      marks = responseData.marks.map((h) => new MarkInfo(h.type, h.color, h.tupleId));\n    }\n\n    // Limit+1 is our sentinal that underlying data contains more rows than user is allowed to fetch.\n    // Remove the last element so we always return MaxRowLimit\n    const isTotalRowCountLimited = isSummary === false && responseData.dataTable.length === this.getMaxRowLimit() + 1;\n    if (isTotalRowCountLimited) {\n      responseData.dataTable.length -= 1;\n    }\n\n    const table = responseData.dataTable.map((row) => {\n      return row.map((cell, index) => {\n        return DataValueFactory.MakeTableDataValue(cell, headers[index].dataType);\n      });\n    });\n\n    if (marks) {\n      return new DataTable(table, headers, table.length, isTotalRowCountLimited, isSummary, marks);\n    }\n    return new DataTable(table, headers, table.length, isTotalRowCountLimited, isSummary);\n  }\n\n  protected processResultsPage(responseData: DataTableInternalContract, isSummary: boolean): DataTable {\n    const headers = responseData.headers.map((h) => new Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index));\n\n    let marks;\n    if (responseData.marks) {\n      marks = responseData.marks.map((h) => new MarkInfo(h.type, h.color, h.tupleId));\n    }\n\n    const table = responseData.dataTable.map((row) => {\n      return row.map((cell, index) => {\n        return DataValueFactory.MakeTableDataValue(cell, headers[index].dataType);\n      });\n    });\n\n    if (marks) {\n      return new DataTable(table, headers, table.length, false, isSummary, marks);\n    }\n    return new DataTable(table, headers, table.length, false, isSummary);\n  }\n}\n","import { NotificationService } from '../NotificationService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { NotificationServiceImplBase } from './NotificationServiceImplBase';\n\nexport class NotificationServiceImpl extends NotificationServiceImplBase implements NotificationService {\n  public get serviceName(): string {\n    return ServiceNames.Notification;\n  }\n}\n","import { InternalApiDispatcher, Model, Notification, NotificationId } from '@tableau/api-internal-contract-js';\nimport { UnregisterFn } from '../NotificationService';\n\nexport class Registration {\n  public constructor(private _filterFn: (notificationModel: Model) => boolean, private _callbackFn: (notificationModel: Model) => void) {\n    // Nothing Here\n  }\n\n  public onNotification(notificationModel: Model): void {\n    if (this._filterFn(notificationModel)) {\n      this._callbackFn(notificationModel);\n    }\n  }\n}\n\nexport class NotificationServiceImplBase {\n  private _handlers: { [notificationId: string]: Array<Registration> };\n\n  public constructor(private dispatcher: InternalApiDispatcher) {\n    this._handlers = {};\n    this.dispatcher.registerNotificationHandler(this.onNotification.bind(this));\n  }\n\n  public registerHandler(id: NotificationId, filterFn: (model: Model) => boolean, handler: (model: Model) => void): UnregisterFn {\n    const handlers = this._handlers[id] || new Array<Registration>();\n    const registration = new Registration(filterFn, handler);\n    handlers.push(registration);\n    this._handlers[id] = handlers;\n    return () => this.removeRegistration(id, registration);\n  }\n\n  private hasHandlersForNotificationType(id: NotificationId): boolean {\n    // eslint-disable-next-line no-prototype-builtins\n    return this._handlers.hasOwnProperty(id);\n  }\n\n  private onNotification(notification: Notification): void {\n    if (!this.hasHandlersForNotificationType(notification.notificationId)) {\n      return;\n    }\n\n    // Go through and check for all the handlers of this particular notification\n    this._handlers[notification.notificationId].forEach((h) => h.onNotification(notification.data));\n  }\n\n  private removeRegistration(id: NotificationId, registration: Registration): void {\n    if (!this.hasHandlersForNotificationType(id)) {\n      return;\n    }\n\n    this._handlers[id] = this._handlers[id].filter((reg) => reg !== registration);\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, Model, ParameterId, ParameterInfo, SheetPath, VerbId } from '@tableau/api-internal-contract-js';\nimport { ParameterImpl } from '../../Impl/ParameterImpl';\nimport { TableauError } from '../../TableauError';\nimport { ParametersService } from '../ParametersService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ParametersServiceImpl extends ServiceImplBase implements ParametersService {\n  public get serviceName(): string {\n    return ServiceNames.Parameters;\n  }\n\n  public getParametersForSheetAsync(sheetPath: SheetPath): Promise<Array<ParameterImpl>> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'getParametersForSheetAsync',\n      [ParameterId.SheetPath]: sheetPath,\n    };\n\n    return this.getParametersAsync(parameters);\n  }\n\n  public getAllParametersAsync(): Promise<Array<ParameterImpl>> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'getParametersForSheetAsync',\n    };\n\n    return this.getParametersAsync(parameters);\n  }\n\n  private getParametersAsync(inputParameters: ExecuteParameters): Promise<Array<ParameterImpl>> {\n    return this.execute(VerbId.GetParametersForSheet, inputParameters).then((response) => {\n      const result = response.result as Array<ParameterInfo>;\n      return result.map((parameterInfo) => {\n        return new ParameterImpl(parameterInfo, this._registryId);\n      });\n    });\n  }\n\n  public changeParameterValueAsync(fieldName: string, newValue: string): Promise<ParameterInfo> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'changeParameterValueAsync',\n      [ParameterId.ParameterFieldName]: fieldName,\n      [ParameterId.ParameterValue]: newValue,\n    };\n\n    return this.execute(VerbId.ChangeParameterValue, parameters).then((response) => {\n      const result = response.result as ParameterInfo;\n      return result;\n    });\n  }\n\n  public findParameterByNameAsync(name: string): Promise<ParameterImpl | undefined> {\n    return this.findParameterAsync(name, undefined);\n  }\n\n  public findParameterByGlobalFieldNameAsync(fieldName: string): Promise<ParameterImpl | undefined> {\n    return this.findParameterAsync(undefined, fieldName);\n  }\n\n  private findParameterAsync(name: string | undefined, fieldName: string | undefined): Promise<ParameterImpl | undefined> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'findParameterAsync',\n    };\n    if (name !== undefined) {\n      parameters[ParameterId.ParameterCaption] = name;\n    } else if (fieldName !== undefined) {\n      parameters[ParameterId.ParameterFieldName] = fieldName;\n    } else {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'name or fieldName must be provided to find parameter');\n    }\n\n    return this.execute(VerbId.FindParameter, parameters).then((response) => {\n      const instanceOfParameterInfo = (object: Model): object is ParameterInfo => {\n        return 'fieldName' in object;\n      };\n\n      // We need to check to see if we got a valid response back again\n      if (instanceOfParameterInfo(response.result)) {\n        const result = response.result;\n        return new ParameterImpl(result, this._registryId);\n      } else {\n        return undefined;\n      }\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  ExecuteParameters,\n  ParameterId,\n  QuantitativeIncludedValues,\n  SelectOptions as SelectOptionsInternal,\n  SelectionUpdateType as SelectionUpdateTypeInternal,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport {\n  DimensionSelectionModel,\n  HierarchicalSelectionModel,\n  HoverTupleInteractionModel,\n  RangeSelectionModel,\n  SelectTuplesInteractionModel,\n  SelectionModelsContainer,\n  TupleSelectionModel,\n  ValueSelectionModel,\n} from '../../Models/SelectionModels';\nimport { TableauError } from '../../TableauError';\nimport { Param } from '../../Utils/Param';\nimport { SelectionService } from '../SelectionService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class SelectionServiceImpl extends ServiceImplBase implements SelectionService {\n  public get serviceName(): string {\n    return ServiceNames.Selection;\n  }\n\n  /**\n   * Method to clear all the selected marks for the given worksheet.\n   *\n   * @param visualId\n   */\n  public clearSelectedMarksAsync(visualId: VisualId): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'clearSelectedMarksAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.ClearSelectedMarks, parameters).then<void>((response) => {\n      return; // Expecting an empty model and hence the void response.\n    });\n  }\n\n  /**\n   * Method to select marks for the given worksheet.\n   *\n   * @param visualId\n   * @param selectionCriteria\n   * @param selectionUpdateType\n   */\n  public selectMarksByValueAsync(\n    visualId: VisualId,\n    selectionCriterias: Array<Contract.SelectionCriteria>,\n    selectionUpdateType: Contract.SelectionUpdateType,\n  ): Promise<void> {\n    if (selectionCriterias.length === 0) {\n      throw new TableauError(Contract.ErrorCodes.InvalidParameter, 'Selection criteria missing for selecting marks by value');\n    }\n\n    const selectionType: string = this.validateSelectionUpdateType(selectionUpdateType);\n    const selectionModelContainer: SelectionModelsContainer = this.parseSelectionMarks(selectionCriterias);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'selectMarksByValueAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.SelectionUpdateType]: selectionType,\n    };\n\n    if (selectionModelContainer.hierModelArr && selectionModelContainer.hierModelArr.length) {\n      parameters[ParameterId.HierValSelectionModels] = selectionModelContainer.hierModelArr;\n    }\n    if (selectionModelContainer.quantModelArr && selectionModelContainer.quantModelArr.length) {\n      parameters[ParameterId.QuantRangeSelectionModels] = selectionModelContainer.quantModelArr;\n    }\n    if (selectionModelContainer.dimModelArr && selectionModelContainer.dimModelArr.length) {\n      parameters[ParameterId.DimValSelectionModels] = selectionModelContainer.dimModelArr;\n    }\n\n    return this.execute(VerbId.SelectByValue, parameters).then<void>((response) => {\n      this.apiFilterHandlerCheckForCommandError(response.result as { [key: string]: string });\n      return;\n    });\n  }\n\n  /**\n   * Method to execute hover actions and render tooltip for a given tuple representing a mark in the visualization.\n   * If the tooltip parameter is included it will show the tooltip on hover. If not, no tooltip is shown.\n   *\n   * @param visualId\n   * @param hoveredTuple\n   * @param tooltip\n   * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error\n   */\n  public hoverTupleAsync(visualId: VisualId, hoveredTuple: number, tooltip?: Contract.TooltipContext): Promise<void> {\n    let interactionModel = new HoverTupleInteractionModel(visualId, hoveredTuple, tooltip);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'hoverTupleAsync',\n      [ParameterId.HoverTupleInteraction]: interactionModel,\n    };\n\n    return this.execute(VerbId.RaiseHoverTupleNotification, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  /**\n   * Method to modify selection, execute select actions and render tooltip for a given list of tuples representing a mark or marks in the visualization.\n   * If the tooltip parameter is included it will show the tooltip on select. If not, no tooltip is shown.\n   *\n   * @param visualId\n   * @param selectedTuples\n   * @param selectOption\n   * @param tooltip\n   * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error\n   */\n  public selectTuplesAsync(\n    visualId: VisualId,\n    selectedTuples: Array<number>,\n    selectOption: Contract.SelectOptions,\n    tooltip?: Contract.TooltipContext,\n  ): Promise<void> {\n    const option: string = this.validateSelectOption(selectOption);\n    let interactionModel = new SelectTuplesInteractionModel(visualId, selectedTuples, option, tooltip);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'selectTuplesAsync',\n      [ParameterId.SelectTuplesInteraction]: interactionModel,\n    };\n\n    return this.execute(VerbId.RaiseSelectTuplesNotification, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  private apiFilterHandlerCheckForCommandError(serverPm: { [key: string]: string }) {\n    if (!serverPm[ParameterId.ParameterError]) {\n      return;\n    }\n    if (serverPm[ParameterId.InvalidFields]) {\n      throw new TableauError(Contract.SharedErrorCodes.InvalidSelectionFieldName, serverPm[ParameterId.InvalidFields]);\n    }\n    if (serverPm[ParameterId.InvalidValues]) {\n      throw new TableauError(Contract.SharedErrorCodes.InvalidSelectionValue, serverPm[ParameterId.InvalidValues]);\n    }\n    if (serverPm[ParameterId.InvalidDates]) {\n      throw new TableauError(Contract.SharedErrorCodes.InvalidSelectionDate, serverPm[ParameterId.InvalidDates]);\n    }\n  }\n\n  /**\n   * Method to select marks for the given worksheet.\n   *\n   * @param visualId\n   * @param MarkInfo\n   * @param selectionUpdateType\n   */\n  public selectMarksByIdAsync(\n    visualId: VisualId,\n    marks: Array<Contract.MarkInfo>,\n    selectionUpdateType: Contract.SelectionUpdateType,\n  ): Promise<void> {\n    if (marks.length === 0) {\n      throw new TableauError(Contract.ErrorCodes.InvalidParameter, 'Marks info missing for selecting marks by Id');\n    }\n\n    const selectionType: string = this.validateSelectionUpdateType(selectionUpdateType);\n    const selectionModelContainer: SelectionModelsContainer = this.parseSelectionIds(marks);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'selectMarksByIdAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.SelectionUpdateType]: selectionType,\n      [ParameterId.Selection]: selectionModelContainer.selection,\n    };\n    return this.execute(VerbId.SelectByValue, parameters).then<void>((response) => {\n      // Expecting an empty model and hence the void response.\n      return;\n      // TODO Investigate the error response with multiple output params and throw error accordingly.\n    });\n  }\n\n  /**\n   * Method to prepare the pres models for selection by MarksInfo\n   * @param marks\n   */\n  private parseSelectionIds(marks: Array<Contract.MarkInfo>): SelectionModelsContainer {\n    const ids: Array<string> = [];\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n    for (let i = 0; i < marks.length; i++) {\n      const tupleId: number | undefined = marks[i].tupleId;\n      if (tupleId !== undefined && tupleId !== null) {\n        // If tuple id is provided use that instead of pair\n        ids.push(tupleId.toString()); // collect the tuple ids\n      } else {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'tupleId parsing error');\n      }\n    }\n    if (ids.length !== 0) {\n      // tuple ids based selection\n      const tupleSelectionModel: TupleSelectionModel = new TupleSelectionModel();\n      tupleSelectionModel.selectionType = 'tuples';\n      tupleSelectionModel.objectIds = ids;\n      selectionModelContainer.selection = tupleSelectionModel;\n    }\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to prepare the pres models for selection by values.\n   *\n   * Supports 3 types for selection:\n   * 1) Hierarchical value based selection\n   * 2) Range value based selection\n   * 3) Dimension value based selection\n   *\n   * @param marks\n   */\n  private parseSelectionMarks(selectionCriterias: Array<Contract.SelectionCriteria>): SelectionModelsContainer {\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n\n    for (let i = 0; i < selectionCriterias.length; i++) {\n      const st = selectionCriterias[i];\n      if (!(st.fieldName && st.value !== undefined && st.value !== null)) {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'Selection Criteria parsing error');\n      }\n\n      const catRegex = new RegExp('([[A-Za-z0-9]+]).*', 'g');\n      const rangeOption = st.value as Contract.RangeValue;\n      if (catRegex.test(st.fieldName)) {\n        // Hierarchical value selection\n        const hierModel: HierarchicalSelectionModel = this.addToParamsList(st.fieldName, st.value) as HierarchicalSelectionModel;\n        selectionModelContainer.hierModelArr.push(hierModel);\n      } else if (rangeOption.min !== undefined && rangeOption.max !== undefined) {\n        // Range value selection\n        const quantModel: RangeSelectionModel = this.addToRangeParamsList(st.fieldName, rangeOption);\n        selectionModelContainer.quantModelArr.push(quantModel);\n      } else {\n        // Dimension value selection\n        const dimModel: DimensionSelectionModel = this.addToParamsList(st.fieldName, st.value) as DimensionSelectionModel;\n        selectionModelContainer.dimModelArr.push(dimModel);\n      }\n    }\n\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to transform the key value pair into value based pres model object.\n   *\n   * @param valueSelectionModel\n   * @param fieldName\n   * @param value\n   */\n  private addToParamsList(fieldName: string, value: Contract.CategoricalValue | Contract.RangeValue): ValueSelectionModel {\n    const valueSelectionModel: ValueSelectionModel = new ValueSelectionModel();\n    const markValues: Array<string> = [];\n\n    if (value instanceof Array) {\n      const valueArr: Array<string> = value;\n      for (let i = 0; i < valueArr.length; i++) {\n        markValues.push(Param.serializeParameterValue(valueArr[i]));\n      }\n    } else {\n      markValues.push(Param.serializeParameterValue(value));\n    }\n\n    valueSelectionModel.qualifiedFieldCaption = fieldName;\n    valueSelectionModel.selectValues = markValues;\n    return valueSelectionModel;\n  }\n\n  /**\n   * Method to transform the key value pair into range based selection pres model.\n   *\n   * TODO: Need to handle the parsing of date type values.\n   *\n   * @param valueSelectionModel\n   * @param fieldName\n   * @param value\n   */\n  private addToRangeParamsList(fieldName: string, value: Contract.RangeValue): RangeSelectionModel {\n    const rangeSelectionModel: RangeSelectionModel = new RangeSelectionModel();\n    rangeSelectionModel.qualifiedFieldCaption = fieldName;\n    if (value.max !== undefined && value.max !== null) {\n      rangeSelectionModel.maxValue = Param.serializeParameterValue(value.max);\n    }\n    if (value.min !== undefined && value.min !== null) {\n      rangeSelectionModel.minValue = Param.serializeParameterValue(value.min);\n    }\n    rangeSelectionModel.included = this.validateNullOptionType(value.nullOption);\n    return rangeSelectionModel;\n  }\n\n  /**\n   * Method to validate the selection update type.\n   *\n   * @param selectionUpdateType\n   */\n  private validateSelectionUpdateType(selectionUpdateType: Contract.SelectionUpdateType): string {\n    if (selectionUpdateType === Contract.SelectionUpdateType.Replace) {\n      return SelectionUpdateTypeInternal.Replace;\n    } else if (selectionUpdateType === Contract.SelectionUpdateType.Add) {\n      return SelectionUpdateTypeInternal.Add;\n    } else if (selectionUpdateType === Contract.SelectionUpdateType.Remove) {\n      return SelectionUpdateTypeInternal.Remove;\n    }\n    return SelectionUpdateTypeInternal.Replace;\n  }\n\n  /**\n   * Method to validate the include type for range selection.\n   *\n   * @param nullOption\n   */\n  private validateNullOptionType(nullOption: Contract.FilterNullOption | undefined): string {\n    if (nullOption) {\n      if (nullOption === Contract.FilterNullOption.NullValues) {\n        return QuantitativeIncludedValues.IncludeNull;\n      } else if (nullOption === Contract.FilterNullOption.NonNullValues) {\n        return QuantitativeIncludedValues.IncludeNonNull;\n      } else if (nullOption === Contract.FilterNullOption.AllValues) {\n        return QuantitativeIncludedValues.IncludeAll;\n      }\n    }\n\n    return QuantitativeIncludedValues.IncludeAll;\n  }\n\n  /**\n   * Method to validate the select option.\n   *\n   * @param selectOption\n   */\n  private validateSelectOption(selectOption: Contract.SelectOptions): string {\n    if (selectOption === Contract.SelectOptions.Simple) {\n      return SelectOptionsInternal.Simple;\n    } else if (selectOption === Contract.SelectOptions.Toggle) {\n      return SelectOptionsInternal.Toggle;\n    } else {\n      throw new TableauError(Contract.ErrorCodes.InvalidParameter, 'Only simple and toggle select options are currently supported');\n    }\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ExecuteResponse, InternalApiDispatcher, InternalTableauError, VerbId } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../../EnumMappings/InternalToExternalEnumMappings';\nimport { TableauError } from '../../TableauError';\nimport { ShouldThrow } from '../../Utils/EnumConverter';\n\n/**\n * Each ServceImpl should extend this base class for the sake of\n * proper error handling.  This base handles the conversion\n * from internal errors to external errors that we throw to developers\n */\nexport class ServiceImplBase {\n  public constructor(private _dispatcher: InternalApiDispatcher, protected _registryId: number) {}\n\n  protected execute(verb: VerbId, params: ExecuteParameters): Promise<ExecuteResponse> {\n    return this._dispatcher.execute(verb, params).catch((error) => {\n      // Any internal error that comes from the dispatcher should be converted\n      // to an external error using the enum mapper for error codes.\n      const internalError = error as InternalTableauError;\n      const externalErrorCode: ErrorCodes = InternalToExternalEnumMappings.errorCode.convert(internalError.errorCode, ShouldThrow.No);\n      throw new TableauError(externalErrorCode, internalError.message);\n    });\n  }\n}\n","import { SheetSize } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { SizeService } from '../SizeService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class SizeServiceImpl extends ServiceImplBase implements SizeService {\n  public get serviceName(): string {\n    return ServiceNames.Size;\n  }\n\n  changeSizeAsync(name: string, newSize: SheetSize): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'changeSizeAsync',\n      [ParameterId.SheetName]: name,\n      [ParameterId.MinHeight]: newSize.minSize?.height || 0,\n      [ParameterId.MinWidth]: newSize.minSize?.width || 0,\n      [ParameterId.MaxHeight]: newSize.maxSize?.height || 0,\n      [ParameterId.MaxWidth]: newSize.maxSize?.width || 0,\n    };\n\n    return this.execute(VerbId.SetSheetSize, parameters).then<void>((_response) => {\n      return;\n    });\n  }\n}\n","import { ExecuteParameters, ParameterId, StoryPointModel, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { StoryActivationService } from '../StoryActivationService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class StoryActivationServiceImpl extends ServiceImplBase implements StoryActivationService {\n  public get serviceName(): string {\n    return ServiceNames.StoryActivation;\n  }\n\n  activateNextStoryPointAsync(): Promise<void> {\n    const verb = VerbId.ActivateNextStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activateNextStoryPointAsync',\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  activatePreviousStoryPointAsync(): Promise<void> {\n    const verb = VerbId.ActivatePreviousStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activatePreviousStoryPointAsync',\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  activateStoryPointAsync(index: number): Promise<void> {\n    const verb = VerbId.ActivateStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activateStoryPointAsync',\n    };\n    parameters[ParameterId.StoryPointIndex] = index;\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  revertStoryPointAsync(index: number): Promise<StoryPointModel> {\n    const verb = VerbId.RevertStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'revertStoryPointAsync',\n    };\n    parameters[ParameterId.StoryPointIndex] = index;\n\n    return this.execute(verb, parameters).then<StoryPointModel>((response) => {\n      return response.result as StoryPointModel;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ParameterId, VerbId, VisualId, VisualSpecification } from '@tableau/api-internal-contract-js';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { VisualModelService } from '../VisualModelService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class VisualModelServiceImpl extends ServiceImplBase implements VisualModelService {\n  public get serviceName(): string {\n    return ServiceNames.VisualModel;\n  }\n\n  public getVisualSpecificationAsync(visualId: VisualId): Promise<Contract.VisualSpecification> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getVisualSpecificationAsync',\n      [ParameterId.WorksheetName]: visualId.worksheet,\n    };\n\n    return this.execute(VerbId.GetVisualSpecification, parameters).then<Contract.VisualSpecification>((response) => {\n      const result = response.result as VisualSpecification;\n      return result;\n    });\n  }\n}\n","import { CustomViewModel, ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { CustomViewImpl } from '../../Impl/CustomViewImpl';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { VizService } from '../VizService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class VizServiceImpl extends ServiceImplBase implements VizService {\n  public get serviceName(): string {\n    return ServiceNames.Viz;\n  }\n\n  public createVizImageAsync(inputSpec: object): Promise<string> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'createVizImageAsync',\n      [ParameterId.VizAPIInputJson]: JSON.stringify(inputSpec),\n    };\n\n    return this.execute(VerbId.VizAPI, parameters).then((response) => {\n      const result = response.result as string;\n      return result;\n    });\n  }\n\n  public activateSheetAsync(name: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activateSheetAsync',\n      [ParameterId.SwitchToSheetName]: name,\n    };\n\n    return this.execute(VerbId.ActivateSheet, parameters).then(() => {\n      return;\n    });\n  }\n\n  public getCustomViewsAsync(): Promise<Array<CustomViewImpl>> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getCustomViewsAsync',\n    };\n\n    return this.execute(VerbId.GetCustomViews, parameters).then<Array<CustomViewImpl>>((response) => {\n      const customViews = response.result as Array<CustomViewModel>;\n      return customViews.map((customView: CustomViewModel) => {\n        return new CustomViewImpl(customView, this._registryId);\n      });\n    });\n  }\n\n  public showCustomViewAsync(customViewName: string): Promise<CustomViewImpl> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'showCustomViewAsync',\n      [ParameterId.CustomViewName]: customViewName,\n    };\n\n    return this.execute(VerbId.ShowCustomView, parameters).then<CustomViewImpl>((response) => {\n      const customView = response.result as CustomViewModel;\n      return new CustomViewImpl(customView, this._registryId);\n    });\n  }\n\n  public removeCustomViewAsync(customViewName: string): Promise<CustomViewImpl> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'removeCustomViewAsync',\n      [ParameterId.CustomViewName]: customViewName,\n    };\n\n    return this.execute(VerbId.RemoveCustomView, parameters).then<CustomViewImpl>((response) => {\n      const customView = response.result as CustomViewModel;\n      return new CustomViewImpl(customView, this._registryId);\n    });\n  }\n\n  public saveCustomViewAsync(customViewName: string): Promise<CustomViewImpl> {\n    // CustomViewIsDefault is a required parameter, but our API has not been updated to allow it to be specified yet.\n    // We should add a 'default' parameter to the interface.\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'saveCustomViewAsync',\n      [ParameterId.CustomViewName]: customViewName,\n      [ParameterId.CustomViewIsDefault]: false,\n    };\n\n    return this.execute(VerbId.SaveWorkbookAsCustomView, parameters).then<CustomViewImpl>((response) => {\n      const customView = response.result as CustomViewModel;\n      return new CustomViewImpl(customView, this._registryId);\n    });\n  }\n\n  public setActiveCustomViewAsDefaultAsync(): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'setActiveCustomViewAsDefaultAsync',\n    };\n\n    return this.execute(VerbId.SetActiveCustomViewAsDefault, parameters).then(() => {\n      return;\n    });\n  }\n\n  public saveAsync(customView: CustomViewImpl): Promise<CustomViewImpl> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'saveAsync',\n      [ParameterId.CustomViewLuid]: customView.luid,\n      [ParameterId.CustomViewName]: customView.name,\n      [ParameterId.CustomViewIsDefault]: customView.isDefault,\n      [ParameterId.CustomViewIsPublic]: customView.shared,\n    };\n\n    return this.execute(VerbId.UpdateCustomView, parameters).then<CustomViewImpl>((response) => {\n      const customView = response.result as CustomViewModel;\n      return new CustomViewImpl(customView, this._registryId);\n    });\n  }\n\n  public getCurrentSrcAsync(): Promise<string> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getCurrentSrcAsync',\n    };\n\n    return this.execute(VerbId.GetCurrentSrc, parameters).then((response) => response.result as string);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardObjectVisibilityType } from '@tableau/api-external-contract-js';\nimport { ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ExternalToInternalEnumMappings as ExternalEnumConverter } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { DashboardObjectImpl } from '../../Impl/DashboardObjectImpl';\nimport { ErrorHelpers } from '../../Utils/ErrorHelpers';\nimport { Param } from '../../Utils/Param';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ZoneService } from '../ZoneService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ZoneServiceImpl extends ServiceImplBase implements ZoneService {\n  public get serviceName(): string {\n    return ServiceNames.Zone;\n  }\n\n  public setVisibilityAsync(\n    dashboard: string,\n    dashboardZoneMap: Map<number, DashboardObjectImpl>,\n    zoneVisibilityMap: Contract.ZoneVisibilityMap,\n  ): Promise<void> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'setVisibilityAsync',\n      [ParameterId.Dashboard]: dashboard,\n      [ParameterId.ZoneIdsVisibilityMap]: {},\n    };\n\n    // zoneVisibilityMap can be either an object or a Map - convert it to a Map\n    const parameterAsMap = Param.convertParameterToMap(zoneVisibilityMap, 'zoneVisibilityMap');\n\n    parameterAsMap.forEach((value, key) => {\n      ErrorHelpers.verifyZoneIsValid(dashboardZoneMap, Number.parseInt(key, 10));\n      ErrorHelpers.verifyEnumValue<DashboardObjectVisibilityType>(value, DashboardObjectVisibilityType, 'DashboardObjectVisibilityType');\n      parameters[ParameterId.ZoneIdsVisibilityMap][key] = ExternalEnumConverter.setVisibilityType.convert(value);\n    });\n\n    return this.execute(VerbId.SetZoneVisibility, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public moveAndResizeAsync(\n    dashboard: string,\n    dashboardZoneMap: Map<number, DashboardObjectImpl>,\n    dashboardObjectPositionAndSizeUpdateArray: Contract.DashboardObjectPositionAndSizeUpdateArray,\n  ): Promise<void> {\n    const parameters = {\n      [ParameterId.Dashboard]: dashboard,\n      [ParameterId.DashboardObjectPositionAndSizeUpdateList]: dashboardObjectPositionAndSizeUpdateArray,\n    };\n\n    dashboardObjectPositionAndSizeUpdateArray.forEach((dashboardObject: Contract.DashboardObjectPositionAndSizeUpdate) => {\n      ErrorHelpers.verifyZoneIsValidAndFloating(dashboardZoneMap, dashboardObject.dashboardObjectID);\n      ErrorHelpers.verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate(dashboardObject);\n    });\n\n    return this.execute(VerbId.MoveAndResizeZones, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableInfo } from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of a table summary.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class TableSummary implements Contract.TableSummary {\n  public constructor(private _tableInfo: TableInfo) {}\n\n  public get name(): string {\n    return this._tableInfo.name;\n  }\n\n  public get id(): string {\n    return this._tableInfo.id;\n  }\n\n  public get connectionId(): string {\n    return this._tableInfo.connectionId;\n  }\n\n  public get customSQL(): string | undefined {\n    return this._tableInfo.customSQL;\n  }\n}\n","import { EmbeddingErrorCodes, ErrorCodes, SharedErrorCodes } from '@tableau/api-external-contract-js';\n\n/**\n * Custom error class that extends the default JavaScript Error object.\n * This allows us to provide a field with a specific error code\n * so that developers can more easily programmatically respond\n * to error scenarios.\n */\nexport class TableauError extends Error {\n  public constructor(private _errorCode: ErrorCodes | EmbeddingErrorCodes | SharedErrorCodes, message: string) {\n    super(`${_errorCode}: ${message}`);\n\n    /*tslint:disable-next-line */\n    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    // Error inheritance does not work propertly when compiling to ES5, this is a workaround to force\n    // the proto chain to be built correctly.  See the github link above for details.\n    Object.setPrototypeOf(this, TableauError.prototype);\n  }\n\n  public get errorCode(): ErrorCodes | EmbeddingErrorCodes | SharedErrorCodes {\n    return this._errorCode;\n  }\n}\n","import * as InternalContract from '@tableau/api-internal-contract-js';\nimport { DataValue } from '../Models/GetDataModels';\n\n/**\n * In version 2 of the interface, we should collapse value into nativeValue, and do all this work over\n * in the platform.\n */\nexport class DataValueFactory {\n  public static MakeParameterDataValue(internalDataValue: InternalContract.DataValue, dataType: InternalContract.DataType): DataValue {\n    // Parameter values are all strings, convert from string to value\n    return new DataValue(\n      internalDataValue.value,\n      InternalContract.DataTypeConverter.convertStringValueToNativeValue(internalDataValue.value, dataType),\n      internalDataValue.formattedValue,\n    );\n  }\n\n  public static MakeFilterDataValue(internalDataValue: InternalContract.DataValue): DataValue {\n    // Filters already have native type in value, just use that for nativeValue also\n    return new DataValue(internalDataValue.value, internalDataValue.value, internalDataValue.formattedValue);\n  }\n\n  public static MakeTableDataValue(internalDataValue: InternalContract.DataValue, dataType: InternalContract.DataType): DataValue {\n    // DataTables contain boolean | number | string | date as string | '%null%\n    // convertValueToNativeValue converts dates as string to dates, and any special to null\n    // (boolean, numbers, strings are passed through)\n    // Because of IncludeDataValuesOption - we can have undefined values, which are different than any special\n    return new DataValue(\n      internalDataValue.value,\n      internalDataValue.value !== undefined\n        ? InternalContract.DataTypeConverter.convertValueToNativeValue(internalDataValue.value, dataType)\n        : undefined,\n      internalDataValue.formattedValue,\n    );\n  }\n}\n","/**\n * A Promise wrapper class allowing for resolving/rejecting the Promise outside the context of its constructor.\n *\n * @export\n * @class Deferred\n * @template TResolve The type used to resolve the promise.\n * @template TReject The type used to reject the promise. Defaults to any.\n * @link https://stackoverflow.com/a/34637436\n */\nexport class Deferred<TResolve, TReject = any> {\n  private _promise: Promise<TResolve>;\n  private _resolve: (response: TResolve | PromiseLike<TResolve>) => void;\n  private _reject: (reason?: TReject) => void;\n\n  /**\n   * Creates an instance of Deferred.\n   */\n  constructor() {\n    this._promise = new Promise<TResolve>((resolve, reject) => {\n      this._resolve = resolve;\n      this._reject = reject;\n    });\n  }\n\n  /**\n   * Gets the Promise.\n   *\n   * @readonly\n   * @type {Promise<TResolve>}\n   */\n  get promise(): Promise<TResolve> {\n    return this._promise;\n  }\n\n  /**\n   * Resolves the wrapped Promise.\n   *\n   * @param {(TResolve | PromiseLike<TResolve>)} response The argument to be resolved by the Promise.\n   * @returns {*}  {void}\n   */\n  resolve(response: TResolve | PromiseLike<TResolve>): void {\n    if (!this._resolve) {\n      return;\n    }\n\n    this._resolve(response);\n  }\n\n  /**\n   *\n   *\n   * @param {TReject} [reason] The reason why the Promise rejected.\n   * @returns {*}  {void}\n   */\n  reject(reason?: TReject): void {\n    if (!this._reject) {\n      return;\n    }\n\n    this._reject(reason);\n  }\n}\n\nexport const UnregisterTimeoutInMilliseconds = 30000;\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * This class converts from a source enum value to destination enum\n * value given a mapping from source to destination when constructed.\n *\n * Note: This exact same class is defined in api-core.  Given its small\n * nature, it is not worth having in a separate project to share this between\n * api-core and api-shared.  If more utility functionality is added that is used by api-core\n * and api-shared but has no other dependecies, a utiltity project might be merited,\n * and this class could be moved.\n */\nexport class EnumConverter<TSourceType extends string, TDestinationType> {\n  public constructor(private _mappings: { [enumVal: string]: TDestinationType }, private _defaultVal?: TDestinationType) {}\n\n  public convert(enumVal: TSourceType, throwIfMissing: ShouldThrow = ShouldThrow.Yes): TDestinationType {\n    if (this._mappings.hasOwnProperty(enumVal)) {\n      return this._mappings[enumVal as string];\n    }\n\n    if (this._defaultVal !== undefined && throwIfMissing !== ShouldThrow.Yes) {\n      return this._defaultVal;\n    }\n\n    throw new TableauError(ErrorCodes.InternalError, `Enum Mapping not found for: ${enumVal}`);\n  }\n}\n\nexport enum ShouldThrow {\n  Yes = 'yes',\n  No = 'no',\n}\n","import {\n  DashboardObjectPositionAndSizeUpdate,\n  ExportDataOptions,\n  ExportPDFOptions as ExternalExportPDFOptions,\n  ExportScenariosForPDFAndPowerPoint,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  SharedErrorCodes,\n} from '@tableau/api-external-contract-js';\nimport { DashboardObjectImpl } from '../Impl/DashboardObjectImpl';\nimport { TableauError } from '../TableauError';\nimport { Param } from './Param';\n\ninterface EnumLike {\n  toString(): string;\n}\n\n/**\n * This class is used to construct common errors throughout the external\n * projects (api-shared, extensions-api, etc.).  It has some duplication with\n * the ErrorHelpers class in api-core, but is separate due to the need to throw\n * an external TableauError vs. an InternalTableauError.\n */\nexport class ErrorHelpers {\n  /**\n   * Throws with code InternalError.\n   *\n   * @param apiName name of api that was called.\n   */\n  public static apiNotImplemented(apiName: string): TableauError {\n    return new TableauError(SharedErrorCodes.InternalError, `${apiName} API not yet implemented.`);\n  }\n\n  /**\n   * Throws an internal error if argument is null or undefined.\n   *\n   * @param argumentValue value to verify\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyInternalValue(argumentValue: any, argumentName: string) {\n    if (argumentValue === null || argumentValue === undefined) {\n      throw new TableauError(SharedErrorCodes.InternalError, `${argumentValue} is invalid value for: ${argumentName}`);\n    }\n  }\n\n  /**\n   * Throws an InvalidParameter error if argument is null or undefined.\n   *\n   * @param argumentValue value to verify\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyParameter(argumentValue: any, argumentName: string) {\n    if (argumentValue === null || argumentValue === undefined) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${argumentValue} is invalid value for parameter: ${argumentName}`);\n    }\n  }\n\n  /**\n   * Throws an InvalidParameter error if argument is not the specified type.\n   * For objects, it just tests that it is an object\n   *\n   * @param argumentValue value to verify\n   * @param expectedType expected result of typeof\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyParameterType(argumentValue: any, expectedType: string, argumentName: string) {\n    if (typeof argumentValue !== expectedType) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${argumentValue} has invalid type for parameter: ${argumentName}.`);\n    }\n  }\n\n  /**\n   * Throws an InvalidParameter error if argument is empty string, null or undefined.\n   *\n   * @param argumentValue value to verify\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyStringParameter(argumentValue: string, argumentName: string) {\n    if (argumentValue === null || argumentValue === undefined || argumentValue === '') {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${argumentValue} is invalid value for paramter: ${argumentName}`);\n    }\n  }\n\n  /**\n   * Verifies passed value is a valid value for that enum.\n   * Throws an InvalidParameter error if the enum value is not valid.\n   *\n   * String enums are {string : string} dictionaries which are not reverse mappable\n   * This is an ugly workaround\n   *\n   * @param enumValue value to verify\n   * @param enumType enum to verify against\n   * @param enumName enum name for clear error message\n   */\n  /*tslint:disable-next-line */\n  public static verifyEnumValue<EnumType extends EnumLike>(enumValue: EnumType, enumType: any, enumName: string) {\n    let isValid = false;\n    Object.keys(enumType).forEach((enumKey) => {\n      if (enumType[enumKey] === enumValue.toString()) {\n        isValid = true;\n      }\n    });\n\n    if (!isValid) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${enumValue} is invalid value for enum: ${enumName}.`);\n    }\n  }\n\n  /**\n   * Verifies passed value is between [min, max) ... min <= value < max\n   * Throws an InvalidParameter error if the value is not valid.\n   *\n   *\n   * @param value value to verify\n   * @param min   value must be >= min\n   * @param max   value must be < max\n   */\n  /*tslint:disable-next-line */\n  public static verifyRange(value: number, min: number, max: number) {\n    let isValid = min <= value && value < max;\n\n    if (!isValid) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${value} is invalid value for range: [${min}..${max})`);\n    }\n  }\n\n  /**\n   * Verifies the params min and max for applying range filter.\n   * Throws with error code InvalidParameter if range is invalid.\n   *\n   * @param min range min\n   * @param max range max\n   */\n  /*tslint:disable-next-line */\n  public static verifyRangeParamType(min: any, max: any): void {\n    if (!min && !max) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, at least one of min or max is required.');\n    }\n\n    if (min && !Param.isTypeNumber(min) && !Param.isTypeDate(min)) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        'Unexpected invalid param value, only Date and number are allowed for parameter min.',\n      );\n    }\n\n    if (max && !Param.isTypeNumber(max) && !Param.isTypeDate(max)) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        'Unexpected invalid param value, only Date and number are allowed for parameter max.',\n      );\n    }\n\n    if (min && max && typeof min !== typeof max) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        'Unexpected invalid param value, parameters min and max should be of the same type.',\n      );\n    }\n  }\n\n  /**\n   * Verifies that the zoneId is present in the current dashboard.\n   * Throws with error code InvalidParameter if either condition is false.\n   *\n   * @param dashboardZoneMap A map of zoneId's to the corresponding dashboard object.\n   * @param zoneID ZoneId to be validated\n   */\n  public static verifyZoneIsValid(dashboardZoneMap: Map<number, DashboardObjectImpl>, zoneID: number): void {\n    if (dashboardZoneMap.has(zoneID)) {\n      return;\n    }\n\n    throw new TableauError(\n      SharedErrorCodes.InvalidParameter,\n      `Unexpected invalid param value, Dashboard Object Id: ${zoneID} is not present in dashboard.`,\n    );\n  }\n\n  /**\n   * Verifies that the zone is present and floating in the current dashboard.\n   * Throws with error code InvalidParameter if either condition is false.\n   *\n   * @param dashboardZoneMap A map of zoneId's to the corresponding dashboard object.\n   * @param zoneID ZoneId to be validated\n   */\n  public static verifyZoneIsValidAndFloating(dashboardZoneMap: Map<number, DashboardObjectImpl>, zoneID: number): void {\n    if (dashboardZoneMap.has(zoneID) && dashboardZoneMap.get(zoneID)!.isFloating) {\n      return;\n    }\n\n    throw new TableauError(\n      SharedErrorCodes.InvalidParameter,\n      `Unexpected invalid param value, Dashboard Object Id: ${zoneID} is not present or is a fixed zone in the dashboard.`,\n    );\n  }\n\n  /**\n   * Verifies that width and height are > 0 for each DashboardObjectPositionAndSizeUpdate object.\n   * Throws with error code InvalidParameter if either condition is false.\n   *\n   * @param dashboardObjectPositionAndSizeUpdate DashboardObjectPositionAndSizeUpdate object for which width and height will be validated\n   */\n  public static verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate(\n    dashboardObjectPositionAndSizeUpdate: DashboardObjectPositionAndSizeUpdate,\n  ): void {\n    if (dashboardObjectPositionAndSizeUpdate.width < 0 || dashboardObjectPositionAndSizeUpdate.height < 0) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        `Unexpected invalid param value for dashboard object ID ${dashboardObjectPositionAndSizeUpdate.dashboardObjectID}:` +\n          ` negative widths and heights are not allowed.`,\n      );\n    }\n  }\n\n  /**\n   * Verifies is the given sheet name is in the list of sheets names allowed for exporting.\n   * Throws with error code InvalidParameter if the condition above is false.\n   *\n   * @param exportableSheetNames A list of sheet names allowed for exporting\n   * @param sheetName the name of the sheet selected for export\n   */\n  public static verifySheetName(exportableSheetNames: Array<string>, sheetName: string) {\n    if (!exportableSheetNames.includes(sheetName)) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidSelectionSheet,\n        'sheetName parameter must belong to a worksheet within the current view',\n      );\n    }\n  }\n\n  /**\n   * Verifies the ExportDataOptions object\n   * Throws with error code InvalidParameter if the parameter is not of ExportDataOptions type.\n   *\n   * @param options The ExportDataOptions object used to configure the output CSV file for exportDataAsync.\n   */\n  public static verifyExportDataOptions(options: ExportDataOptions): void {\n    if (\n      (!Param.isNullOrUndefined(options.ignoreAliases) && !Param.isTypeBool(options.ignoreAliases)) ||\n      (!Param.isNullOrUndefined(options.columnsToIncludeById) && !Array.isArray(options.columnsToIncludeById))\n    )\n      throw new TableauError(SharedErrorCodes.InvalidParameter, 'options paramater must be of type ExportDataOptions');\n  }\n\n  /**\n   * Verifies if the sheet names are included in any of the export scenarios.\n   * Throws with error code InvalidParameter if the parameter is not an array.\n   * Throws with error code InvalidSelectionSheet if there are array entries that dont exist or if there is mixing between sheets from the dashboard and sheet from the workbook.\n   *\n   * @param sheetNames List of sheet names selected for exporting.\n   * @param exportScenarios an object containing the current sheet name, exportable sheets from the dashboard, and exportable sheets from the workbook.\n   */\n  public static verifySheetNamesForPDFAndPPT(sheetNames: Array<string>, exportScenarios: ExportScenariosForPDFAndPowerPoint): void {\n    if (!Array.isArray(sheetNames)) throw new TableauError(SharedErrorCodes.InvalidParameter, 'sheetNames parameter must be an array');\n    if (sheetNames.length === 0) throw new TableauError(SharedErrorCodes.InternalError, 'sheetNames should not be empty');\n\n    const isIncludedInDashboard = sheetNames.every((sheetName: string) =>\n      exportScenarios.exportableSheetNamesFromDashboard.includes(sheetName),\n    );\n    if (isIncludedInDashboard) {\n      return;\n    }\n    const isIncludedInWorkbook = sheetNames.every((sheetName: string) =>\n      exportScenarios.exportableSheetNamesFromWorkbook.includes(sheetName),\n    );\n    if (isIncludedInWorkbook) {\n      return;\n    }\n    const isCurrentSheet = sheetNames.length === 1 && sheetNames[0] === exportScenarios.currentSheetName;\n    if (isCurrentSheet) {\n      return;\n    }\n\n    // Export requirement: all sheet names must be included in the list of exportable sheets in the dashboard or\n    // all sheet names must be included in the list of exportable sheets in the workbook, or the sheet name is the current sheet\n    throw new TableauError(\n      SharedErrorCodes.InvalidSelectionSheet,\n      'sheetNames parameter must have all its entries be exportable sheet names from the dashboard or all its entries be exportable sheet names from the workbook',\n    );\n  }\n\n  /**\n   * Verifies the external ExportPDFOptions object's properties.\n   * Throws with error code InvalidParameter if the parameter is not of external ExportPDFOptions type.\n   *\n   * @param options The external user-facing ExportPDFOptions object used to configure the output PDF file for exportPDFAsync.\n   */\n  public static verifyExportPDFOptions(options: ExternalExportPDFOptions) {\n    try {\n      this.verifyEnumValue<PrintOrientation>(options.orientation, PrintOrientation, 'PrintOrientation');\n      this.verifyEnumValue<PrintPageSize>(options.pageSize, PrintPageSize, 'PrintPageSize');\n      this.verifyEnumValue<PrintScaling>(options.scaling, PrintScaling, 'PrintScaling');\n    } catch {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, 'options parameter must be of type ExportPDFOptions');\n    }\n  }\n}\n","import {\n  ExportLayoutOptions,\n  ExportPDFOptions as InternalExportPDFOptions,\n  FitPages,\n  PageOrientation,\n  PageScalingOption,\n  PageSizeOption,\n  ScaleMode,\n  ScalingSelection,\n} from '@tableau/api-internal-contract-js';\nimport {\n  ExportDataOptions,\n  ExportPDFOptions as ExternalExportPDFOptions,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  SharedErrorCodes,\n} from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * Helper methods for Export APIs.\n *\n * @class ExportHelpers\n */\nexport class ExportHelpers {\n  public static DefaultDataOptions: ExportDataOptions = {\n    ignoreAliases: false,\n    columnsToIncludeById: [],\n  };\n\n  public static DefaultPDFOptions: ExternalExportPDFOptions = {\n    scaling: PrintScaling.Automatic,\n    pageSize: PrintPageSize.Letter,\n    orientation: PrintOrientation.Portrait,\n  };\n\n  private static DefaultLayoutOptions: ExportLayoutOptions = {\n    imageHeight: 0,\n    imageWidth: 0,\n    pageFitHorizontal: 1,\n    pageFitVertical: 1,\n    pageOrientationOption: PageOrientation.Portrait,\n    pageScaleMode: ScaleMode.ScaleAuto,\n    pageScalePercent: 100,\n    pageSizeOption: PageSizeOption.Letter,\n  };\n\n  /**\n   * Modifies the internal ExportPDFOptions' properties based on the given PDF export configuration.\n   * This method will construct the internal ExportPDFOptions identically to how the 'Export PDF' dialog constructs the ExportPdfOptionsPresModel.\n   * See the handleExportClick method in @browser-clients/export-pdf-options-dialog for reference.\n   *\n   * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n   * @param externalExportPdfOptions The external ExportPDFOptions user-facing object passed to exportPDFAsync.\n   * @param sheetNames The list of sheets selected for export.\n   */\n  public static updateInternalExportPDFOptions(\n    internalExportPdfOptions: InternalExportPDFOptions,\n    externalExportPdfOptions: ExternalExportPDFOptions,\n    sheetNames: Array<string>,\n  ): void {\n    internalExportPdfOptions.currentSheet = sheetNames[0];\n    this.updateExportLayoutOptions(internalExportPdfOptions, externalExportPdfOptions);\n    this.updateSheetOptions(internalExportPdfOptions, sheetNames);\n  }\n\n  /**\n   * Helper method for updateInternalExportPDFOptions.\n   * Modifies the exportLayoutOptions property of the internal ExportPDFOptions based on the external ExportPDFOptions.\n   * See the getExportLayoutOptions method in @browser-clients/export-pdf-options-dialog for reference.\n   *\n   * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n   * @param externalExportPdfOptions The external ExportPDFOptions user-facing object passed to exportPDFAsync.\n   */\n  public static updateExportLayoutOptions(\n    internalExportPdfOptions: InternalExportPDFOptions,\n    externalExportPdfOptions: ExternalExportPDFOptions,\n  ): void {\n    const exportLayoutOptions = internalExportPdfOptions.exportLayoutOptions;\n\n    // setting the image height and width properties to their default values\n    exportLayoutOptions.imageHeight = this.DefaultLayoutOptions.imageHeight;\n    exportLayoutOptions.imageWidth = this.DefaultLayoutOptions.imageWidth;\n\n    //  setting the orientation value for the exportLayoutOptions\n    switch (externalExportPdfOptions.orientation) {\n      case PrintOrientation.Landscape:\n        exportLayoutOptions.pageOrientationOption = PageOrientation.Landscape;\n        break;\n      case PrintOrientation.Portrait:\n        exportLayoutOptions.pageOrientationOption = PageOrientation.Portrait;\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'invalid orientation for ExportPDFOption');\n    }\n\n    // setting the page size value for the exportLayoutOptions\n    switch (externalExportPdfOptions.pageSize) {\n      case PrintPageSize.A3:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.A3;\n        break;\n      case PrintPageSize.A4:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.A4;\n        break;\n      case PrintPageSize.A5:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.A5;\n        break;\n      case PrintPageSize.B4:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.B4;\n        break;\n      case PrintPageSize.B5:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.B5;\n        break;\n      case PrintPageSize.Executive:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Executive;\n        break;\n      case PrintPageSize.Folio:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Folio;\n        break;\n      case PrintPageSize.Ledger:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Ledger;\n        break;\n      case PrintPageSize.Legal:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Legal;\n        break;\n      case PrintPageSize.Letter:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Letter;\n        break;\n      case PrintPageSize.Note:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Note;\n        break;\n      case PrintPageSize.Quarto:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Quarto;\n        break;\n      case PrintPageSize.Statement:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Statement;\n        break;\n      case PrintPageSize.Tabloid:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Tabloid;\n        break;\n      case PrintPageSize.Unspecified:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Unspecified;\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'invalid pageSize for ExportPDFOption');\n    }\n\n    // setting the scaling values for the exportLayoutOptions\n    switch (externalExportPdfOptions.scaling) {\n      case PrintScaling.AtMost1PageHigh:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitOneHigh);\n        break;\n      case PrintScaling.AtMost1PageWide:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitOneWide);\n        break;\n      case PrintScaling.AtMost2PagesHigh:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitTwoHigh);\n        break;\n      case PrintScaling.AtMost2PagesWide:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitTwoWide);\n        break;\n      case PrintScaling.Automatic:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePctAuto);\n        break;\n      case PrintScaling.Perc100:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct100);\n        break;\n      case PrintScaling.Perc200:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct200);\n        break;\n      case PrintScaling.Perc25:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct25);\n        break;\n      case PrintScaling.Perc400:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct400);\n        break;\n      case PrintScaling.Perc50:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct50);\n        break;\n      case PrintScaling.Perc60:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct60);\n        break;\n      case PrintScaling.Perc75:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct75);\n        break;\n      case PrintScaling.Perc80:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct80);\n        break;\n      case PrintScaling.Perc90:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct90);\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'invalid scaling for ExportPDFOption');\n    }\n  }\n\n  /**\n   * Helper method for updateInternalExportPDFOptions.\n   * Modifies the sheetOptions property of the internal ExportPDFOptions based on the sheets selected for export.\n   * See the handleExportClick method in @browser-clients/export-pdf-options-dialog for reference.\n   *\n   * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n   * @param sheetNames The list of sheets selected for export.\n   */\n  public static updateSheetOptions(internalExportPdfOptions: InternalExportPDFOptions, sheetNames: Array<string>): void {\n    const { exportLayoutOptions, sheetOptions } = internalExportPdfOptions;\n    // updating the export layouts options for each sheet and selecting sheet for export if included in list\n    for (const sheetOption of sheetOptions) {\n      sheetOption.exportLayoutOptions = exportLayoutOptions;\n      sheetOption.isSelected = sheetNames.includes(sheetOption.sheet);\n    }\n  }\n\n  /**\n   * Helper method for updateExportLayoutOptons.\n   * This method is a spoof of the getFitAndScaleValues method used in @browser-clients/export-pdf-options to set the exportLayoutOptions' scaling properties.\n   * In the future, this file should be refactored to import the method directly from @browser-clients/export-pdf-options.\n   *\n   * @param scalingSelection string used for setting the exportLayoutOptions based on the PrintScaling property from the ExternalExportPDFOptions.\n   * @param exportLayoutOptions the ExportLayoutOptions used by the internal ExportPDFOptions pres model.\n   */\n  public static setFitAndScaleValues(exportLayoutOptions: ExportLayoutOptions, scalingSelection: ScalingSelection): void {\n    let { pageFitHorizontal, pageFitVertical, pageScaleMode, pageScalePercent } = this.DefaultLayoutOptions;\n\n    const fitMatch = this.fitRegex.exec(scalingSelection);\n    const percentMatch = this.pctRegex.exec(scalingSelection);\n\n    if (fitMatch) {\n      [pageFitHorizontal, pageFitVertical] = fitMatch.slice(1).map((value) => Number(value));\n      pageScaleMode = ScaleMode.ScaleFitPages;\n    } else if (percentMatch) {\n      [pageScalePercent] = percentMatch.slice(1).map((value) => Number(value));\n      pageScaleMode = ScaleMode.ScalePercentage;\n    }\n\n    // getFitAndScaleValues returns the properties below, but instead this method will set them.\n    exportLayoutOptions.pageFitHorizontal = pageFitHorizontal;\n    exportLayoutOptions.pageFitVertical = pageFitVertical;\n    exportLayoutOptions.pageScaleMode = pageScaleMode;\n    exportLayoutOptions.pageScalePercent = pageScalePercent;\n  }\n\n  private static fitRegex = new RegExp('fit([0-9]+)x([0-9]+)');\n  private static pctRegex = new RegExp('pct([0-9]+)');\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from './ErrorHelpers';\n\nexport class Param {\n  /**\n   * serializes the date into the format that the server expects.\n   * @param date the date to serialize\n   */\n  public static serializeDateForPlatform(date: Date): string {\n    const year: number = date.getUTCFullYear();\n    const month: number = date.getUTCMonth() + 1;\n    const day: number = date.getUTCDate();\n    const hh: number = date.getUTCHours();\n    const mm: number = date.getUTCMinutes();\n    const sec: number = date.getUTCSeconds();\n    return `${year}-${month}-${day} ${hh}:${mm}:${sec}`;\n  }\n\n  public static serializeBooleanForPlatform(bool: boolean): string {\n    return bool ? 'true' : 'false';\n  }\n\n  public static serializeNumberForPlatform(num: number): string {\n    return num.toString(10);\n  }\n\n  /**\n   * Verifies the input is a number\n   */\n  /* tslint:disable-next-line:no-any */\n  public static isTypeNumber(input: any): boolean {\n    return typeof input === 'number' || input instanceof Number;\n  }\n\n  /**\n   * Verifies the input is a Date\n   */\n  /* tslint:disable-next-line:no-any */\n  public static isTypeDate(input: any): boolean {\n    return input instanceof Date;\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static isTypeString(input: any): boolean {\n    return typeof input === 'string' || input instanceof String;\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static isTypeBool(input: any): boolean {\n    return typeof input === 'boolean' || input instanceof Boolean;\n  }\n\n  /**\n   * Determines if the input is null or undefined\n   */\n  /* tslint:disable-next-line:no-any */\n  public static isNullOrUndefined(input: any): boolean {\n    return input === null || input === undefined;\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static serializeParameterValue(value: any): string {\n    if (Param.isTypeNumber(value)) {\n      return Param.serializeNumberForPlatform(value as number);\n    } else if (Param.isTypeDate(value)) {\n      return Param.serializeDateForPlatform(value as Date);\n    } else if (Param.isTypeBool(value)) {\n      return Param.serializeBooleanForPlatform(value as boolean);\n    } else if (Param.isTypeString(value)) {\n      return value;\n    } else {\n      throw new TableauError(ErrorCodes.InternalError, `Unexpected invalid value for: ${value}`);\n    }\n  }\n\n  /**\n   * Verifies that the parameter is already a Map, or converts an object to a Map.\n   * If the parameter is an object, we convert it to a Map using Object.entries.\n   * @throws if the parameter is not an object or Map\n   */\n  // tslint:disable-next-line:no-any\n  public static convertParameterToMap(param: object, paramName: string): Map<any, any> {\n    ErrorHelpers.verifyParameterType(param, 'object', paramName);\n    if (Array.isArray(param)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, `Expecting object or Map for: ${paramName}.`);\n    }\n\n    return param instanceof Map ? param : new Map(Object.entries(param));\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static tryParseNumber(value: any): { parsed?: number; success: boolean } {\n    if (Param.isNullOrUndefined(value)) {\n      return { success: false };\n    }\n\n    if (Param.isTypeNumber(value)) {\n      return { parsed: value as number, success: true };\n    }\n\n    const valueString = value.toString();\n    if (valueString === 'NaN') {\n      // 'NaN' parses as NaN which is indistinguishable from a failed parse.\n      return { parsed: NaN, success: true };\n    }\n\n    const parsed = parseFloat(valueString);\n    if (isNaN(parsed)) {\n      return { success: false };\n    }\n\n    return { parsed, success: true };\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { SheetInfo, SheetType, SizeConstraint } from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../TableauError';\n\nexport class SheetUtils {\n  // This is a direct port from SheetSize.cs - SheetSizeFactory\n  public static getSheetSizeFromSizeConstraints(sizeConstraint: SizeConstraint): Contract.SheetSize {\n    const { minWidth, minHeight, maxWidth, maxHeight } = sizeConstraint;\n\n    if (minHeight === 0 && minWidth === 0) {\n      if (maxHeight === 0 && maxWidth === 0) {\n        return {\n          behavior: Contract.SheetSizeBehavior.Automatic,\n        };\n      }\n\n      return {\n        behavior: Contract.SheetSizeBehavior.AtMost,\n        maxSize: { width: maxWidth, height: maxHeight },\n      };\n    }\n\n    if (maxHeight === 0 && maxWidth === 0) {\n      return {\n        behavior: Contract.SheetSizeBehavior.AtLeast,\n        minSize: { width: minWidth, height: minHeight },\n      };\n    }\n\n    if (maxHeight === minHeight && maxWidth === minWidth && minWidth > 0) {\n      return {\n        behavior: Contract.SheetSizeBehavior.Exactly,\n        minSize: { width: minWidth, height: minHeight },\n        maxSize: { width: minWidth, height: minHeight },\n      };\n    }\n\n    // 'Fit Width' for a DSD layout\n    const isDsdLayout = minWidth === 0 && maxWidth === 0;\n\n    return {\n      behavior: Contract.SheetSizeBehavior.Range,\n      minSize: { width: minWidth, height: minHeight },\n      maxSize: { width: isDsdLayout ? 2147483647 : maxWidth, height: maxHeight },\n    };\n  }\n\n  public static createAutomaticSize(): Contract.SheetSize {\n    let behavior = Contract.SheetSizeBehavior.Automatic;\n    let minSize = { width: 0, height: 0 };\n    let maxSize = { width: 0, height: 0 };\n    return { behavior, minSize, maxSize };\n  }\n\n  public static getPublishedSheetInfoByName(name: string, sheetInfos: Array<SheetInfo>): SheetInfo | undefined {\n    const sheetInfo = sheetInfos.find((sheet) => sheet.name === name);\n    return sheetInfo;\n  }\n\n  public static getSheetTypeEnum(internalSheetType: SheetType): Contract.SheetType {\n    let sheetType: Contract.SheetType;\n    switch (internalSheetType) {\n      case SheetType.Worksheet: {\n        sheetType = Contract.SheetType.Worksheet;\n        break;\n      }\n      case SheetType.Dashboard: {\n        sheetType = Contract.SheetType.Dashboard;\n        break;\n      }\n      case SheetType.Story: {\n        sheetType = Contract.SheetType.Story;\n        break;\n      }\n      default: {\n        throw new TableauError(Contract.SharedErrorCodes.ServerError, 'Invalid SheetType');\n      }\n    }\n    return sheetType;\n  }\n\n  public static isValidSheetSize(sizeObject: Contract.Size | Contract.SheetSize): sizeObject is Contract.SheetSize {\n    return (<Contract.SheetSize>sizeObject).behavior !== undefined;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\nimport { Deferred, UnregisterTimeoutInMilliseconds } from './Deferred';\n\n/**\n * A Deferred wrapper class adding functionality to reject unresponsive promises after timeout\n *\n * this class handles two things:\n\n *    1. Adds timeout logic for deferred\n *    2. It blocks multiple calls from executing at the same time.\n *\n * @export\n * @class ShortLivedDeferred\n * @template TResolve The type used to resolve the promise.\n * @template TReject The type used to reject the promise. Defaults to any.\n *\n */\nexport class ShortLivedDeferred<TResolve, TReject = any> {\n  private _deferred: Deferred<TResolve, TReject> | undefined;\n  private _timeoutId;\n  constructor(private _timeoutInMilliseconds = UnregisterTimeoutInMilliseconds) {}\n\n  public getNewPromiseOrThrowIfBusy(): Promise<TResolve> {\n    if (this._deferred) {\n      throw new TableauError(Contract.SharedErrorCodes.ApiExecutionError, 'This api cannot be executed till previous call is resolved.');\n    }\n    this._deferred = new Deferred();\n\n    this._timeoutId = setTimeout(() => {\n      const error = new TableauError(\n        Contract.SharedErrorCodes.Timeout,\n        `Api failed to complete in ${this._timeoutInMilliseconds / 1000} seconds`,\n      );\n      this.reject(error);\n    }, this._timeoutInMilliseconds);\n\n    return this._deferred.promise;\n  }\n\n  public resolve(response: TResolve | PromiseLike<TResolve>): void {\n    if (this._deferred) {\n      clearTimeout(this._timeoutId);\n      this._deferred.resolve(response);\n      this._deferred = undefined;\n    }\n  }\n\n  public reject(error: any): void {\n    if (this._deferred) {\n      clearTimeout(this._timeoutId);\n      this._deferred.reject(error);\n      this._deferred = undefined;\n    }\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from './TableauError';\nimport { VersionNumberContract } from './VersionNumberContract';\n\n/**\n * Represents the current version of the extensions, embedding\n * and extensions-api-types library\n */\nexport class VersionNumber implements VersionNumberContract {\n  public major: number;\n  public minor: number;\n  public fix: number;\n  public build: number;\n  public isAlpha: boolean;\n\n  // private constructor so everyone uses the singleton instance\n  // build numbers have this form: M.m.f-pre.N\n  public constructor(versionString: string, isAlpha: boolean) {\n    const partStr = versionString.split('-');\n    this.build = this.getBuildNumber(partStr[1]);\n    versionString = partStr[0];\n\n    const parts = versionString.split('.').map((p) => parseInt(p, 10));\n    if (parts.length !== 3) {\n      throw new TableauError(ErrorCodes.InternalError, `Invalid version number: ${versionString}`);\n    }\n\n    this.major = parts[0];\n    this.minor = parts[1];\n    this.fix = parts[2];\n    this.isAlpha = isAlpha;\n  }\n\n  private getBuildNumber(preReleaseString: string): number {\n    const noBuildNumber = -1;\n    if (!preReleaseString) {\n      return noBuildNumber;\n    }\n\n    // The preRelease string has this form: pre.N, but we don't depend on the actual string being 'pre'\n    const partStr = preReleaseString.split('.');\n    return partStr[1] ? parseInt(partStr[1], 10) : noBuildNumber;\n  }\n\n  public get formattedValue(): string {\n    return `${this.major}.${this.minor}.${this.fix}`;\n  }\n\n  public get fullFormattedValue(): string {\n    return `${this.major}.${this.minor}.${this.fix}-pre.${this.build}`;\n  }\n}\n","import {\n  CreateExternalCompatibleVersionConverter,\n  ExecuteParameters,\n  ExecuteResponse,\n  ExternalContractVersionConverter,\n  InternalApiDispatcher,\n  INTERNAL_CONTRACT_VERSION,\n  Notification,\n  NotificationHandler,\n  VerbId,\n  VersionLessThan,\n  VersionNumber,\n} from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of the InternalApiDispatcher which supports upgrading and downgrading the input\n * internal contract to the version that this module is built against\n *\n * @class VersionedExternalApiDispatcher\n * @implements {InternalApiDispatcher}\n */\nexport class VersionedExternalApiDispatcher implements InternalApiDispatcher {\n  private _versionConverter: ExternalContractVersionConverter;\n  private _notificationHandlers: Array<NotificationHandler>;\n\n  /**\n   * Creates a new instance of the VersionedExternalApiDispatcher\n   * We have multiple version converting dispatchers that work together.\n   * If needed, the VersionedExternalApiDispatcher wraps either the InternalApiDispatcher (desktop)\n   * or the CrossFrameDispatcher (server).\n   * The Internal/CrossFrame dispatchers handle an updated platform with an older external library.\n   * (The CrossFrameDispatcher sends messages across the frame, and it is handled by the PresLayerHandler.)\n   * Meanwhile, the VersionedExternalApiDispatcher handles an updated external library with an older platform.\n\n   * @param _apiDelegateDispatcher The delegate that does the actual work.\n   * @param platformVersionNumber The version of the internal contract which the platform module is using.\n   * This number will be used to figure out how to downgrade incoming commands and upgrade the results\n   */\n  public constructor(private _apiDelegateDispatcher: InternalApiDispatcher, platformVersionNumber: VersionNumber) {\n    this._versionConverter = CreateExternalCompatibleVersionConverter(INTERNAL_CONTRACT_VERSION, platformVersionNumber);\n\n    this._notificationHandlers = [];\n    _apiDelegateDispatcher.registerNotificationHandler((notification: Notification): void => {\n      if (this._notificationHandlers.length === 0) {\n        return;\n      }\n      const upgradedNotification = this._versionConverter.upgradeNotification(notification);\n      this._notificationHandlers.forEach((handler) => {\n        handler(upgradedNotification);\n      });\n    });\n  }\n\n  public static needsVersionConverter(platformVersion: VersionNumber): boolean {\n    // If our platform is less than external library version, then we need a converter\n    return VersionLessThan(platformVersion, INTERNAL_CONTRACT_VERSION);\n  }\n\n  public execute(verb: VerbId, parameters: ExecuteParameters): Promise<ExecuteResponse> {\n    try {\n      const downgradeParameters = this._versionConverter.downgradeExecuteCall(verb, parameters);\n      return this._apiDelegateDispatcher.execute(downgradeParameters.verb, downgradeParameters.parameters).then((response) => {\n        const upgradeResponse = this._versionConverter.upgradeExecuteReturn(response, verb, parameters);\n        return upgradeResponse;\n      });\n    } catch (e) {\n      return Promise.reject(e);\n    }\n  }\n\n  public registerNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers.push(handler);\n  }\n\n  public unregisterNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers = this._notificationHandlers.filter((h) => h !== handler);\n  }\n}\n","export { default as v1 } from './v1.js';\nexport { default as v3 } from './v3.js';\nexport { default as v4 } from './v4.js';\nexport { default as v5 } from './v5.js';\nexport { default as NIL } from './nil.js';\nexport { default as version } from './version.js';\nexport { default as validate } from './validate.js';\nexport { default as stringify } from './stringify.js';\nexport { default as parse } from './parse.js';","/*\n * Browser-compatible JavaScript MD5\n *\n * Modification of JavaScript MD5\n * https://github.com/blueimp/JavaScript-MD5\n *\n * Copyright 2011, Sebastian Tschan\n * https://blueimp.net\n *\n * Licensed under the MIT license:\n * https://opensource.org/licenses/MIT\n *\n * Based on\n * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message\n * Digest Algorithm, as defined in RFC 1321.\n * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for more info.\n */\nfunction md5(bytes) {\n  if (typeof bytes === 'string') {\n    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\n\n    bytes = new Uint8Array(msg.length);\n\n    for (var i = 0; i < msg.length; ++i) {\n      bytes[i] = msg.charCodeAt(i);\n    }\n  }\n\n  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));\n}\n/*\n * Convert an array of little-endian words to an array of bytes\n */\n\n\nfunction md5ToHexEncodedArray(input) {\n  var output = [];\n  var length32 = input.length * 32;\n  var hexTab = '0123456789abcdef';\n\n  for (var i = 0; i < length32; i += 8) {\n    var x = input[i >> 5] >>> i % 32 & 0xff;\n    var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);\n    output.push(hex);\n  }\n\n  return output;\n}\n/**\n * Calculate output length with padding and bit length\n */\n\n\nfunction getOutputLength(inputLength8) {\n  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;\n}\n/*\n * Calculate the MD5 of an array of little-endian words, and a bit length.\n */\n\n\nfunction wordsToMd5(x, len) {\n  /* append padding */\n  x[len >> 5] |= 0x80 << len % 32;\n  x[getOutputLength(len) - 1] = len;\n  var a = 1732584193;\n  var b = -271733879;\n  var c = -1732584194;\n  var d = 271733878;\n\n  for (var i = 0; i < x.length; i += 16) {\n    var olda = a;\n    var oldb = b;\n    var oldc = c;\n    var oldd = d;\n    a = md5ff(a, b, c, d, x[i], 7, -680876936);\n    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);\n    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);\n    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);\n    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);\n    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);\n    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);\n    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);\n    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);\n    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);\n    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);\n    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);\n    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);\n    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);\n    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);\n    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);\n    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);\n    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);\n    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);\n    b = md5gg(b, c, d, a, x[i], 20, -373897302);\n    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);\n    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);\n    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);\n    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);\n    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);\n    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);\n    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);\n    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);\n    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);\n    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);\n    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);\n    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);\n    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);\n    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);\n    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);\n    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);\n    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);\n    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);\n    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);\n    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);\n    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);\n    d = md5hh(d, a, b, c, x[i], 11, -358537222);\n    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);\n    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);\n    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);\n    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);\n    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);\n    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);\n    a = md5ii(a, b, c, d, x[i], 6, -198630844);\n    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);\n    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);\n    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);\n    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);\n    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);\n    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);\n    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);\n    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);\n    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);\n    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);\n    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);\n    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);\n    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);\n    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);\n    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);\n    a = safeAdd(a, olda);\n    b = safeAdd(b, oldb);\n    c = safeAdd(c, oldc);\n    d = safeAdd(d, oldd);\n  }\n\n  return [a, b, c, d];\n}\n/*\n * Convert an array bytes to an array of little-endian words\n * Characters >255 have their high-byte silently ignored.\n */\n\n\nfunction bytesToWords(input) {\n  if (input.length === 0) {\n    return [];\n  }\n\n  var length8 = input.length * 8;\n  var output = new Uint32Array(getOutputLength(length8));\n\n  for (var i = 0; i < length8; i += 8) {\n    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;\n  }\n\n  return output;\n}\n/*\n * Add integers, wrapping at 2^32. This uses 16-bit operations internally\n * to work around bugs in some JS interpreters.\n */\n\n\nfunction safeAdd(x, y) {\n  var lsw = (x & 0xffff) + (y & 0xffff);\n  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n  return msw << 16 | lsw & 0xffff;\n}\n/*\n * Bitwise rotate a 32-bit number to the left.\n */\n\n\nfunction bitRotateLeft(num, cnt) {\n  return num << cnt | num >>> 32 - cnt;\n}\n/*\n * These functions implement the four basic operations the algorithm uses.\n */\n\n\nfunction md5cmn(q, a, b, x, s, t) {\n  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);\n}\n\nfunction md5ff(a, b, c, d, x, s, t) {\n  return md5cmn(b & c | ~b & d, a, b, x, s, t);\n}\n\nfunction md5gg(a, b, c, d, x, s, t) {\n  return md5cmn(b & d | c & ~d, a, b, x, s, t);\n}\n\nfunction md5hh(a, b, c, d, x, s, t) {\n  return md5cmn(b ^ c ^ d, a, b, x, s, t);\n}\n\nfunction md5ii(a, b, c, d, x, s, t) {\n  return md5cmn(c ^ (b | ~d), a, b, x, s, t);\n}\n\nexport default md5;","export default '00000000-0000-0000-0000-000000000000';","import validate from './validate.js';\n\nfunction parse(uuid) {\n  if (!validate(uuid)) {\n    throw TypeError('Invalid UUID');\n  }\n\n  var v;\n  var arr = new Uint8Array(16); // Parse ########-....-....-....-............\n\n  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;\n  arr[1] = v >>> 16 & 0xff;\n  arr[2] = v >>> 8 & 0xff;\n  arr[3] = v & 0xff; // Parse ........-####-....-....-............\n\n  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;\n  arr[5] = v & 0xff; // Parse ........-....-####-....-............\n\n  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;\n  arr[7] = v & 0xff; // Parse ........-....-....-####-............\n\n  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;\n  arr[9] = v & 0xff; // Parse ........-....-....-....-############\n  // (Use \"/\" to avoid 32-bit truncation when bit-shifting high-order bytes)\n\n  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;\n  arr[11] = v / 0x100000000 & 0xff;\n  arr[12] = v >>> 24 & 0xff;\n  arr[13] = v >>> 16 & 0xff;\n  arr[14] = v >>> 8 & 0xff;\n  arr[15] = v & 0xff;\n  return arr;\n}\n\nexport default parse;","export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nvar getRandomValues;\nvar rnds8 = new Uint8Array(16);\nexport default function rng() {\n  // lazy load so that environments that need to polyfill have a chance to do so\n  if (!getRandomValues) {\n    // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation. Also,\n    // find the complete implementation of crypto (msCrypto) on IE11.\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\n\n    if (!getRandomValues) {\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n    }\n  }\n\n  return getRandomValues(rnds8);\n}","// Adapted from Chris Veness' SHA1 code at\n// http://www.movable-type.co.uk/scripts/sha1.html\nfunction f(s, x, y, z) {\n  switch (s) {\n    case 0:\n      return x & y ^ ~x & z;\n\n    case 1:\n      return x ^ y ^ z;\n\n    case 2:\n      return x & y ^ x & z ^ y & z;\n\n    case 3:\n      return x ^ y ^ z;\n  }\n}\n\nfunction ROTL(x, n) {\n  return x << n | x >>> 32 - n;\n}\n\nfunction sha1(bytes) {\n  var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];\n  var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];\n\n  if (typeof bytes === 'string') {\n    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\n\n    bytes = [];\n\n    for (var i = 0; i < msg.length; ++i) {\n      bytes.push(msg.charCodeAt(i));\n    }\n  } else if (!Array.isArray(bytes)) {\n    // Convert Array-like to Array\n    bytes = Array.prototype.slice.call(bytes);\n  }\n\n  bytes.push(0x80);\n  var l = bytes.length / 4 + 2;\n  var N = Math.ceil(l / 16);\n  var M = new Array(N);\n\n  for (var _i = 0; _i < N; ++_i) {\n    var arr = new Uint32Array(16);\n\n    for (var j = 0; j < 16; ++j) {\n      arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];\n    }\n\n    M[_i] = arr;\n  }\n\n  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);\n  M[N - 1][14] = Math.floor(M[N - 1][14]);\n  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;\n\n  for (var _i2 = 0; _i2 < N; ++_i2) {\n    var W = new Uint32Array(80);\n\n    for (var t = 0; t < 16; ++t) {\n      W[t] = M[_i2][t];\n    }\n\n    for (var _t = 16; _t < 80; ++_t) {\n      W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);\n    }\n\n    var a = H[0];\n    var b = H[1];\n    var c = H[2];\n    var d = H[3];\n    var e = H[4];\n\n    for (var _t2 = 0; _t2 < 80; ++_t2) {\n      var s = Math.floor(_t2 / 20);\n      var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;\n      e = d;\n      d = c;\n      c = ROTL(b, 30) >>> 0;\n      b = a;\n      a = T;\n    }\n\n    H[0] = H[0] + a >>> 0;\n    H[1] = H[1] + b >>> 0;\n    H[2] = H[2] + c >>> 0;\n    H[3] = H[3] + d >>> 0;\n    H[4] = H[4] + e >>> 0;\n  }\n\n  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];\n}\n\nexport default sha1;","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nvar byteToHex = [];\n\nfor (var i = 0; i < 256; ++i) {\n  byteToHex.push((i + 0x100).toString(16).substr(1));\n}\n\nfunction stringify(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  // Note: Be careful editing this code!  It's been tuned for performance\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one\n  // of the following:\n  // - One or more input array values don't map to a hex octet (leading to\n  // \"undefined\" in the uuid)\n  // - Invalid input values for the RFC `version` or `variant` fields\n\n  if (!validate(uuid)) {\n    throw TypeError('Stringified UUID is invalid');\n  }\n\n  return uuid;\n}\n\nexport default stringify;","import rng from './rng.js';\nimport stringify from './stringify.js'; // **`v1()` - Generate time-based UUID**\n//\n// Inspired by https://github.com/LiosK/UUID.js\n// and http://docs.python.org/library/uuid.html\n\nvar _nodeId;\n\nvar _clockseq; // Previous uuid creation time\n\n\nvar _lastMSecs = 0;\nvar _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details\n\nfunction v1(options, buf, offset) {\n  var i = buf && offset || 0;\n  var b = buf || new Array(16);\n  options = options || {};\n  var node = options.node || _nodeId;\n  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not\n  // specified.  We do this lazily to minimize issues related to insufficient\n  // system entropy.  See #189\n\n  if (node == null || clockseq == null) {\n    var seedBytes = options.random || (options.rng || rng)();\n\n    if (node == null) {\n      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\n      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];\n    }\n\n    if (clockseq == null) {\n      // Per 4.2.2, randomize (14 bit) clockseq\n      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;\n    }\n  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,\n  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so\n  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\n  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\n\n\n  var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock\n  // cycle to simulate higher resolution clock\n\n  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)\n\n  var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression\n\n  if (dt < 0 && options.clockseq === undefined) {\n    clockseq = clockseq + 1 & 0x3fff;\n  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\n  // time interval\n\n\n  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\n    nsecs = 0;\n  } // Per 4.2.1.2 Throw error if too many uuids are requested\n\n\n  if (nsecs >= 10000) {\n    throw new Error(\"uuid.v1(): Can't create more than 10M uuids/sec\");\n  }\n\n  _lastMSecs = msecs;\n  _lastNSecs = nsecs;\n  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\n\n  msecs += 12219292800000; // `time_low`\n\n  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\n  b[i++] = tl >>> 24 & 0xff;\n  b[i++] = tl >>> 16 & 0xff;\n  b[i++] = tl >>> 8 & 0xff;\n  b[i++] = tl & 0xff; // `time_mid`\n\n  var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;\n  b[i++] = tmh >>> 8 & 0xff;\n  b[i++] = tmh & 0xff; // `time_high_and_version`\n\n  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\n\n  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\n\n  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`\n\n  b[i++] = clockseq & 0xff; // `node`\n\n  for (var n = 0; n < 6; ++n) {\n    b[i + n] = node[n];\n  }\n\n  return buf || stringify(b);\n}\n\nexport default v1;","import v35 from './v35.js';\nimport md5 from './md5.js';\nvar v3 = v35('v3', 0x30, md5);\nexport default v3;","import stringify from './stringify.js';\nimport parse from './parse.js';\n\nfunction stringToBytes(str) {\n  str = unescape(encodeURIComponent(str)); // UTF8 escape\n\n  var bytes = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    bytes.push(str.charCodeAt(i));\n  }\n\n  return bytes;\n}\n\nexport var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';\nexport var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';\nexport default function (name, version, hashfunc) {\n  function generateUUID(value, namespace, buf, offset) {\n    if (typeof value === 'string') {\n      value = stringToBytes(value);\n    }\n\n    if (typeof namespace === 'string') {\n      namespace = parse(namespace);\n    }\n\n    if (namespace.length !== 16) {\n      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');\n    } // Compute hash of namespace and value, Per 4.3\n    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =\n    // hashfunc([...namespace, ... value])`\n\n\n    var bytes = new Uint8Array(16 + value.length);\n    bytes.set(namespace);\n    bytes.set(value, namespace.length);\n    bytes = hashfunc(bytes);\n    bytes[6] = bytes[6] & 0x0f | version;\n    bytes[8] = bytes[8] & 0x3f | 0x80;\n\n    if (buf) {\n      offset = offset || 0;\n\n      for (var i = 0; i < 16; ++i) {\n        buf[offset + i] = bytes[i];\n      }\n\n      return buf;\n    }\n\n    return stringify(bytes);\n  } // Function#name is not settable on some platforms (#270)\n\n\n  try {\n    generateUUID.name = name; // eslint-disable-next-line no-empty\n  } catch (err) {} // For CommonJS default export support\n\n\n  generateUUID.DNS = DNS;\n  generateUUID.URL = URL;\n  return generateUUID;\n}","import rng from './rng.js';\nimport stringify from './stringify.js';\n\nfunction v4(options, buf, offset) {\n  options = options || {};\n  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n  rnds[6] = rnds[6] & 0x0f | 0x40;\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n  if (buf) {\n    offset = offset || 0;\n\n    for (var i = 0; i < 16; ++i) {\n      buf[offset + i] = rnds[i];\n    }\n\n    return buf;\n  }\n\n  return stringify(rnds);\n}\n\nexport default v4;","import v35 from './v35.js';\nimport sha1 from './sha1.js';\nvar v5 = v35('v5', 0x50, sha1);\nexport default v5;","import REGEX from './regex.js';\n\nfunction validate(uuid) {\n  return typeof uuid === 'string' && REGEX.test(uuid);\n}\n\nexport default validate;","import validate from './validate.js';\n\nfunction version(uuid) {\n  if (!validate(uuid)) {\n    throw TypeError('Invalid UUID');\n  }\n\n  return parseInt(uuid.substr(14, 1), 16);\n}\n\nexport default version;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\n\n// The following polyfills are needed for IE11\n\nimport { ApiVersion } from '@tableau/api-shared-js';\nimport 'core-js/es/array/find';\nimport 'core-js/es/array/from';\nimport 'core-js/es/map';\nimport 'core-js/es/number/is-integer';\nimport 'core-js/es/number/is-nan';\nimport 'core-js/es/number/parse-float';\nimport 'core-js/es/number/parse-int';\nimport 'core-js/es/object/assign';\nimport 'core-js/es/object/entries';\nimport 'core-js/es/object/set-prototype-of';\nimport 'core-js/es/promise';\n// Due to the way we configured webpack, we should be exporting things which will be under\n// a global variable called \"tableau\". Export everything we want to be visible under tableau\n// from this file.\nimport { ExtensionsImpl } from './ExtensionsApi/Impl/ExtensionsImpl';\nimport { Extensions } from './ExtensionsApi/Namespaces/Extensions';\n\ndeclare let VERSION_IS_ALPHA: boolean;\nconst isAlpha: boolean = typeof VERSION_IS_ALPHA !== 'undefined' ? VERSION_IS_ALPHA : false;\n\ndeclare let API_VERSION_NUMBER: string;\nApiVersion.SetVersionNumber(typeof API_VERSION_NUMBER !== 'undefined' ? API_VERSION_NUMBER : '0.0.0', isAlpha);\n\nconst extensionImpl = new ExtensionsImpl();\nexport const extensions = new Extensions(extensionImpl);\n\n// Export Enums\n// These show up under the tableau object. I.e. tableau.ExtensionContext.Server\nexport {\n  AnalyticsObjectType,\n  AnnotationType,\n  ClassNameKey,\n  ColumnType,\n  DashboardLayoutChange,\n  DashboardObjectType,\n  DashboardObjectVisibilityType,\n  DataType,\n  DateRangeType,\n  DialogStyle,\n  EncodingType,\n  ErrorCodes,\n  ExtensionContext,\n  ExtensionMode,\n  FieldAggregationType,\n  FieldRoleType,\n  FilterDomainType,\n  FilterNullOption,\n  FilterType,\n  FilterUpdateType,\n  HierarchicalLevelSelectionState,\n  IncludeDataValuesOption,\n  MarkType,\n  ParameterValueType,\n  PeriodType,\n  QuickTableCalcType,\n  RelativeDateFilterOptions,\n  ReplaySpeedType,\n  SelectOptions,\n  SelectionUpdateType,\n  SheetType,\n  SortDirection,\n  TableauEventType,\n  TrendLineModelType,\n  VizImageEncodingType,\n  VizImagePaletteType,\n  VizImageSizeSettingAlignmentType,\n  VizImageSizeSettingType,\n  VizImageSortDirectionType,\n  ZoneVisibilityType,\n} from '@tableau/api-external-contract-js';\n"],"names":[],"sourceRoot":""} \ No newline at end of file +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tableau.extensions.1.12.0-pre.16.js","mappings":"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iD;AAC/D,0BAA0B,mBAAO,CAAC,2FAA6B;;AAE/D;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,kEAAkE,gCAAgC;AAClG,KAAK;;AAEL;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gCAAgC,OAAO;AACvC;AACA;AACA;;AAEA;AACA,YAAY,UAAU;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,YAAY,UAAU;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,OAAO;AACP,YAAY,UAAU;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,YAAY,SAAS;AACrB;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,UAAU,UAAU,aAAa,mCAAmC;AACpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB;AACA;AACA,mCAAmC;AACnC,qCAAqC;AACrC,eAAe;AACf,KAAK;;AAEL,UAAU,UAAU;AACpB;AACA;AACA;AACA;AACA;;;;;;;;;;;;AC3Ma;AACb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BAAoB,mBAAO,CAAC,2FAA6B;;AAEzD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,+BAA+B,MAAM,2BAA2B;AAChE;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,GAAG,KAAK,MAAM;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,eAAe;AAC7D,mBAAmB,0CAA0C;AAC7D,CAAC,sCAAsC;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ,EAAE;;;;;;;;;;;ACxDF;AACA,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,uBAAuB,mBAAO,CAAC,+GAAuC;AACtE,kBAAkB,mBAAO,CAAC,yFAA4B;AACtD,iBAAiB,mBAAO,CAAC,qFAA0B;AACnD,WAAW,mBAAO,CAAC,uEAAmB;AACtC,4BAA4B,mBAAO,CAAC,6GAAsC;AAC1E,gBAAgB,mBAAO,CAAC,mFAAyB;;AAEjD;AACA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,0BAA0B;AAC1B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,gBAAgB;AACpB;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;;;;;;;;;;;ACjFA,kBAAkB,mBAAO,CAAC,qFAA0B;AACpD,2BAA2B,mBAAO,CAAC,2GAAqC;AACxE,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,sBAAsB,mBAAO,CAAC,iGAAgC;AAC9D,iBAAiB,mBAAO,CAAC,qFAA0B;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;AClBA,aA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O,CAAC,+GAAuC;AAC5E,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,kBAAkB,mBAAO,CAAC,qFAA0B;;AAEpD;AACA;AACA;AACA;;AAEA,uBAAuB,+CAA+C;AACtE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yBAAyB,qBAAqB;AAC9C;AACA;AACA,yBAAyB,oBAAoB;AAC7C;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;AC9BA,aAAa,mBAAO,CAAC,2EAAqB;AAC1C,YAAY,mBAAO,CAAC,2FAA6B;AACjD,WAAW,mBAAO,CAAC,yGAAoC;AACvD,iBAAiB,mBAAO,CAAC,qFAA0B;AACnD,aAAa,mBAAO,CAAC,+FAA+B;AACpD,YAAY,mBAAO,CAAC,yEAAoB;AACxC,WAAW,mBAAO,CAAC,uEAAmB;AACtC,iBAAiB,mBAAO,CAAC,qFAA0B;AACnD,oBAAoB,mBAAO,CAAC,6GAAsC;AAClE,aAAa,mBAAO,CAAC,yFAA4B;AACjD,cAAc,mBAAO,CAAC,2FAA6B;;AAEnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,EAAE,gBAAgB;;AAElB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;;;;;;;;;;AChHA,0BAA0B,mBAAO,CAAC,2GAAqC;;AAEvE;AACA;;AAEA;AACA;AACA,6DAA6D;AAC7D;AACA;AACA;AACA;;;;;;;;;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hE,iCAAiC,mBAAO,CAAC,2GAAqC;AAC9E,cAAc,mBAAO,CAAC,6EAAsB;AAC5C,0BAA0B,mBAAO,CAAC,2FAA6B;AAC/D,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,sBAAsB,mBAAO,CAAC,iGAAgC;AAC9D,iBAAiB,mBAAO,CAAC,iGAAgC;AACzD,cAAc,mBAAO,CAAC,2FAA6B;AACnD,iBAAiB,mBAAO,CAAC,iGAAgC;;AAEzD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4DAA4D,aAAa;AACzE;AACA,uBAAuB,aAAa,gBAAgB,aAAa;AACjE;AACA;AACA;AACA,2CAA2C,aAAa;AACxD;AACA;AACA;AACA,CAAC;;AAED;AACA,0DAA0D,aAAa;AACvE,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA,YAAY;AACZ,UAAU;AACV,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,eAAe;AACnB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;AACV,OAAO;AACP;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,OAAO;AACP,MAAM;AACN;AACA;AACA;AACA;AACA,IAAI;AACJ,qBAAqB,aAAa;AAClC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,OAAO,IAAI,cAAc;;AAEzB;AACA,6EAA6E,cAAc;AAC3F;;AAEA;AACA;AACA;AACA,MAAM,gBAAgB;;AAEtB;AACA;AACA;AACA;AACA;AACA;;AAEA,IAAI,0CAA0C;AAC9C;AACA,CAAC;;AAED;AACA;;AAEA;;AAEA;AACA,IAAI,6CAA6C;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED,IAAI,wDAAwD;AAC5D;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED,IAAI,0DAA0D;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA,CAAC;;;;;;;;;;;;AC7YY;AACb,aAAa,6HAA+C;AAC5D,eAAe,mBAAO,CAAC,iFAAwB;AAC/C,0BAA0B,mBAAO,CAA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A;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,aAAa;AAC/B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,iEAAe,GAAG;;;;;;;;;;;;;;;ACtNlB,iEAAe,sCAAsC;;;;;;;;;;;;;;;;ACAhB;;AAErC;AACA,OAAO,wDAAQ;AACf;AACA;;AAEA;AACA,gCAAgC;;AAEhC;AACA;AACA;AACA,qBAAqB;;AAErB;AACA,qBAAqB;;AAErB;AACA,qBAAqB;;AAErB;AACA,qBAAqB;AACrB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,iEAAe,KAAK;;;;;;;;;;;;;;;AClCpB,iEAAe,cAAc,EAAE,UAAU,EAAE,eAAe,EAAE,gBAAgB,EAAE,UAAU,GAAG,yCAAyC;;;;;;;;;;;;;;;ACApI;AACA;AACA;AACA;AACA;AACe;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;;;;;;;;;AClBA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,mDAAmD;;AAEnD;;AAEA,oBAAoB,gBAAgB;AACpC;AACA;AACA,IAAI;AACJ;AACA;AACA;;A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","sources":["webpack://tableau/../../node_modules/core-js/es/array/find.js","webpack://tableau/../../node_modules/core-js/es/array/from.js","webpack://tableau/../../node_modules/core-js/es/map/index.js","webpack://tableau/../../node_modules/core-js/es/number/is-integer.js","webpack://tableau/../../node_modules/core-js/es/number/is-nan.js","webpack://tableau/../../node_modules/core-js/es/number/parse-float.js","webpack://tableau/../../node_modules/core-js/es/number/parse-int.js","webpack://tableau/../../node_modules/core-js/es/object/assign.js","webpack://tableau/../../node_modules/core-js/es/object/entries.js","webpack://tableau/../../node_modules/core-js/es/object/set-prototype-of.js","webpack://tableau/../../node_modules/core-js/es/promise/index.js","webpack://tableau/../../node_modules/core-js/internals/a-callable.js","webpack://tableau/../../node_modules/core-js/internals/a-constructor.js","webpack://tableau/../../node_modules/core-js/internals/a-possible-prototype.js","webpack://tableau/../../node_modules/core-js/internals/add-to-unscopables.js","webpack://tableau/../../node_modules/core-js/internals/an-instance.js","webpack://tableau/../../node_modules/core-js/internals/an-object.js","webpack://tableau/../../node_modules/core-js/internals/array-from.js","webpack://tableau/../../node_modules/core-js/internals/array-includes.js","webpack://tableau/../../node_modules/core-js/internals/array-iteration.js","webpack://tableau/../../node_modules/core-js/internals/array-slice.js","webpack://tableau/../../node_modules/core-js/internals/array-species-constructor.js","webpack://tableau/../../node_modules/core-js/internals/array-species-create.js","webpack://tableau/../../node_modules/core-js/internals/call-with-safe-iteration-closing.js","webpack://tableau/../../node_modules/core-js/internals/check-correctness-of-iteration.js","webpack://tableau/../../node_modules/core-js/internals/classof-raw.js","webpack://tableau/../../node_modules/core-js/internals/classof.js","webpack://tableau/../../node_modules/core-js/internals/clear-error-stack.js","webpack://tableau/../../node_modules/core-js/internals/collection-strong.js","webpack://tableau/../../node_modules/core-js/internals/collection.js","webpack://tableau/../../node_modules/core-js/internals/copy-constructor-properties.js","webpack://tableau/../../node_modules/core-js/internals/correct-prototype-getter.js","webpack://tableau/../../node_modules/core-js/internals/create-iterator-constructor.js","webpack://tableau/../../node_modules/core-js/internals/create-non-enumerable-property.js","webpack://tableau/../../node_modules/core-js/internals/create-property-descriptor.js","webpack://tableau/../../node_modules/core-js/internals/create-property.js","webpack://tableau/../../node_modules/core-js/internals/define-iterator.js","webpack://tableau/../../node_modules/core-js/internals/descriptors.js","webpack://tableau/../../node_modules/core-js/internals/document-create-element.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-browser.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-ios-pebble.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-ios.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-node.js","webpack://tableau/../../node_modules/core-js/internals/engine-is-webos-webkit.js","webpack://tableau/../../node_modules/core-js/internals/engine-user-agent.js","webpack://tableau/../../node_modules/core-js/internals/engine-v8-version.js","webpack://tableau/../../node_modules/core-js/internals/entry-unbind.js","webpack://tableau/../../node_modules/core-js/internals/enum-bug-keys.js","webpack://tableau/../../node_modules/core-js/internals/error-stack-installable.js","webpack://tableau/../../node_modules/core-js/internals/export.js","webpack://tableau/../../node_modules/core-js/internals/fails.js","webpack://tableau/../../node_modules/core-js/internals/freezing.js","webpack://tableau/../../node_modules/core-js/internals/function-apply.js","webpack://tableau/../../node_modules/core-js/internals/function-bind-context.js","webpack://tableau/../../node_modules/core-js/internals/function-call.js","webpack://tableau/../../node_modules/core-js/internals/function-name.js","webpack://tableau/../../node_modules/core-js/internals/function-uncurry-this.js","webpack://tableau/../../node_modules/core-js/internals/get-built-in.js","webpack://tableau/../../node_modules/core-js/internals/get-iterator-method.js","webpack://tableau/../../node_modules/core-js/internals/get-iterator.js","webpack://tableau/../../node_modules/core-js/internals/get-method.js","webpack://tableau/../../node_modules/core-js/internals/global.js","webpack://tableau/../../node_modules/core-js/internals/has-own-property.js","webpack://tableau/../../node_modules/core-js/internals/hidden-keys.js","webpack://tableau/../../node_modules/core-js/internals/host-report-errors.js","webpack://tableau/../../node_modules/core-js/internals/html.js","webpack://tableau/../../node_modules/core-js/internals/ie8-dom-define.js","webpack://tableau/../../node_modules/core-js/internals/indexed-object.js","webpack://tableau/../../node_modules/core-js/internals/inherit-if-required.js","webpack://tableau/../../node_modules/core-js/internals/inspect-source.js","webpack://tableau/../../node_modules/core-js/internals/install-error-cause.js","webpack://tableau/../../node_modules/core-js/internals/internal-metadata.js","webpack://tableau/../../node_modules/core-js/internals/internal-state.js","webpack://tableau/../../node_modules/core-js/internals/is-array-iterator-method.js","webpack://tableau/../../node_modules/core-js/internals/is-array.js","webpack://tableau/../../node_modules/core-js/internals/is-callable.js","webpack://tableau/../../node_modules/core-js/internals/is-constructor.js","webpack://tableau/../../node_modules/core-js/internals/is-forced.js","webpack://tableau/../../node_modules/core-js/internals/is-integral-number.js","webpack://tableau/../../node_modules/core-js/internals/is-object.js","webpack://tableau/../../node_modules/core-js/internals/is-pure.js","webpack://tableau/../../node_modules/core-js/internals/is-symbol.js","webpack://tableau/../../node_modules/core-js/internals/iterate.js","webpack://tableau/../../node_modules/core-js/internals/iterator-close.js","webpack://tableau/../../node_modules/core-js/internals/iterators-core.js","webpack://tableau/../../node_modules/core-js/internals/iterators.js","webpack://tableau/../../node_modules/core-js/internals/length-of-array-like.js","webpack://tableau/../../node_modules/core-js/internals/microtask.js","webpack://tableau/../../node_modules/core-js/internals/native-promise-constructor.js","webpack://tableau/../../node_modules/core-js/internals/native-symbol.js","webpack://tableau/../../node_modules/core-js/internals/native-weak-map.js","webpack://tableau/../../node_modules/core-js/internals/new-promise-capability.js","webpack://tableau/../../node_modules/core-js/internals/normalize-string-argument.js","webpack://tableau/../../node_modules/core-js/internals/number-parse-float.js","webpack://tableau/../../node_modules/core-js/internals/number-parse-int.js","webpack://tableau/../../node_modules/core-js/internals/object-assign.js","webpack://tableau/../../node_modules/core-js/internals/object-create.js","webpack://tableau/../../node_modules/core-js/internals/object-define-properties.js","webpack://tableau/../../node_modules/core-js/internals/object-define-property.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-descriptor.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-names-external.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-names.js","webpack://tableau/../../node_modules/core-js/internals/object-get-own-property-symbols.js","webpack://tableau/../../node_modules/core-js/internals/object-get-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-is-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-keys-internal.js","webpack://tableau/../../node_modules/core-js/internals/object-keys.js","webpack://tableau/../../node_modules/core-js/internals/object-property-is-enumerable.js","webpack://tableau/../../node_modules/core-js/internals/object-set-prototype-of.js","webpack://tableau/../../node_modules/core-js/internals/object-to-array.js","webpack://tableau/../../node_modules/core-js/internals/object-to-string.js","webpack://tableau/../../node_modules/core-js/internals/ordinary-to-primitive.js","webpack://tableau/../../node_modules/core-js/internals/own-keys.js","webpack://tableau/../../node_modules/core-js/internals/path.js","webpack://tableau/../../node_modules/core-js/internals/perform.js","webpack://tableau/../../node_modules/core-js/internals/promise-resolve.js","webpack://tableau/../../node_modules/core-js/internals/redefine-all.js","webpack://tableau/../../node_modules/core-js/internals/redefine.js","webpack://tableau/../../node_modules/core-js/internals/require-object-coercible.js","webpack://tableau/../../node_modules/core-js/internals/set-global.js","webpack://tableau/../../node_modules/core-js/internals/set-species.js","webpack://tableau/../../node_modules/core-js/internals/set-to-string-tag.js","webpack://tableau/../../node_modules/core-js/internals/shared-key.js","webpack://tableau/../../node_modules/core-js/internals/shared-store.js","webpack://tableau/../../node_modules/core-js/internals/shared.js","webpack://tableau/../../node_modules/core-js/internals/species-constructor.js","webpack://tableau/../../node_modules/core-js/internals/string-multibyte.js","webpack://tableau/../../node_modules/core-js/internals/string-trim.js","webpack://tableau/../../node_modules/core-js/internals/task.js","webpack://tableau/../../node_modules/core-js/internals/to-absolute-index.js","webpack://tableau/../../node_modules/core-js/internals/to-indexed-object.js","webpack://tableau/../../node_modules/core-js/internals/to-integer-or-infinity.js","webpack://tableau/../../node_modules/core-js/internals/to-length.js","webpack://tableau/../../node_modules/core-js/internals/to-object.js","webpack://tableau/../../node_modules/core-js/internals/to-primitive.js","webpack://tableau/../../node_modules/core-js/internals/to-property-key.js","webpack://tableau/../../node_modules/core-js/internals/to-string-tag-support.js","webpack://tableau/../../node_modules/core-js/internals/to-string.js","webpack://tableau/../../node_modules/core-js/internals/try-to-string.js","webpack://tableau/../../node_modules/core-js/internals/uid.js","webpack://tableau/../../node_modules/core-js/internals/use-symbol-as-uid.js","webpack://tableau/../../node_modules/core-js/internals/well-known-symbol.js","webpack://tableau/../../node_modules/core-js/internals/whitespaces.js","webpack://tableau/../../node_modules/core-js/modules/es.aggregate-error.js","webpack://tableau/../../node_modules/core-js/modules/es.array.find.js","webpack://tableau/../../node_modules/core-js/modules/es.array.from.js","webpack://tableau/../../node_modules/core-js/modules/es.array.iterator.js","webpack://tableau/../../node_modules/core-js/modules/es.map.js","webpack://tableau/../../node_modules/core-js/modules/es.number.is-integer.js","webpack://tableau/../../node_modules/core-js/modules/es.number.is-nan.js","webpack://tableau/../../node_modules/core-js/modules/es.number.parse-float.js","webpack://tableau/../../node_modules/core-js/modules/es.number.parse-int.js","webpack://tableau/../../node_modules/core-js/modules/es.object.assign.js","webpack://tableau/../../node_modules/core-js/modules/es.object.entries.js","webpack://tableau/../../node_modules/core-js/modules/es.object.set-prototype-of.js","webpack://tableau/../../node_modules/core-js/modules/es.object.to-string.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.all-settled.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.any.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.finally.js","webpack://tableau/../../node_modules/core-js/modules/es.promise.js","webpack://tableau/../../node_modules/core-js/modules/es.string.iterator.js","webpack://tableau/../../node_modules/guid/guid.js","webpack://tableau/./src/ExtensionsApi/Events/DashboardLayoutChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/FilterChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/MarksSelectedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/ParameterChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/SummaryDataChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/TableauEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/TableauSheetEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/TableauWorksheetEvent.ts","webpack://tableau/./src/ExtensionsApi/Events/WorkbookFormattingChangedEvent.ts","webpack://tableau/./src/ExtensionsApi/Impl/BentonSansFontNameConstants.ts","webpack://tableau/./src/ExtensionsApi/Impl/ConnectedServer.ts","webpack://tableau/./src/ExtensionsApi/Impl/ExtensionWorkbookImpl.ts","webpack://tableau/./src/ExtensionsApi/Impl/ExtensionsImpl.ts","webpack://tableau/./src/ExtensionsApi/Impl/LegacyInternalApiDispatcherHolder.ts","webpack://tableau/./src/ExtensionsApi/Impl/SettingsImpl.ts","webpack://tableau/./src/ExtensionsApi/Impl/TableauBookFontNameConstants.ts","webpack://tableau/./src/ExtensionsApi/Impl/UIImpl.ts","webpack://tableau/./src/ExtensionsApi/Models/Dashboard.ts","webpack://tableau/./src/ExtensionsApi/Models/DashboardObject.ts","webpack://tableau/./src/ExtensionsApi/Models/Parameter.ts","webpack://tableau/./src/ExtensionsApi/Models/Sheet.ts","webpack://tableau/./src/ExtensionsApi/Models/Workbook.ts","webpack://tableau/./src/ExtensionsApi/Models/Worksheet.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/DashboardContent.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/Environment.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/Extensions.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/Settings.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/UI.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/WorkbookFormattingEnvUtil.ts","webpack://tableau/./src/ExtensionsApi/Namespaces/WorksheetContent.ts","webpack://tableau/./src/ExtensionsApi/Services/Impl/InitializationServiceImpl.ts","webpack://tableau/./src/ExtensionsApi/Services/Impl/SettingsServiceImpl.ts","webpack://tableau/./src/ExtensionsApi/Services/Impl/UIServiceImpl.ts","webpack://tableau/./src/ExtensionsApi/Services/RegisterAllExtensionsServices.ts","webpack://tableau/./src/ExtensionsApi/Services/ServiceRegistryUtil.ts","webpack://tableau/../api-external-contract-js/src/EmbeddingApiExternalContract.ts","webpack://tableau/../api-external-contract-js/src/ExtensionsApiExternalContract.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/AskDataInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/Enums.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/PulseInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/VizInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Embedding/WebComponentInterfaces.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Extensions/Namespaces/Tableau.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Shared/Enums.ts","webpack://tableau/../api-external-contract-js/src/ExternalContract/Shared/Namespaces/Tableau.ts","webpack://tableau/../api-external-contract-js/src/SharedApiExternalContract.ts","webpack://tableau/../api-internal-contract-js/src/JsApiInternalContract.ts","webpack://tableau/../api-internal-contract-js/src/contract/DataTypeConverter.ts","webpack://tableau/../api-internal-contract-js/src/contract/Enums.ts","webpack://tableau/../api-internal-contract-js/src/contract/Notifications.ts","webpack://tableau/../api-internal-contract-js/src/contract/Parameters.ts","webpack://tableau/../api-internal-contract-js/src/contract/Verbs.ts","webpack://tableau/../api-internal-contract-js/src/interface/AskDataInterface.ts","webpack://tableau/../api-internal-contract-js/src/interface/PulseInterface.ts","webpack://tableau/../api-internal-contract-js/src/interface/VqlInterface.ts","webpack://tableau/../api-internal-contract-js/src/messaging/CrossFrameMessenger.ts","webpack://tableau/../api-internal-contract-js/src/messaging/CrossFramePreparedMessage.ts","webpack://tableau/../api-internal-contract-js/src/messaging/MessageTypeChecks.ts","webpack://tableau/../api-internal-contract-js/src/messaging/interface/MessageTypes.ts","webpack://tableau/../api-internal-contract-js/src/versioning/IdentityVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/StackingVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/VersionConverterFactory.ts","webpack://tableau/../api-internal-contract-js/src/versioning/VersionTranslations.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalIdentityVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalStackingVersionConverter.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalVersionConverterFactory.ts","webpack://tableau/../api-internal-contract-js/src/versioning/external/ExternalVersionTranslations.ts","webpack://tableau/../api-shared-js/src/ApiShared.ts","webpack://tableau/../api-shared-js/src/ApiShared/ApiVersion.ts","webpack://tableau/../api-shared-js/src/ApiShared/ConnectionSummary.ts","webpack://tableau/../api-shared-js/src/ApiShared/CrossFrame/CrossFrameBootstrap.ts","webpack://tableau/../api-shared-js/src/ApiShared/CrossFrame/CrossFrameDispatcher.ts","webpack://tableau/../api-shared-js/src/ApiShared/DataSource.ts","webpack://tableau/../api-shared-js/src/ApiShared/EnumMappings/ExternalToInternalEnumMappings.ts","webpack://tableau/../api-shared-js/src/ApiShared/EnumMappings/InternalToExternalEnumMappings.ts","webpack://tableau/../api-shared-js/src/ApiShared/EventListenerManager.ts","webpack://tableau/../api-shared-js/src/ApiShared/Field.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/CustomViewImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/DashboardImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/DashboardObjectImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/DataSourceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/FieldImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/ParameterImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/SheetImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/SheetInfoImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/SingleEventManagerImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/StoryImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/StoryPointImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/StoryPointInfoImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/WorkbookImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Impl/WorksheetImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/LogicalTable.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/AccessibilityModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/FilterModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/GetDataModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/GetDataTableReaderModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Models/SelectionModels.ts","webpack://tableau/../api-shared-js/src/ApiShared/Point.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/GetDataService.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/RegisterAllSharedServices.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/ServiceRegistry.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/AccessibilityServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/AnimationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/AnnotationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ClientInfoServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/DataSourceServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ExportServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ExternalContextMenuServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/FilterServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/GetDataServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/NotificationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/NotificationServiceImplBase.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ParametersServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/SelectionServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ServiceImplBase.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/SizeServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/StoryActivationServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/VisualModelServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/VizServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/Services/impl/ZoneServiceImpl.ts","webpack://tableau/../api-shared-js/src/ApiShared/TableSummary.ts","webpack://tableau/../api-shared-js/src/ApiShared/TableauError.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/DataValueFactory.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/Deferred.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/EnumConverter.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/ErrorHelpers.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/ExportHelpers.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/Param.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/SheetUtils.ts","webpack://tableau/../api-shared-js/src/ApiShared/Utils/ShortLivedDeferred.ts","webpack://tableau/../api-shared-js/src/ApiShared/VersionNumber.ts","webpack://tableau/../api-shared-js/src/VersionedExternalApiDispatcher.ts","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/index.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/md5.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/nil.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/parse.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/regex.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/rng.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/sha1.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/stringify.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v1.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v3.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v35.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v4.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/v5.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/validate.js","webpack://tableau/../api-shared-js/node_modules/uuid/dist/esm-browser/version.js","webpack://tableau/webpack/bootstrap","webpack://tableau/webpack/runtime/define property getters","webpack://tableau/webpack/runtime/global","webpack://tableau/webpack/runtime/hasOwnProperty shorthand","webpack://tableau/webpack/runtime/make namespace object","webpack://tableau/./src/ExtensionsApi.ts"],"sourcesContent":["require('../../modules/es.array.find');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('Array', 'find');\n","require('../../modules/es.string.iterator');\nrequire('../../modules/es.array.from');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Array.from;\n","require('../../modules/es.array.iterator');\nrequire('../../modules/es.map');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Map;\n","require('../../modules/es.number.is-integer');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.isInteger;\n","require('../../modules/es.number.is-nan');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.isNaN;\n","require('../../modules/es.number.parse-float');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.parseFloat;\n","require('../../modules/es.number.parse-int');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.parseInt;\n","require('../../modules/es.object.assign');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.assign;\n","require('../../modules/es.object.entries');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.entries;\n","require('../../modules/es.object.set-prototype-of');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.setPrototypeOf;\n","require('../../modules/es.aggregate-error');\nrequire('../../modules/es.array.iterator');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.promise');\nrequire('../../modules/es.promise.all-settled');\nrequire('../../modules/es.promise.any');\nrequire('../../modules/es.promise.finally');\nrequire('../../modules/es.string.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Promise;\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar TypeError = global.TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n  if (isCallable(argument)) return argument;\n  throw TypeError(tryToString(argument) + ' is not a function');\n};\n","var global = require('../internals/global');\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar TypeError = global.TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n  if (isConstructor(argument)) return argument;\n  throw TypeError(tryToString(argument) + ' is not a constructor');\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar String = global.String;\nvar TypeError = global.TypeError;\n\nmodule.exports = function (argument) {\n  if (typeof argument == 'object' || isCallable(argument)) return argument;\n  throw TypeError(\"Can't set \" + String(argument) + ' as a prototype');\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","var global = require('../internals/global');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar TypeError = global.TypeError;\n\nmodule.exports = function (it, Prototype) {\n  if (isPrototypeOf(Prototype, it)) return it;\n  throw TypeError('Incorrect invocation');\n};\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar String = global.String;\nvar TypeError = global.TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n  if (isObject(argument)) return argument;\n  throw TypeError(String(argument) + ' is not an object');\n};\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar toObject = require('../internals/to-object');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar isConstructor = require('../internals/is-constructor');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar Array = global.Array;\n\n// `Array.from` method implementation\n// https://tc39.es/ecma262/#sec-array.from\nmodule.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n  var O = toObject(arrayLike);\n  var IS_CONSTRUCTOR = isConstructor(this);\n  var argumentsLength = arguments.length;\n  var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n  var mapping = mapfn !== undefined;\n  if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);\n  var iteratorMethod = getIteratorMethod(O);\n  var index = 0;\n  var length, result, step, iterator, next, value;\n  // if the target is not iterable or it's an array with the default iterator - use a simple case\n  if (iteratorMethod && !(this == Array && isArrayIteratorMethod(iteratorMethod))) {\n    iterator = getIterator(O, iteratorMethod);\n    next = iterator.next;\n    result = IS_CONSTRUCTOR ? new this() : [];\n    for (;!(step = call(next, iterator)).done; index++) {\n      value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;\n      createProperty(result, index, value);\n    }\n  } else {\n    length = lengthOfArrayLike(O);\n    result = IS_CONSTRUCTOR ? new this(length) : Array(length);\n    for (;length > index; index++) {\n      value = mapping ? mapfn(O[index], index) : O[index];\n      createProperty(result, index, value);\n    }\n  }\n  result.length = index;\n  return result;\n};\n","var toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = lengthOfArrayLike(O);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare -- NaN check\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare -- NaN check\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.includes` method\n  // https://tc39.es/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.es/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n","var bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n  var IS_MAP = TYPE == 1;\n  var IS_FILTER = TYPE == 2;\n  var IS_SOME = TYPE == 3;\n  var IS_EVERY = TYPE == 4;\n  var IS_FIND_INDEX = TYPE == 6;\n  var IS_FILTER_REJECT = TYPE == 7;\n  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;\n  return function ($this, callbackfn, that, specificCreate) {\n    var O = toObject($this);\n    var self = IndexedObject(O);\n    var boundFunction = bind(callbackfn, that);\n    var length = lengthOfArrayLike(self);\n    var index = 0;\n    var create = specificCreate || arraySpeciesCreate;\n    var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n    var value, result;\n    for (;length > index; index++) if (NO_HOLES || index in self) {\n      value = self[index];\n      result = boundFunction(value, index, O);\n      if (TYPE) {\n        if (IS_MAP) target[index] = result; // map\n        else if (result) switch (TYPE) {\n          case 3: return true;              // some\n          case 5: return value;             // find\n          case 6: return index;             // findIndex\n          case 2: push(target, value);      // filter\n        } else switch (TYPE) {\n          case 4: return false;             // every\n          case 7: push(target, value);      // filterReject\n        }\n      }\n    }\n    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.forEach` method\n  // https://tc39.es/ecma262/#sec-array.prototype.foreach\n  forEach: createMethod(0),\n  // `Array.prototype.map` method\n  // https://tc39.es/ecma262/#sec-array.prototype.map\n  map: createMethod(1),\n  // `Array.prototype.filter` method\n  // https://tc39.es/ecma262/#sec-array.prototype.filter\n  filter: createMethod(2),\n  // `Array.prototype.some` method\n  // https://tc39.es/ecma262/#sec-array.prototype.some\n  some: createMethod(3),\n  // `Array.prototype.every` method\n  // https://tc39.es/ecma262/#sec-array.prototype.every\n  every: createMethod(4),\n  // `Array.prototype.find` method\n  // https://tc39.es/ecma262/#sec-array.prototype.find\n  find: createMethod(5),\n  // `Array.prototype.findIndex` method\n  // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n  findIndex: createMethod(6),\n  // `Array.prototype.filterReject` method\n  // https://github.com/tc39/proposal-array-filtering\n  filterReject: createMethod(7)\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","var global = require('../internals/global');\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar Array = global.Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n  var C;\n  if (isArray(originalArray)) {\n    C = originalArray.constructor;\n    // cross-realm fallback\n    if (isConstructor(C) && (C === Array || isArray(C.prototype))) C = undefined;\n    else if (isObject(C)) {\n      C = C[SPECIES];\n      if (C === null) C = undefined;\n    }\n  } return C === undefined ? Array : C;\n};\n","var arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n  return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","var anObject = require('../internals/an-object');\nvar iteratorClose = require('../internals/iterator-close');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n  try {\n    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n  } catch (error) {\n    iteratorClose(iterator, 'throw', error);\n  }\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n  var called = 0;\n  var iteratorWithReturn = {\n    next: function () {\n      return { done: !!called++ };\n    },\n    'return': function () {\n      SAFE_CLOSING = true;\n    }\n  };\n  iteratorWithReturn[ITERATOR] = function () {\n    return this;\n  };\n  // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n  Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n  var ITERATION_SUPPORT = false;\n  try {\n    var object = {};\n    object[ITERATOR] = function () {\n      return {\n        next: function () {\n          return { done: ITERATION_SUPPORT = true };\n        }\n      };\n    };\n    exec(object);\n  } catch (error) { /* empty */ }\n  return ITERATION_SUPPORT;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n  return stringSlice(toString(it), 8, -1);\n};\n","var global = require('../internals/global');\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar Object = global.Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n  var O, tag, result;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag\n    // builtinTag case\n    : CORRECT_ARGUMENTS ? classofRaw(O)\n    // ES3 arguments fallback\n    : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar arraySlice = require('../internals/array-slice');\n\nvar replace = uncurryThis(''.replace);\nvar split = uncurryThis(''.split);\nvar join = uncurryThis([].join);\n\nvar TEST = (function (arg) { return String(Error(arg).stack); })('zxcasd');\nvar V8_OR_CHAKRA_STACK_ENTRY = /\\n\\s*at [^:]*:[^\\n]*/;\nvar IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);\nvar IS_FIREFOX_OR_SAFARI_STACK = /@[^\\n]*\\n/.test(TEST) && !/zxcasd/.test(TEST);\n\nmodule.exports = function (stack, dropEntries) {\n  if (typeof stack != 'string') return stack;\n  if (IS_V8_OR_CHAKRA_STACK) {\n    while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');\n  } else if (IS_FIREFOX_OR_SAFARI_STACK) {\n    return join(arraySlice(split(stack, '\\n'), dropEntries), '\\n');\n  } return stack;\n};\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar create = require('../internals/object-create');\nvar redefineAll = require('../internals/redefine-all');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/define-iterator');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n    var Constructor = wrapper(function (that, iterable) {\n      anInstance(that, Prototype);\n      setInternalState(that, {\n        type: CONSTRUCTOR_NAME,\n        index: create(null),\n        first: undefined,\n        last: undefined,\n        size: 0\n      });\n      if (!DESCRIPTORS) that.size = 0;\n      if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n    });\n\n    var Prototype = Constructor.prototype;\n\n    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n    var define = function (that, key, value) {\n      var state = getInternalState(that);\n      var entry = getEntry(that, key);\n      var previous, index;\n      // change existing entry\n      if (entry) {\n        entry.value = value;\n      // create new entry\n      } else {\n        state.last = entry = {\n          index: index = fastKey(key, true),\n          key: key,\n          value: value,\n          previous: previous = state.last,\n          next: undefined,\n          removed: false\n        };\n        if (!state.first) state.first = entry;\n        if (previous) previous.next = entry;\n        if (DESCRIPTORS) state.size++;\n        else that.size++;\n        // add to index\n        if (index !== 'F') state.index[index] = entry;\n      } return that;\n    };\n\n    var getEntry = function (that, key) {\n      var state = getInternalState(that);\n      // fast case\n      var index = fastKey(key);\n      var entry;\n      if (index !== 'F') return state.index[index];\n      // frozen object case\n      for (entry = state.first; entry; entry = entry.next) {\n        if (entry.key == key) return entry;\n      }\n    };\n\n    redefineAll(Prototype, {\n      // `{ Map, Set }.prototype.clear()` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.clear\n      // https://tc39.es/ecma262/#sec-set.prototype.clear\n      clear: function clear() {\n        var that = this;\n        var state = getInternalState(that);\n        var data = state.index;\n        var entry = state.first;\n        while (entry) {\n          entry.removed = true;\n          if (entry.previous) entry.previous = entry.previous.next = undefined;\n          delete data[entry.index];\n          entry = entry.next;\n        }\n        state.first = state.last = undefined;\n        if (DESCRIPTORS) state.size = 0;\n        else that.size = 0;\n      },\n      // `{ Map, Set }.prototype.delete(key)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.delete\n      // https://tc39.es/ecma262/#sec-set.prototype.delete\n      'delete': function (key) {\n        var that = this;\n        var state = getInternalState(that);\n        var entry = getEntry(that, key);\n        if (entry) {\n          var next = entry.next;\n          var prev = entry.previous;\n          delete state.index[entry.index];\n          entry.removed = true;\n          if (prev) prev.next = next;\n          if (next) next.previous = prev;\n          if (state.first == entry) state.first = next;\n          if (state.last == entry) state.last = prev;\n          if (DESCRIPTORS) state.size--;\n          else that.size--;\n        } return !!entry;\n      },\n      // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.foreach\n      // https://tc39.es/ecma262/#sec-set.prototype.foreach\n      forEach: function forEach(callbackfn /* , that = undefined */) {\n        var state = getInternalState(this);\n        var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n        var entry;\n        while (entry = entry ? entry.next : state.first) {\n          boundFunction(entry.value, entry.key, this);\n          // revert to the last existing entry\n          while (entry && entry.removed) entry = entry.previous;\n        }\n      },\n      // `{ Map, Set}.prototype.has(key)` methods\n      // https://tc39.es/ecma262/#sec-map.prototype.has\n      // https://tc39.es/ecma262/#sec-set.prototype.has\n      has: function has(key) {\n        return !!getEntry(this, key);\n      }\n    });\n\n    redefineAll(Prototype, IS_MAP ? {\n      // `Map.prototype.get(key)` method\n      // https://tc39.es/ecma262/#sec-map.prototype.get\n      get: function get(key) {\n        var entry = getEntry(this, key);\n        return entry && entry.value;\n      },\n      // `Map.prototype.set(key, value)` method\n      // https://tc39.es/ecma262/#sec-map.prototype.set\n      set: function set(key, value) {\n        return define(this, key === 0 ? 0 : key, value);\n      }\n    } : {\n      // `Set.prototype.add(value)` method\n      // https://tc39.es/ecma262/#sec-set.prototype.add\n      add: function add(value) {\n        return define(this, value = value === 0 ? 0 : value, value);\n      }\n    });\n    if (DESCRIPTORS) defineProperty(Prototype, 'size', {\n      get: function () {\n        return getInternalState(this).size;\n      }\n    });\n    return Constructor;\n  },\n  setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {\n    var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n    var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n    var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n    // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods\n    // https://tc39.es/ecma262/#sec-map.prototype.entries\n    // https://tc39.es/ecma262/#sec-map.prototype.keys\n    // https://tc39.es/ecma262/#sec-map.prototype.values\n    // https://tc39.es/ecma262/#sec-map.prototype-@@iterator\n    // https://tc39.es/ecma262/#sec-set.prototype.entries\n    // https://tc39.es/ecma262/#sec-set.prototype.keys\n    // https://tc39.es/ecma262/#sec-set.prototype.values\n    // https://tc39.es/ecma262/#sec-set.prototype-@@iterator\n    defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {\n      setInternalState(this, {\n        type: ITERATOR_NAME,\n        target: iterated,\n        state: getInternalCollectionState(iterated),\n        kind: kind,\n        last: undefined\n      });\n    }, function () {\n      var state = getInternalIteratorState(this);\n      var kind = state.kind;\n      var entry = state.last;\n      // revert to the last existing entry\n      while (entry && entry.removed) entry = entry.previous;\n      // get next entry\n      if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n        // or finish the iteration\n        state.target = undefined;\n        return { value: undefined, done: true };\n      }\n      // return step by kind\n      if (kind == 'keys') return { value: entry.key, done: false };\n      if (kind == 'values') return { value: entry.value, done: false };\n      return { value: [entry.key, entry.value], done: false };\n    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n    // `{ Map, Set }.prototype[@@species]` accessors\n    // https://tc39.es/ecma262/#sec-get-map-@@species\n    // https://tc39.es/ecma262/#sec-get-set-@@species\n    setSpecies(CONSTRUCTOR_NAME);\n  }\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar redefine = require('../internals/redefine');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n  var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n  var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n  var ADDER = IS_MAP ? 'set' : 'add';\n  var NativeConstructor = global[CONSTRUCTOR_NAME];\n  var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n  var Constructor = NativeConstructor;\n  var exported = {};\n\n  var fixMethod = function (KEY) {\n    var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n    redefine(NativePrototype, KEY,\n      KEY == 'add' ? function add(value) {\n        uncurriedNativeMethod(this, value === 0 ? 0 : value);\n        return this;\n      } : KEY == 'delete' ? function (key) {\n        return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : KEY == 'get' ? function get(key) {\n        return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : KEY == 'has' ? function has(key) {\n        return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n      } : function set(key, value) {\n        uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n        return this;\n      }\n    );\n  };\n\n  var REPLACE = isForced(\n    CONSTRUCTOR_NAME,\n    !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n      new NativeConstructor().entries().next();\n    }))\n  );\n\n  if (REPLACE) {\n    // create collection constructor\n    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n    InternalMetadataModule.enable();\n  } else if (isForced(CONSTRUCTOR_NAME, true)) {\n    var instance = new Constructor();\n    // early implementations not supports chaining\n    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n    // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n    // most early implementations doesn't supports iterables, most modern - not close it correctly\n    // eslint-disable-next-line no-new -- required for testing\n    var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n    // for early implementations -0 and +0 not the same\n    var BUGGY_ZERO = !IS_WEAK && fails(function () {\n      // V8 ~ Chromium 42- fails only with 5+ elements\n      var $instance = new NativeConstructor();\n      var index = 5;\n      while (index--) $instance[ADDER](index, index);\n      return !$instance.has(-0);\n    });\n\n    if (!ACCEPT_ITERABLES) {\n      Constructor = wrapper(function (dummy, iterable) {\n        anInstance(dummy, NativePrototype);\n        var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n        if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n        return that;\n      });\n      Constructor.prototype = NativePrototype;\n      NativePrototype.constructor = Constructor;\n    }\n\n    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n      fixMethod('delete');\n      fixMethod('has');\n      IS_MAP && fixMethod('get');\n    }\n\n    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n    // weak collections should not contains .clear method\n    if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n  }\n\n  exported[CONSTRUCTOR_NAME] = Constructor;\n  $({ global: true, forced: Constructor != NativeConstructor }, exported);\n\n  setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n  return Constructor;\n};\n","var hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n  var keys = ownKeys(source);\n  var defineProperty = definePropertyModule.f;\n  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!hasOwn(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next) {\n  var TO_STRING_TAG = NAME + ' Iterator';\n  IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });\n  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n  Iterators[TO_STRING_TAG] = returnThis;\n  return IteratorConstructor;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n  var propertyKey = toPropertyKey(key);\n  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n  else object[propertyKey] = value;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n  createIteratorConstructor(IteratorConstructor, NAME, next);\n\n  var getIterationMethod = function (KIND) {\n    if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];\n    switch (KIND) {\n      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n    } return function () { return new IteratorConstructor(this); };\n  };\n\n  var TO_STRING_TAG = NAME + ' Iterator';\n  var INCORRECT_VALUES_NAME = false;\n  var IterablePrototype = Iterable.prototype;\n  var nativeIterator = IterablePrototype[ITERATOR]\n    || IterablePrototype['@@iterator']\n    || DEFAULT && IterablePrototype[DEFAULT];\n  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n  var CurrentIteratorPrototype, methods, KEY;\n\n  // fix native\n  if (anyNativeIterator) {\n    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n    if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n        if (setPrototypeOf) {\n          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n        } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n          redefine(CurrentIteratorPrototype, ITERATOR, returnThis);\n        }\n      }\n      // Set @@toStringTag to native iterators\n      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n      if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n    }\n  }\n\n  // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n  if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n    if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n      createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n    } else {\n      INCORRECT_VALUES_NAME = true;\n      defaultIterator = function values() { return call(nativeIterator, this); };\n    }\n  }\n\n  // export additional methods\n  if (DEFAULT) {\n    methods = {\n      values: getIterationMethod(VALUES),\n      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n      entries: getIterationMethod(ENTRIES)\n    };\n    if (FORCED) for (KEY in methods) {\n      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n        redefine(IterablePrototype, KEY, methods[KEY]);\n      }\n    } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n  }\n\n  // define iterator\n  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n    redefine(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n  }\n  Iterators[NAME] = defaultIterator;\n\n  return methods;\n};\n","var fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n  return EXISTS ? document.createElement(it) : {};\n};\n","module.exports = typeof window == 'object';\n","var userAgent = require('../internals/engine-user-agent');\nvar global = require('../internals/global');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && global.Pebble !== undefined;\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","var classof = require('../internals/classof-raw');\nvar global = require('../internals/global');\n\nmodule.exports = classof(global.process) == 'process';\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\n","var global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n  match = v8.split('.');\n  // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n  // but their correct versions are not interesting for us\n  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n  match = userAgent.match(/Edge\\/(\\d+)/);\n  if (!match || match[1] >= 74) {\n    match = userAgent.match(/Chrome\\/(\\d+)/);\n    if (match) version = +match[1];\n  }\n}\n\nmodule.exports = version;\n","var global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (CONSTRUCTOR, METHOD) {\n  return uncurryThis(global[CONSTRUCTOR].prototype[METHOD]);\n};\n","// IE8- don't enum bug keys\nmodule.exports = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf'\n];\n","var fails = require('../internals/fails');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = !fails(function () {\n  var error = Error('a');\n  if (!('stack' in error)) return true;\n  // eslint-disable-next-line es/no-object-defineproperty -- safe\n  Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));\n  return error.stack !== 7;\n});\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n  options.target      - name of the target object\n  options.global      - target is the global object\n  options.stat        - export as static methods of target\n  options.proto       - export as prototype methods of target\n  options.real        - real prototype method for the `pure` version\n  options.forced      - export even if the native feature is available\n  options.bind        - bind methods to the target, required for the `pure` version\n  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n  options.sham        - add a flag to not completely full polyfills\n  options.enumerable  - export as enumerable property\n  options.noTargetGet - prevent calling a getter on target\n  options.name        - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global;\n  } else if (STATIC) {\n    target = global[TARGET] || setGlobal(TARGET, {});\n  } else {\n    target = (global[TARGET] || {}).prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.noTargetGet) {\n      descriptor = getOwnPropertyDescriptor(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty == typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || (targetProperty && targetProperty.sham)) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    // extend global\n    redefine(target, key, sourceProperty, options);\n  }\n};\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n  return Object.isExtensible(Object.preventExtensions({}));\n});\n","var FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar bind = FunctionPrototype.bind;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (bind ? call.bind(apply) : function () {\n  return call.apply(apply, arguments);\n});\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n  aCallable(fn);\n  return that === undefined ? fn : bind ? bind(fn, that) : function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","var call = Function.prototype.call;\n\nmodule.exports = call.bind ? call.bind(call) : function () {\n  return call.apply(call, arguments);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n  EXISTS: EXISTS,\n  PROPER: PROPER,\n  CONFIGURABLE: CONFIGURABLE\n};\n","var FunctionPrototype = Function.prototype;\nvar bind = FunctionPrototype.bind;\nvar call = FunctionPrototype.call;\nvar callBind = bind && bind.bind(call);\n\nmodule.exports = bind ? function (fn) {\n  return fn && callBind(call, fn);\n} : function (fn) {\n  return fn && function () {\n    return call.apply(fn, arguments);\n  };\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n  return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","var classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n  if (it != undefined) return getMethod(it, ITERATOR)\n    || getMethod(it, '@@iterator')\n    || Iterators[classof(it)];\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar TypeError = global.TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n  throw TypeError(tryToString(argument) + ' is not iterable');\n};\n","var aCallable = require('../internals/a-callable');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n  var func = V[P];\n  return func == null ? undefined : aCallable(func);\n};\n","var check = function (it) {\n  return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n  // eslint-disable-next-line es/no-global-this -- safe\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  // eslint-disable-next-line no-restricted-globals -- safe\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  // eslint-disable-next-line no-new-func -- fallback\n  (function () { return this; })() || Function('return this')();\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n  return hasOwnProperty(toObject(it), key);\n};\n","module.exports = {};\n","var global = require('../internals/global');\n\nmodule.exports = function (a, b) {\n  var console = global.console;\n  if (console && console.error) {\n    arguments.length == 1 ? console.error(a) : console.error(a, b);\n  }\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n  // eslint-disable-next-line es/no-object-defineproperty -- requied for testing\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a != 7;\n});\n","var global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar Object = global.Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins -- safe\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) == 'String' ? split(it, '') : Object(it);\n} : Object;\n","var isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n  var NewTarget, NewTargetPrototype;\n  if (\n    // it can work only with native `setPrototypeOf`\n    setPrototypeOf &&\n    // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n    isCallable(NewTarget = dummy.constructor) &&\n    NewTarget !== Wrapper &&\n    isObject(NewTargetPrototype = NewTarget.prototype) &&\n    NewTargetPrototype !== Wrapper.prototype\n  ) setPrototypeOf($this, NewTargetPrototype);\n  return $this;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n  store.inspectSource = function (it) {\n    return functionToString(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n","var isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\n// `InstallErrorCause` abstract operation\n// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause\nmodule.exports = function (O, options) {\n  if (isObject(options) && 'cause' in options) {\n    createNonEnumerableProperty(O, 'cause', options.cause);\n  }\n};\n","var $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar isExtensible = Object.isExtensible || function () {\n  return true;\n};\n\nvar setMetadata = function (it) {\n  defineProperty(it, METADATA, { value: {\n    objectID: 'O' + id++, // object ID\n    weakData: {}          // weak collections IDs\n  } });\n};\n\nvar fastKey = function (it, create) {\n  // return a primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!hasOwn(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMetadata(it);\n  // return object ID\n  } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n  if (!hasOwn(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMetadata(it);\n  // return the store of weak collections IDs\n  } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n  return it;\n};\n\nvar enable = function () {\n  meta.enable = function () { /* empty */ };\n  REQUIRED = true;\n  var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n  var splice = uncurryThis([].splice);\n  var test = {};\n  test[METADATA] = 1;\n\n  // prevent exposing of metadata key\n  if (getOwnPropertyNames(test).length) {\n    getOwnPropertyNamesModule.f = function (it) {\n      var result = getOwnPropertyNames(it);\n      for (var i = 0, length = result.length; i < length; i++) {\n        if (result[i] === METADATA) {\n          splice(result, i, 1);\n          break;\n        }\n      } return result;\n    };\n\n    $({ target: 'Object', stat: true, forced: true }, {\n      getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n    });\n  }\n};\n\nvar meta = module.exports = {\n  enable: enable,\n  fastKey: fastKey,\n  getWeakData: getWeakData,\n  onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n  return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n    } return state;\n  };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n  var store = shared.state || (shared.state = new WeakMap());\n  var wmget = uncurryThis(store.get);\n  var wmhas = uncurryThis(store.has);\n  var wmset = uncurryThis(store.set);\n  set = function (it, metadata) {\n    if (wmhas(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    wmset(store, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget(store, it) || {};\n  };\n  has = function (it) {\n    return wmhas(store, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n    metadata.facade = it;\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return hasOwn(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return hasOwn(it, STATE);\n  };\n}\n\nmodule.exports = {\n  set: set,\n  get: get,\n  has: has,\n  enforce: enforce,\n  getterFor: getterFor\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","var classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n  return classof(argument) == 'Array';\n};\n","// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = function (argument) {\n  return typeof argument == 'function';\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.exec(noop);\n\nvar isConstructorModern = function (argument) {\n  if (!isCallable(argument)) return false;\n  try {\n    construct(noop, empty, argument);\n    return true;\n  } catch (error) {\n    return false;\n  }\n};\n\nvar isConstructorLegacy = function (argument) {\n  if (!isCallable(argument)) return false;\n  switch (classof(argument)) {\n    case 'AsyncFunction':\n    case 'GeneratorFunction':\n    case 'AsyncGeneratorFunction': return false;\n    // we can't check .prototype since constructors produced by .bind haven't it\n  } return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n};\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n  var called;\n  return isConstructorModern(isConstructorModern.call)\n    || !isConstructorModern(Object)\n    || !isConstructorModern(function () { called = true; })\n    || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","var fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value == POLYFILL ? true\n    : value == NATIVE ? false\n    : isCallable(detection) ? fails(detection)\n    : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","var isObject = require('../internals/is-object');\n\nvar floor = Math.floor;\n\n// `IsIntegralNumber` abstract operation\n// https://tc39.es/ecma262/#sec-isintegralnumber\n// eslint-disable-next-line es/no-number-isinteger -- safe\nmodule.exports = Number.isInteger || function isInteger(it) {\n  return !isObject(it) && isFinite(it) && floor(it) === it;\n};\n","var isCallable = require('../internals/is-callable');\n\nmodule.exports = function (it) {\n  return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","module.exports = false;\n","var global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Object = global.Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n  return typeof it == 'symbol';\n} : function (it) {\n  var $Symbol = getBuiltIn('Symbol');\n  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, Object(it));\n};\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar TypeError = global.TypeError;\n\nvar Result = function (stopped, result) {\n  this.stopped = stopped;\n  this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n  var that = options && options.that;\n  var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n  var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n  var INTERRUPTED = !!(options && options.INTERRUPTED);\n  var fn = bind(unboundFunction, that);\n  var iterator, iterFn, index, length, result, next, step;\n\n  var stop = function (condition) {\n    if (iterator) iteratorClose(iterator, 'normal', condition);\n    return new Result(true, condition);\n  };\n\n  var callFn = function (value) {\n    if (AS_ENTRIES) {\n      anObject(value);\n      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n    } return INTERRUPTED ? fn(value, stop) : fn(value);\n  };\n\n  if (IS_ITERATOR) {\n    iterator = iterable;\n  } else {\n    iterFn = getIteratorMethod(iterable);\n    if (!iterFn) throw TypeError(tryToString(iterable) + ' is not iterable');\n    // optimisation for array iterators\n    if (isArrayIteratorMethod(iterFn)) {\n      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n        result = callFn(iterable[index]);\n        if (result && isPrototypeOf(ResultPrototype, result)) return result;\n      } return new Result(false);\n    }\n    iterator = getIterator(iterable, iterFn);\n  }\n\n  next = iterator.next;\n  while (!(step = call(next, iterator)).done) {\n    try {\n      result = callFn(step.value);\n    } catch (error) {\n      iteratorClose(iterator, 'throw', error);\n    }\n    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n  } return new Result(false);\n};\n","var call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n  var innerResult, innerError;\n  anObject(iterator);\n  try {\n    innerResult = getMethod(iterator, 'return');\n    if (!innerResult) {\n      if (kind === 'throw') throw value;\n      return value;\n    }\n    innerResult = call(innerResult, iterator);\n  } catch (error) {\n    innerError = true;\n    innerResult = error;\n  }\n  if (kind === 'throw') throw value;\n  if (innerError) throw innerResult;\n  anObject(innerResult);\n  return value;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n  arrayIterator = [].keys();\n  // Safari 8 has buggy iterators w/o `next`\n  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n  else {\n    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n  }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () {\n  var test = {};\n  // FF44- legacy iterators case\n  return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n  redefine(IteratorPrototype, ITERATOR, function () {\n    return this;\n  });\n}\n\nmodule.exports = {\n  IteratorPrototype: IteratorPrototype,\n  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","module.exports = {};\n","var toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n  return toLength(obj.length);\n};\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\n\nvar flush, head, last, notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!queueMicrotask) {\n  flush = function () {\n    var parent, fn;\n    if (IS_NODE && (parent = process.domain)) parent.exit();\n    while (head) {\n      fn = head.fn;\n      head = head.next;\n      try {\n        fn();\n      } catch (error) {\n        if (head) notify();\n        else last = undefined;\n        throw error;\n      }\n    } last = undefined;\n    if (parent) parent.enter();\n  };\n\n  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n  // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n  if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n    toggle = true;\n    node = document.createTextNode('');\n    new MutationObserver(flush).observe(node, { characterData: true });\n    notify = function () {\n      node.data = toggle = !toggle;\n    };\n  // environments with maybe non-completely correct, but existent Promise\n  } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n    // Promise.resolve without an argument throws an error in LG WebOS 2\n    promise = Promise.resolve(undefined);\n    // workaround of WebKit ~ iOS Safari 10.1 bug\n    promise.constructor = Promise;\n    then = bind(promise.then, promise);\n    notify = function () {\n      then(flush);\n    };\n  // Node.js without promises\n  } else if (IS_NODE) {\n    notify = function () {\n      process.nextTick(flush);\n    };\n  // for other environments - macrotask based on:\n  // - setImmediate\n  // - MessageChannel\n  // - window.postMessag\n  // - onreadystatechange\n  // - setTimeout\n  } else {\n    // strange IE + webpack dev server bug - use .bind(global)\n    macrotask = bind(macrotask, global);\n    notify = function () {\n      macrotask(flush);\n    };\n  }\n}\n\nmodule.exports = queueMicrotask || function (fn) {\n  var task = { fn: fn, next: undefined };\n  if (last) last.next = task;\n  if (!head) {\n    head = task;\n    notify();\n  } last = task;\n};\n","var global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  var symbol = Symbol();\n  // Chrome 38 Symbol has incorrect toString conversion\n  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n  return !String(symbol) || !(Object(symbol) instanceof Symbol) ||\n    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n    !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(inspectSource(WeakMap));\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar PromiseCapability = function (C) {\n  var resolve, reject;\n  this.promise = new C(function ($$resolve, $$reject) {\n    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');\n    resolve = $$resolve;\n    reject = $$reject;\n  });\n  this.resolve = aCallable(resolve);\n  this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n  return new PromiseCapability(C);\n};\n","var toString = require('../internals/to-string');\n\nmodule.exports = function (argument, $default) {\n  return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);\n};\n","var global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toString = require('../internals/to-string');\nvar trim = require('../internals/string-trim').trim;\nvar whitespaces = require('../internals/whitespaces');\n\nvar charAt = uncurryThis(''.charAt);\nvar n$ParseFloat = global.parseFloat;\nvar Symbol = global.Symbol;\nvar ITERATOR = Symbol && Symbol.iterator;\nvar FORCED = 1 / n$ParseFloat(whitespaces + '-0') !== -Infinity\n  // MS Edge 18- broken with boxed symbols\n  || (ITERATOR && !fails(function () { n$ParseFloat(Object(ITERATOR)); }));\n\n// `parseFloat` method\n// https://tc39.es/ecma262/#sec-parsefloat-string\nmodule.exports = FORCED ? function parseFloat(string) {\n  var trimmedString = trim(toString(string));\n  var result = n$ParseFloat(trimmedString);\n  return result === 0 && charAt(trimmedString, 0) == '-' ? -0 : result;\n} : n$ParseFloat;\n","var global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toString = require('../internals/to-string');\nvar trim = require('../internals/string-trim').trim;\nvar whitespaces = require('../internals/whitespaces');\n\nvar $parseInt = global.parseInt;\nvar Symbol = global.Symbol;\nvar ITERATOR = Symbol && Symbol.iterator;\nvar hex = /^[+-]?0x/i;\nvar exec = uncurryThis(hex.exec);\nvar FORCED = $parseInt(whitespaces + '08') !== 8 || $parseInt(whitespaces + '0x16') !== 22\n  // MS Edge 18- broken with boxed symbols\n  || (ITERATOR && !fails(function () { $parseInt(Object(ITERATOR)); }));\n\n// `parseInt` method\n// https://tc39.es/ecma262/#sec-parseint-string-radix\nmodule.exports = FORCED ? function parseInt(string, radix) {\n  var S = trim(toString(string));\n  return $parseInt(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10));\n} : $parseInt;\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n  // should have correct order of operations (Edge bug)\n  if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n    enumerable: true,\n    get: function () {\n      defineProperty(this, 'b', {\n        value: 3,\n        enumerable: false\n      });\n    }\n  }), { b: 2 })).b !== 1) return true;\n  // should work with symbols and should have deterministic property order (V8 bug)\n  var A = {};\n  var B = {};\n  // eslint-disable-next-line es/no-symbol -- safe\n  var symbol = Symbol();\n  var alphabet = 'abcdefghijklmnopqrst';\n  A[symbol] = 7;\n  alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n  return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n  var T = toObject(target);\n  var argumentsLength = arguments.length;\n  var index = 1;\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  var propertyIsEnumerable = propertyIsEnumerableModule.f;\n  while (argumentsLength > index) {\n    var S = IndexedObject(arguments[index++]);\n    var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n    var length = keys.length;\n    var j = 0;\n    var key;\n    while (length > j) {\n      key = keys[j++];\n      if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n    }\n  } return T;\n} : $assign;\n","/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar defineProperties = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    activeXDocument = new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = typeof document != 'undefined'\n    ? document.domain && activeXDocument\n      ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n      : NullProtoObjectViaIFrame()\n    : NullProtoObjectViaActiveX(activeXDocument); // WSH\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : defineProperties(result, Properties);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var props = toIndexedObject(Properties);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n  return O;\n};\n","var global = require('../internals/global');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar TypeError = global.TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPropertyKey(P);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return $defineProperty(O, P, Attributes);\n  } catch (error) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPropertyKey(P);\n  if (IE8_DOM_DEFINE) try {\n    return $getOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n  try {\n    return $getOwnPropertyNames(it);\n  } catch (error) {\n    return arraySlice(windowNames);\n  }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n  return windowNames && classof(it) == 'Window'\n    ? getWindowNames(it)\n    : $getOwnPropertyNames(toIndexedObject(it));\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","var global = require('../internals/global');\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar Object = global.Object;\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n  var object = toObject(O);\n  if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n  var constructor = object.constructor;\n  if (isCallable(constructor) && object instanceof constructor) {\n    return constructor.prototype;\n  } return object instanceof Object ? ObjectPrototype : null;\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (hasOwn(O, key = names[i++])) {\n    ~indexOf(result, key) || push(result, key);\n  }\n  return result;\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","/* eslint-disable no-proto -- safe */\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n  var CORRECT_SETTER = false;\n  var test = {};\n  var setter;\n  try {\n    // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n    setter = uncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);\n    setter(test, []);\n    CORRECT_SETTER = test instanceof Array;\n  } catch (error) { /* empty */ }\n  return function setPrototypeOf(O, proto) {\n    anObject(O);\n    aPossiblePrototype(proto);\n    if (CORRECT_SETTER) setter(O, proto);\n    else O.__proto__ = proto;\n    return O;\n  };\n}() : undefined);\n","var DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\nvar propertyIsEnumerable = uncurryThis($propertyIsEnumerable);\nvar push = uncurryThis([].push);\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n  return function (it) {\n    var O = toIndexedObject(it);\n    var keys = objectKeys(O);\n    var length = keys.length;\n    var i = 0;\n    var result = [];\n    var key;\n    while (length > i) {\n      key = keys[i++];\n      if (!DESCRIPTORS || propertyIsEnumerable(O, key)) {\n        push(result, TO_ENTRIES ? [key, O[key]] : O[key]);\n      }\n    }\n    return result;\n  };\n};\n\nmodule.exports = {\n  // `Object.entries` method\n  // https://tc39.es/ecma262/#sec-object.entries\n  entries: createMethod(true),\n  // `Object.values` method\n  // https://tc39.es/ecma262/#sec-object.values\n  values: createMethod(false)\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n  return '[object ' + classof(this) + ']';\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar TypeError = global.TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n  var fn, val;\n  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","var getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = getOwnPropertyNamesModule.f(anObject(it));\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","module.exports = function (exec) {\n  try {\n    return { error: false, value: exec() };\n  } catch (error) {\n    return { error: true, value: error };\n  }\n};\n","var anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n  anObject(C);\n  if (isObject(x) && x.constructor === C) return x;\n  var promiseCapability = newPromiseCapability.f(C);\n  var resolve = promiseCapability.resolve;\n  resolve(x);\n  return promiseCapability.promise;\n};\n","var redefine = require('../internals/redefine');\n\nmodule.exports = function (target, src, options) {\n  for (var key in src) redefine(target, key, src[key], options);\n  return target;\n};\n","var global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n  var unsafe = options ? !!options.unsafe : false;\n  var simple = options ? !!options.enumerable : false;\n  var noTargetGet = options ? !!options.noTargetGet : false;\n  var name = options && options.name !== undefined ? options.name : key;\n  var state;\n  if (isCallable(value)) {\n    if (String(name).slice(0, 7) === 'Symbol(') {\n      name = '[' + String(name).replace(/^Symbol\\(([^)]*)\\)/, '$1') + ']';\n    }\n    if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n      createNonEnumerableProperty(value, 'name', name);\n    }\n    state = enforceInternalState(value);\n    if (!state.source) {\n      state.source = TEMPLATE.join(typeof name == 'string' ? name : '');\n    }\n  }\n  if (O === global) {\n    if (simple) O[key] = value;\n    else setGlobal(key, value);\n    return;\n  } else if (!unsafe) {\n    delete O[key];\n  } else if (!noTargetGet && O[key]) {\n    simple = true;\n  }\n  if (simple) O[key] = value;\n  else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n  return isCallable(this) && getInternalState(this).source || inspectSource(this);\n});\n","var global = require('../internals/global');\n\nvar TypeError = global.TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n  return it;\n};\n","var global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n  try {\n    defineProperty(global, key, { value: value, configurable: true, writable: true });\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar definePropertyModule = require('../internals/object-define-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n  var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n  var defineProperty = definePropertyModule.f;\n\n  if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n    defineProperty(Constructor, SPECIES, {\n      configurable: true,\n      get: function () { return this; }\n    });\n  }\n};\n","var defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (it, TAG, STATIC) {\n  if (it && !hasOwn(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {\n    defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });\n  }\n};\n","var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\n","var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n","var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: '3.19.0',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2021 Denis Pushkarev (zloirock.ru)'\n});\n","var anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n  var C = anObject(O).constructor;\n  var S;\n  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aConstructor(S);\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n  return function ($this, pos) {\n    var S = toString(requireObjectCoercible($this));\n    var position = toIntegerOrInfinity(pos);\n    var size = S.length;\n    var first, second;\n    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n    first = charCodeAt(S, position);\n    return first < 0xD800 || first > 0xDBFF || position + 1 === size\n      || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n        ? CONVERT_TO_STRING\n          ? charAt(S, position)\n          : first\n        : CONVERT_TO_STRING\n          ? stringSlice(S, position, position + 2)\n          : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.codePointAt` method\n  // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n  codeAt: createMethod(false),\n  // `String.prototype.at` method\n  // https://github.com/mathiasbynens/String.prototype.at\n  charAt: createMethod(true)\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\nvar whitespaces = require('../internals/whitespaces');\n\nvar replace = uncurryThis(''.replace);\nvar whitespace = '[' + whitespaces + ']';\nvar ltrim = RegExp('^' + whitespace + whitespace + '*');\nvar rtrim = RegExp(whitespace + whitespace + '*$');\n\n// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation\nvar createMethod = function (TYPE) {\n  return function ($this) {\n    var string = toString(requireObjectCoercible($this));\n    if (TYPE & 1) string = replace(string, ltrim, '');\n    if (TYPE & 2) string = replace(string, rtrim, '');\n    return string;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.{ trimLeft, trimStart }` methods\n  // https://tc39.es/ecma262/#sec-string.prototype.trimstart\n  start: createMethod(1),\n  // `String.prototype.{ trimRight, trimEnd }` methods\n  // https://tc39.es/ecma262/#sec-string.prototype.trimend\n  end: createMethod(2),\n  // `String.prototype.trim` method\n  // https://tc39.es/ecma262/#sec-string.prototype.trim\n  trim: createMethod(3)\n};\n","var global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar location, defer, channel, port;\n\ntry {\n  // Deno throws a ReferenceError on `location` access without `--location` flag\n  location = global.location;\n} catch (error) { /* empty */ }\n\nvar run = function (id) {\n  if (hasOwn(queue, id)) {\n    var fn = queue[id];\n    delete queue[id];\n    fn();\n  }\n};\n\nvar runner = function (id) {\n  return function () {\n    run(id);\n  };\n};\n\nvar listener = function (event) {\n  run(event.data);\n};\n\nvar post = function (id) {\n  // old engines have not location.origin\n  global.postMessage(String(id), location.protocol + '//' + location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n  set = function setImmediate(fn) {\n    var args = arraySlice(arguments, 1);\n    queue[++counter] = function () {\n      apply(isCallable(fn) ? fn : Function(fn), undefined, args);\n    };\n    defer(counter);\n    return counter;\n  };\n  clear = function clearImmediate(id) {\n    delete queue[id];\n  };\n  // Node.js 0.8-\n  if (IS_NODE) {\n    defer = function (id) {\n      process.nextTick(runner(id));\n    };\n  // Sphere (JS game engine) Dispatch API\n  } else if (Dispatch && Dispatch.now) {\n    defer = function (id) {\n      Dispatch.now(runner(id));\n    };\n  // Browsers with MessageChannel, includes WebWorkers\n  // except iOS - https://github.com/zloirock/core-js/issues/624\n  } else if (MessageChannel && !IS_IOS) {\n    channel = new MessageChannel();\n    port = channel.port2;\n    channel.port1.onmessage = listener;\n    defer = bind(port.postMessage, port);\n  // Browsers with postMessage, skip WebWorkers\n  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n  } else if (\n    global.addEventListener &&\n    isCallable(global.postMessage) &&\n    !global.importScripts &&\n    location && location.protocol !== 'file:' &&\n    !fails(post)\n  ) {\n    defer = post;\n    global.addEventListener('message', listener, false);\n  // IE8-\n  } else if (ONREADYSTATECHANGE in createElement('script')) {\n    defer = function (id) {\n      html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n        html.removeChild(this);\n        run(id);\n      };\n    };\n  // Rest old browsers\n  } else {\n    defer = function (id) {\n      setTimeout(runner(id), 0);\n    };\n  }\n}\n\nmodule.exports = {\n  set: set,\n  clear: clear\n};\n","var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n  var integer = toIntegerOrInfinity(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n  return IndexedObject(requireObjectCoercible(it));\n};\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n  var number = +argument;\n  // eslint-disable-next-line no-self-compare -- safe\n  return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number);\n};\n","var toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","var global = require('../internals/global');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar Object = global.Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n  return Object(requireObjectCoercible(argument));\n};\n","var global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TypeError = global.TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n  if (!isObject(input) || isSymbol(input)) return input;\n  var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n  var result;\n  if (exoticToPrim) {\n    if (pref === undefined) pref = 'default';\n    result = call(exoticToPrim, input, pref);\n    if (!isObject(result) || isSymbol(result)) return result;\n    throw TypeError(\"Can't convert object to primitive value\");\n  }\n  if (pref === undefined) pref = 'number';\n  return ordinaryToPrimitive(input, pref);\n};\n","var toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n  var key = toPrimitive(argument, 'string');\n  return isSymbol(key) ? key : key + '';\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","var global = require('../internals/global');\nvar classof = require('../internals/classof');\n\nvar String = global.String;\n\nmodule.exports = function (argument) {\n  if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');\n  return String(argument);\n};\n","var global = require('../internals/global');\n\nvar String = global.String;\n\nmodule.exports = function (argument) {\n  try {\n    return String(argument);\n  } catch (error) {\n    return 'Object';\n  }\n};\n","var uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  && !Symbol.sham\n  && typeof Symbol.iterator == 'symbol';\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar symbolFor = Symbol && Symbol['for'];\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!hasOwn(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {\n    var description = 'Symbol.' + name;\n    if (NATIVE_SYMBOL && hasOwn(Symbol, name)) {\n      WellKnownSymbolsStore[name] = Symbol[name];\n    } else if (USE_SYMBOL_AS_UID && symbolFor) {\n      WellKnownSymbolsStore[name] = symbolFor(description);\n    } else {\n      WellKnownSymbolsStore[name] = createWellKnownSymbol(description);\n    }\n  } return WellKnownSymbolsStore[name];\n};\n","// a string of all valid unicode whitespaces\nmodule.exports = '\\u0009\\u000A\\u000B\\u000C\\u000D\\u0020\\u00A0\\u1680\\u2000\\u2001\\u2002' +\n  '\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF';\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar create = require('../internals/object-create');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar clearErrorStack = require('../internals/clear-error-stack');\nvar installErrorCause = require('../internals/install-error-cause');\nvar iterate = require('../internals/iterate');\nvar normalizeStringArgument = require('../internals/normalize-string-argument');\nvar ERROR_STACK_INSTALLABLE = require('../internals/error-stack-installable');\n\nvar Error = global.Error;\nvar push = [].push;\n\nvar $AggregateError = function AggregateError(errors, message /* , options */) {\n  var that = isPrototypeOf(AggregateErrorPrototype, this) ? this : create(AggregateErrorPrototype);\n  var options = arguments.length > 2 ? arguments[2] : undefined;\n  if (setPrototypeOf) {\n    that = setPrototypeOf(new Error(undefined), getPrototypeOf(that));\n  }\n  createNonEnumerableProperty(that, 'message', normalizeStringArgument(message, ''));\n  if (ERROR_STACK_INSTALLABLE) createNonEnumerableProperty(that, 'stack', clearErrorStack(that.stack, 1));\n  installErrorCause(that, options);\n  var errorsArray = [];\n  iterate(errors, push, { that: errorsArray });\n  createNonEnumerableProperty(that, 'errors', errorsArray);\n  return that;\n};\n\nif (setPrototypeOf) setPrototypeOf($AggregateError, Error);\nelse copyConstructorProperties($AggregateError, Error);\n\nvar AggregateErrorPrototype = $AggregateError.prototype = create(Error.prototype, {\n  constructor: createPropertyDescriptor(1, $AggregateError),\n  message: createPropertyDescriptor(1, ''),\n  name: createPropertyDescriptor(1, 'AggregateError')\n});\n\n// `AggregateError` constructor\n// https://tc39.es/ecma262/#sec-aggregate-error-constructor\n$({ global: true }, {\n  AggregateError: $AggregateError\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar $find = require('../internals/array-iteration').find;\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\nvar FIND = 'find';\nvar SKIPS_HOLES = true;\n\n// Shouldn't skip holes\nif (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });\n\n// `Array.prototype.find` method\n// https://tc39.es/ecma262/#sec-array.prototype.find\n$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {\n  find: function find(callbackfn /* , that = undefined */) {\n    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables(FIND);\n","var $ = require('../internals/export');\nvar from = require('../internals/array-from');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\n\nvar INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {\n  // eslint-disable-next-line es/no-array-from -- required for testing\n  Array.from(iterable);\n});\n\n// `Array.from` method\n// https://tc39.es/ecma262/#sec-array.from\n$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {\n  from: from\n});\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n  setInternalState(this, {\n    type: ARRAY_ITERATOR,\n    target: toIndexedObject(iterated), // target\n    index: 0,                          // next index\n    kind: kind                         // kind\n  });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n  var state = getInternalState(this);\n  var target = state.target;\n  var kind = state.kind;\n  var index = state.index++;\n  if (!target || index >= target.length) {\n    state.target = undefined;\n    return { value: undefined, done: true };\n  }\n  if (kind == 'keys') return { value: index, done: false };\n  if (kind == 'values') return { value: target[index], done: false };\n  return { value: [index, target[index]], done: false };\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.es/ecma262/#sec-map-objects\ncollection('Map', function (init) {\n  return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","var $ = require('../internals/export');\nvar isIntegralNumber = require('../internals/is-integral-number');\n\n// `Number.isInteger` method\n// https://tc39.es/ecma262/#sec-number.isinteger\n$({ target: 'Number', stat: true }, {\n  isInteger: isIntegralNumber\n});\n","var $ = require('../internals/export');\n\n// `Number.isNaN` method\n// https://tc39.es/ecma262/#sec-number.isnan\n$({ target: 'Number', stat: true }, {\n  isNaN: function isNaN(number) {\n    // eslint-disable-next-line no-self-compare -- NaN check\n    return number != number;\n  }\n});\n","var $ = require('../internals/export');\nvar parseFloat = require('../internals/number-parse-float');\n\n// `Number.parseFloat` method\n// https://tc39.es/ecma262/#sec-number.parseFloat\n// eslint-disable-next-line es/no-number-parsefloat -- required for testing\n$({ target: 'Number', stat: true, forced: Number.parseFloat != parseFloat }, {\n  parseFloat: parseFloat\n});\n","var $ = require('../internals/export');\nvar parseInt = require('../internals/number-parse-int');\n\n// `Number.parseInt` method\n// https://tc39.es/ecma262/#sec-number.parseint\n// eslint-disable-next-line es/no-number-parseint -- required for testing\n$({ target: 'Number', stat: true, forced: Number.parseInt != parseInt }, {\n  parseInt: parseInt\n});\n","var $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, forced: Object.assign !== assign }, {\n  assign: assign\n});\n","var $ = require('../internals/export');\nvar $entries = require('../internals/object-to-array').entries;\n\n// `Object.entries` method\n// https://tc39.es/ecma262/#sec-object.entries\n$({ target: 'Object', stat: true }, {\n  entries: function entries(O) {\n    return $entries(O);\n  }\n});\n","var $ = require('../internals/export');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n$({ target: 'Object', stat: true }, {\n  setPrototypeOf: setPrototypeOf\n});\n","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar redefine = require('../internals/redefine');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n  redefine(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-promise.allsettled\n$({ target: 'Promise', stat: true }, {\n  allSettled: function allSettled(iterable) {\n    var C = this;\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aCallable(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        remaining++;\n        call(promiseResolve, C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'fulfilled', value: value };\n          --remaining || resolve(values);\n        }, function (error) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'rejected', reason: error };\n          --remaining || resolve(values);\n        });\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar aCallable = require('../internals/a-callable');\nvar getBuiltIn = require('../internals/get-built-in');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\nvar PROMISE_ANY_ERROR = 'No one promise resolved';\n\n// `Promise.any` method\n// https://tc39.es/ecma262/#sec-promise.any\n$({ target: 'Promise', stat: true }, {\n  any: function any(iterable) {\n    var C = this;\n    var AggregateError = getBuiltIn('AggregateError');\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aCallable(C.resolve);\n      var errors = [];\n      var counter = 0;\n      var remaining = 1;\n      var alreadyResolved = false;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyRejected = false;\n        remaining++;\n        call(promiseResolve, C, promise).then(function (value) {\n          if (alreadyRejected || alreadyResolved) return;\n          alreadyResolved = true;\n          resolve(value);\n        }, function (error) {\n          if (alreadyRejected || alreadyResolved) return;\n          alreadyRejected = true;\n          errors[index] = error;\n          --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));\n        });\n      });\n      --remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar fails = require('../internals/fails');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar speciesConstructor = require('../internals/species-constructor');\nvar promiseResolve = require('../internals/promise-resolve');\nvar redefine = require('../internals/redefine');\n\n// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829\nvar NON_GENERIC = !!NativePromise && fails(function () {\n  NativePromise.prototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });\n});\n\n// `Promise.prototype.finally` method\n// https://tc39.es/ecma262/#sec-promise.prototype.finally\n$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {\n  'finally': function (onFinally) {\n    var C = speciesConstructor(this, getBuiltIn('Promise'));\n    var isFunction = isCallable(onFinally);\n    return this.then(\n      isFunction ? function (x) {\n        return promiseResolve(C, onFinally()).then(function () { return x; });\n      } : onFinally,\n      isFunction ? function (e) {\n        return promiseResolve(C, onFinally()).then(function () { throw e; });\n      } : onFinally\n    );\n  }\n});\n\n// makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromise)) {\n  var method = getBuiltIn('Promise').prototype['finally'];\n  if (NativePromise.prototype['finally'] !== method) {\n    redefine(NativePromise.prototype, 'finally', method, { unsafe: true });\n  }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar call = require('../internals/function-call');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar redefine = require('../internals/redefine');\nvar redefineAll = require('../internals/redefine-all');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar inspectSource = require('../internals/inspect-source');\nvar iterate = require('../internals/iterate');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar promiseResolve = require('../internals/promise-resolve');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar InternalStateModule = require('../internals/internal-state');\nvar isForced = require('../internals/is-forced');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_NODE = require('../internals/engine-is-node');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\nvar PROMISE = 'Promise';\n\nvar getInternalState = InternalStateModule.get;\nvar setInternalState = InternalStateModule.set;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar NativePromisePrototype = NativePromise && NativePromise.prototype;\nvar PromiseConstructor = NativePromise;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar NATIVE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\nvar SUBCLASSING = false;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\nvar FORCED = isForced(PROMISE, function () {\n  var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);\n  var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);\n  // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n  // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n  // We can't detect it synchronously, so just check versions\n  if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n  // We need Promise#finally in the pure version for preventing prototype pollution\n  if (IS_PURE && !PromisePrototype['finally']) return true;\n  // We can't use @@species feature detection in V8 since it causes\n  // deoptimization and performance degradation\n  // https://github.com/zloirock/core-js/issues/679\n  if (V8_VERSION >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false;\n  // Detect correctness of subclassing with @@species support\n  var promise = new PromiseConstructor(function (resolve) { resolve(1); });\n  var FakePromise = function (exec) {\n    exec(function () { /* empty */ }, function () { /* empty */ });\n  };\n  var constructor = promise.constructor = {};\n  constructor[SPECIES] = FakePromise;\n  SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n  if (!SUBCLASSING) return true;\n  // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n  return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;\n});\n\nvar INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {\n  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });\n});\n\n// helpers\nvar isThenable = function (it) {\n  var then;\n  return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar notify = function (state, isReject) {\n  if (state.notified) return;\n  state.notified = true;\n  var chain = state.reactions;\n  microtask(function () {\n    var value = state.value;\n    var ok = state.state == FULFILLED;\n    var index = 0;\n    // variable length - can't use forEach\n    while (chain.length > index) {\n      var reaction = chain[index++];\n      var handler = ok ? reaction.ok : reaction.fail;\n      var resolve = reaction.resolve;\n      var reject = reaction.reject;\n      var domain = reaction.domain;\n      var result, then, exited;\n      try {\n        if (handler) {\n          if (!ok) {\n            if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n            state.rejection = HANDLED;\n          }\n          if (handler === true) result = value;\n          else {\n            if (domain) domain.enter();\n            result = handler(value); // can throw\n            if (domain) {\n              domain.exit();\n              exited = true;\n            }\n          }\n          if (result === reaction.promise) {\n            reject(TypeError('Promise-chain cycle'));\n          } else if (then = isThenable(result)) {\n            call(then, result, resolve, reject);\n          } else resolve(result);\n        } else reject(value);\n      } catch (error) {\n        if (domain && !exited) domain.exit();\n        reject(error);\n      }\n    }\n    state.reactions = [];\n    state.notified = false;\n    if (isReject && !state.rejection) onUnhandled(state);\n  });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n  var event, handler;\n  if (DISPATCH_EVENT) {\n    event = document.createEvent('Event');\n    event.promise = promise;\n    event.reason = reason;\n    event.initEvent(name, false, true);\n    global.dispatchEvent(event);\n  } else event = { promise: promise, reason: reason };\n  if (!NATIVE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n  call(task, global, function () {\n    var promise = state.facade;\n    var value = state.value;\n    var IS_UNHANDLED = isUnhandled(state);\n    var result;\n    if (IS_UNHANDLED) {\n      result = perform(function () {\n        if (IS_NODE) {\n          process.emit('unhandledRejection', value, promise);\n        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n      });\n      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n      state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n      if (result.error) throw result.value;\n    }\n  });\n};\n\nvar isUnhandled = function (state) {\n  return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n  call(task, global, function () {\n    var promise = state.facade;\n    if (IS_NODE) {\n      process.emit('rejectionHandled', promise);\n    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n  });\n};\n\nvar bind = function (fn, state, unwrap) {\n  return function (value) {\n    fn(state, value, unwrap);\n  };\n};\n\nvar internalReject = function (state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  state.value = value;\n  state.state = REJECTED;\n  notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  try {\n    if (state.facade === value) throw TypeError(\"Promise can't be resolved itself\");\n    var then = isThenable(value);\n    if (then) {\n      microtask(function () {\n        var wrapper = { done: false };\n        try {\n          call(then, value,\n            bind(internalResolve, wrapper, state),\n            bind(internalReject, wrapper, state)\n          );\n        } catch (error) {\n          internalReject(wrapper, error, state);\n        }\n      });\n    } else {\n      state.value = value;\n      state.state = FULFILLED;\n      notify(state, false);\n    }\n  } catch (error) {\n    internalReject({ done: false }, error, state);\n  }\n};\n\n// constructor polyfill\nif (FORCED) {\n  // 25.4.3.1 Promise(executor)\n  PromiseConstructor = function Promise(executor) {\n    anInstance(this, PromisePrototype);\n    aCallable(executor);\n    call(Internal, this);\n    var state = getInternalState(this);\n    try {\n      executor(bind(internalResolve, state), bind(internalReject, state));\n    } catch (error) {\n      internalReject(state, error);\n    }\n  };\n  PromisePrototype = PromiseConstructor.prototype;\n  // eslint-disable-next-line no-unused-vars -- required for `.length`\n  Internal = function Promise(executor) {\n    setInternalState(this, {\n      type: PROMISE,\n      done: false,\n      notified: false,\n      parent: false,\n      reactions: [],\n      rejection: false,\n      state: PENDING,\n      value: undefined\n    });\n  };\n  Internal.prototype = redefineAll(PromisePrototype, {\n    // `Promise.prototype.then` method\n    // https://tc39.es/ecma262/#sec-promise.prototype.then\n    then: function then(onFulfilled, onRejected) {\n      var state = getInternalPromiseState(this);\n      var reactions = state.reactions;\n      var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n      reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n      reaction.fail = isCallable(onRejected) && onRejected;\n      reaction.domain = IS_NODE ? process.domain : undefined;\n      state.parent = true;\n      reactions[reactions.length] = reaction;\n      if (state.state != PENDING) notify(state, false);\n      return reaction.promise;\n    },\n    // `Promise.prototype.catch` method\n    // https://tc39.es/ecma262/#sec-promise.prototype.catch\n    'catch': function (onRejected) {\n      return this.then(undefined, onRejected);\n    }\n  });\n  OwnPromiseCapability = function () {\n    var promise = new Internal();\n    var state = getInternalState(promise);\n    this.promise = promise;\n    this.resolve = bind(internalResolve, state);\n    this.reject = bind(internalReject, state);\n  };\n  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n    return C === PromiseConstructor || C === PromiseWrapper\n      ? new OwnPromiseCapability(C)\n      : newGenericPromiseCapability(C);\n  };\n\n  if (!IS_PURE && isCallable(NativePromise) && NativePromisePrototype !== Object.prototype) {\n    nativeThen = NativePromisePrototype.then;\n\n    if (!SUBCLASSING) {\n      // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n      redefine(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n        var that = this;\n        return new PromiseConstructor(function (resolve, reject) {\n          call(nativeThen, that, resolve, reject);\n        }).then(onFulfilled, onRejected);\n      // https://github.com/zloirock/core-js/issues/640\n      }, { unsafe: true });\n\n      // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\n      redefine(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });\n    }\n\n    // make `.constructor === Promise` work for native promise-based APIs\n    try {\n      delete NativePromisePrototype.constructor;\n    } catch (error) { /* empty */ }\n\n    // make `instanceof Promise` work for native promise-based APIs\n    if (setPrototypeOf) {\n      setPrototypeOf(NativePromisePrototype, PromisePrototype);\n    }\n  }\n}\n\n$({ global: true, wrap: true, forced: FORCED }, {\n  Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n\nPromiseWrapper = getBuiltIn(PROMISE);\n\n// statics\n$({ target: PROMISE, stat: true, forced: FORCED }, {\n  // `Promise.reject` method\n  // https://tc39.es/ecma262/#sec-promise.reject\n  reject: function reject(r) {\n    var capability = newPromiseCapability(this);\n    call(capability.reject, undefined, r);\n    return capability.promise;\n  }\n});\n\n$({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, {\n  // `Promise.resolve` method\n  // https://tc39.es/ecma262/#sec-promise.resolve\n  resolve: function resolve(x) {\n    return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);\n  }\n});\n\n$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {\n  // `Promise.all` method\n  // https://tc39.es/ecma262/#sec-promise.all\n  all: function all(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var $promiseResolve = aCallable(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        remaining++;\n        call($promiseResolve, C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = value;\n          --remaining || resolve(values);\n        }, reject);\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  },\n  // `Promise.race` method\n  // https://tc39.es/ecma262/#sec-promise.race\n  race: function race(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var reject = capability.reject;\n    var result = perform(function () {\n      var $promiseResolve = aCallable(C.resolve);\n      iterate(iterable, function (promise) {\n        call($promiseResolve, C, promise).then(capability.resolve, reject);\n      });\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n  setInternalState(this, {\n    type: STRING_ITERATOR,\n    string: toString(iterated),\n    index: 0\n  });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n  var state = getInternalState(this);\n  var string = state.string;\n  var index = state.index;\n  var point;\n  if (index >= string.length) return { value: undefined, done: true };\n  point = charAt(string, index);\n  state.index += point.length;\n  return { value: point, done: false };\n});\n","(function () {\n  var validator = new RegExp(\"^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}$\", \"i\");\n\n  function gen(count) {\n    var out = \"\";\n    for (var i=0; i<count; i++) {\n      out += (((1+Math.random())*0x10000)|0).toString(16).substring(1);\n    }\n    return out;\n  }\n\n  function Guid(guid) {\n    if (!guid) throw new TypeError(\"Invalid argument; `value` has no value.\");\n      \n    this.value = Guid.EMPTY;\n    \n    if (guid && guid instanceof Guid) {\n      this.value = guid.toString();\n\n    } else if (guid && Object.prototype.toString.call(guid) === \"[object String]\" && Guid.isGuid(guid)) {\n      this.value = guid;\n    }\n    \n    this.equals = function(other) {\n      // Comparing string `value` against provided `guid` will auto-call\n      // toString on `guid` for comparison\n      return Guid.isGuid(other) && this.value == other;\n    };\n\n    this.isEmpty = function() {\n      return this.value === Guid.EMPTY;\n    };\n    \n    this.toString = function() {\n      return this.value;\n    };\n    \n    this.toJSON = function() {\n      return this.value;\n    };\n  };\n\n  Guid.EMPTY = \"00000000-0000-0000-0000-000000000000\";\n\n  Guid.isGuid = function(value) {\n    return value && (value instanceof Guid || validator.test(value.toString()));\n  };\n\n  Guid.create = function() {\n    return new Guid([gen(2), gen(1), gen(1), gen(1), gen(3)].join(\"-\"));\n  };\n\n  Guid.raw = function() {\n    return [gen(2), gen(1), gen(1), gen(1), gen(3)].join(\"-\");\n  };\n\n  if(typeof module != 'undefined' && module.exports) {\n    module.exports = Guid;\n  }\n  else if (typeof window != 'undefined') {\n    window.Guid = Guid;\n  }\n})();\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEvent } from './TableauEvent';\n\nexport class DashboardLayoutChangedEvent extends TableauEvent implements Contract.DashboardLayoutChangedEvent {\n  public constructor(public _dashboardLayoutChangeDetails: Contract.DashboardLayoutChangeDetails) {\n    super(Contract.TableauEventType.DashboardLayoutChanged);\n  }\n\n  public get dashboardLayoutChangeDetails(): Contract.DashboardLayoutChangeDetails {\n    return this._dashboardLayoutChangeDetails;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauError } from '@tableau/api-shared-js';\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\n\nexport class FilterChangedEvent extends TableauWorksheetEvent implements Contract.FilterChangedEvent {\n  public constructor(worksheet: Contract.ExtensionWorksheet, private _fieldName: string, private _fieldId?: string) {\n    super(TableauEventType.FilterChanged, worksheet);\n  }\n\n  public get fieldName(): string {\n    return this._fieldName;\n  }\n\n  public get fieldId(): string | undefined {\n    return this._fieldId;\n  }\n\n  public getFilterAsync(): Promise<Contract.Filter> {\n    return this._worksheet.getFiltersAsync().then<Contract.Filter>((filters) => {\n      // TODO: Filtering of the filters should eventually be done platform side.\n      const eventedFilter = this.fieldId\n        ? filters.find((filter) => filter.fieldId === this.fieldId, this)\n        : filters.find((filter) => filter.fieldName === this.fieldName, this);\n\n      if (!eventedFilter) {\n        // We shouldn't hit this unless the filter was removed from the worksheet\n        // after the event was raised.\n        throw new TableauError(ErrorCodes.MissingFilter, `cannot find filter: ${this._fieldName}`);\n      }\n\n      return eventedFilter;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\n\nexport class MarksSelectedEvent extends TableauWorksheetEvent implements Contract.MarksSelectedEvent {\n  public constructor(worksheet: Contract.ExtensionWorksheet) {\n    super(TableauEventType.MarkSelectionChanged, worksheet);\n  }\n\n  public getMarksAsync(): Promise<Contract.MarksCollection> {\n    return this.worksheet.getSelectedMarksAsync();\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, TableauEventType } from '@tableau/api-external-contract-js';\nimport { ApiServiceRegistry, ParametersService, ServiceNames, TableauError } from '@tableau/api-shared-js';\nimport { Parameter } from '../Models/Parameter';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { TableauSheetEvent } from './TableauSheetEvent';\n\nexport class ParameterChangedEvent extends TableauSheetEvent implements Contract.ParameterChangedEvent {\n  public constructor(private _globalFieldName: string, sheet: Contract.ExtensionSheet) {\n    super(TableauEventType.ParameterChanged, sheet);\n  }\n\n  public getParameterAsync(): Promise<Contract.Parameter> {\n    // Call down to our service to get the parameter back via its field name\n    const service = ApiServiceRegistry.get(ExtensionsRegistryId).getService<ParametersService>(ServiceNames.Parameters);\n    return service.findParameterByGlobalFieldNameAsync(this._globalFieldName).then((parameterImpl) => {\n      if (parameterImpl === undefined) {\n        throw new TableauError(ErrorCodes.MissingParameter, `Cannot find parameter: ${this._globalFieldName}`);\n      }\n\n      return new Parameter(parameterImpl, this.sheet);\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauWorksheetEvent } from './TableauWorksheetEvent';\n\nexport class SummaryDataChangedEvent extends TableauWorksheetEvent implements Contract.SummaryDataChangedEvent {\n  public constructor(worksheet: Contract.ExtensionWorksheet) {\n    super(TableauEventType.SummaryDataChanged, worksheet);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\n\nexport class TableauEvent implements Contract.TableauEvent {\n  private _type: TableauEventType;\n\n  public constructor(type: TableauEventType) {\n    this._type = type;\n  }\n\n  public get type(): TableauEventType {\n    return this._type;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauEvent } from './TableauEvent';\n\nexport class TableauSheetEvent extends TableauEvent implements Contract.TableauSheetEvent {\n  private _sheet: Contract.ExtensionSheet;\n\n  public get sheet(): Contract.ExtensionSheet {\n    return this._sheet;\n  }\n\n  public constructor(type: TableauEventType, sheet: Contract.ExtensionSheet) {\n    super(type);\n\n    this._sheet = sheet;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { TableauSheetEvent } from './TableauSheetEvent';\n\nexport class TableauWorksheetEvent extends TableauSheetEvent implements Contract.TableauWorksheetEvent {\n  public get worksheet(): Contract.ExtensionWorksheet {\n    return this._worksheet;\n  }\n\n  public constructor(type: TableauEventType, protected _worksheet: Contract.ExtensionWorksheet) {\n    super(type, _worksheet);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEvent } from './TableauEvent';\n\nexport class WorkbookFormattingChangedEvent extends TableauEvent implements Contract.WorkbookFormattingChangedEvent {\n  public constructor(private _formatting: Contract.WorkbookFormatting) {\n    super(Contract.TableauEventType.WorkbookFormattingChanged);\n  }\n\n  public get formatting(): Contract.WorkbookFormatting {\n    return this._formatting;\n  }\n}\n","import { Model } from '@tableau/api-internal-contract-js';\n\nexport const BentonSansFontFamilyName = 'Benton Sans';\nexport const BentonSansLowDPIFontFamilyName = 'Benton Sans Low-DPI';\n\nexport const BentonSansBookFontFaceName = 'Benton Sans Book';\nexport const BentonSansBookItalicFontFaceName = 'Benton Sans Book Italic';\nexport const BentonSansSemiDemiFontFaceName = 'Benton Sans SemiDemi';\nexport const BentonSansSemiDemiItalicFontFaceName = 'Benton Sans SemiDemi Italic';\nexport const BentonSansLightFontFaceName = 'Benton Sans Light';\nexport const BentonSansMediumFontFaceName = 'Benton Sans Medium';\n\nexport const SupportedBentonSansFontFaces: Model[] = [\n  BentonSansBookFontFaceName,\n  BentonSansBookItalicFontFaceName,\n  BentonSansSemiDemiFontFaceName,\n  BentonSansSemiDemiItalicFontFaceName,\n  BentonSansLightFontFaceName,\n  BentonSansMediumFontFaceName,\n];\n","import * as Contract from '@tableau/api-external-contract-js';\n\nexport class ConnectedServer implements Contract.ConnectedServer {\n  public constructor(\n    protected _userId?: string,\n    protected _siteId?: string,\n    protected _siteNamespace?: string,\n    protected _workbookId?: string,\n  ) {}\n\n  public get userId(): string | undefined {\n    return this._userId;\n  }\n\n  public get siteId(): string | undefined {\n    return this._siteId;\n  }\n\n  public get siteNamespace(): string | undefined {\n    return this._siteNamespace;\n  }\n\n  public get workbookId(): string | undefined {\n    return this._workbookId;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataSchema, DataSource as DataSourceInfo } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, DataSource, DataSourceImpl, DataSourceService, ServiceNames, WorkbookImpl } from '@tableau/api-shared-js';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\n\nexport class ExtensionWorkbookImpl extends WorkbookImpl {\n  public getAllDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    const service = ApiServiceRegistry.get(ExtensionsRegistryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return service.getAllDataSourcesAsync().then<Array<Contract.DataSource>>((result) => {\n      const dataSchema: DataSchema = result;\n      const dataSources: Array<Contract.DataSource> = [];\n\n      // Loop through all data sources and add them.\n      Object.values(dataSchema.dataSources).forEach((ds) => {\n        dataSources.push(this.createDataSourceFromInfo(ds));\n      });\n\n      return dataSources;\n    });\n  }\n\n  private createDataSourceFromInfo(dataSourceInfo: DataSourceInfo): DataSource {\n    const dataSourceImpl = new DataSourceImpl(dataSourceInfo, ExtensionsRegistryId);\n    const dataSource = new DataSource(dataSourceImpl);\n    dataSourceImpl.initializeWithPublicInterfaces(dataSource);\n    return dataSource;\n  }\n}\n","import { ErrorCodes, SheetType } from '@tableau/api-external-contract-js';\nimport {\n  ContextMenuEvent,\n  DashboardExtensionLocator,\n  ExecuteParameters,\n  ExtensionDashboardInfo,\n  ExtensionLocator,\n  ExtensionSettingsInfo,\n  ExtensionWorksheetInfo,\n  FontNameAndInfo,\n  FormattingSheet,\n  INTERNAL_CONTRACT_VERSION,\n  InitializationOptions,\n  InternalApiDispatcher,\n  InternalApiDispatcherFactory,\n  Model,\n  NotificationId,\n  ParameterId,\n  SheetPath,\n  VerbId,\n  WorkbookFormatting,\n} from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  ApiVersion,\n  DashboardImpl,\n  NotificationService,\n  ServiceNames,\n  SheetInfoImpl,\n  TableauError,\n  VersionedExternalApiDispatcher,\n  VizService,\n  WorksheetImpl,\n  doCrossFrameBootstrap,\n  registerAllSharedServices,\n} from '@tableau/api-shared-js';\nimport { Dashboard } from '../Models/Dashboard';\nimport { Workbook } from '../Models/Workbook';\nimport { Worksheet } from '../Models/Worksheet';\nimport { DashboardContent } from '../Namespaces/DashboardContent';\nimport { Environment } from '../Namespaces/Environment';\nimport { Settings } from '../Namespaces/Settings';\nimport { UI } from '../Namespaces/UI';\nimport { WorksheetContent } from '../Namespaces/WorksheetContent';\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\nimport { InitializationService } from '../Services/InitializationService';\nimport { registerAllExtensionsServices, registerInitializationExtensionsServices } from '../Services/RegisterAllExtensionsServices';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { UIService } from '../Services/UIService';\nimport {\n  BentonSansBookFontFaceName,\n  BentonSansBookItalicFontFaceName,\n  BentonSansFontFamilyName,\n  BentonSansLightFontFaceName,\n  BentonSansLowDPIFontFamilyName,\n  BentonSansMediumFontFaceName,\n  BentonSansSemiDemiFontFaceName,\n  BentonSansSemiDemiItalicFontFaceName,\n  SupportedBentonSansFontFaces,\n} from './BentonSansFontNameConstants';\nimport { ExtensionWorkbookImpl } from './ExtensionWorkbookImpl';\nimport { LegacyInternalApiDispatcherHolder } from './LegacyInternalApiDispatcherHolder';\nimport { SettingsImpl } from './SettingsImpl';\nimport {\n  SupportedTableauFontFaces,\n  TableauBoldFontFaceName,\n  TableauBoldFontFamilyName,\n  TableauBookFontFaceName,\n  TableauBookFontFamilyName,\n  TableauLightFontFaceName,\n  TableauLightFontFamilyName,\n  TableauMediumFontFaceName,\n  TableauMediumFontFamilyName,\n  TableauRegularFontFaceName,\n  TableauRegularFontFamilyName,\n  TableauSemiBoldFontFaceName,\n  TableauSemiboldFontFamilyName,\n} from './TableauBookFontNameConstants';\nimport { UIImpl } from './UIImpl';\n\nexport type CallbackMap = { [key: string]: () => Record<string, unknown> };\n\nexport class ExtensionsImpl {\n  private _initializationPromise: Promise<string>;\n  private _styleElement: HTMLStyleElement;\n  public dashboardContent?: DashboardContent;\n  public worksheetContent?: WorksheetContent;\n  public environment: Environment;\n  public settings: Settings;\n  public ui: UI;\n  public workbook: Workbook;\n  public extensionZoneId: number;\n\n  public initializeAsync(isExtensionDialog: boolean, contextMenuCallbacks?: CallbackMap): Promise<string> {\n    if (!this._initializationPromise) {\n      this._initializationPromise = new Promise<string>((resolve, reject) => {\n        const initOptions: InitializationOptions = { isAlpha: ApiVersion.Instance.isAlpha };\n        // First thing we want to do is check to see if there is a desktop dispatcher already registered for us\n        if (LegacyInternalApiDispatcherHolder.hasDesktopApiDispatcherPromise(initOptions)) {\n          // Running in a pre-2019.3 desktop, use our legacy dispatcher promise\n          const desktopDispatcherPromise = LegacyInternalApiDispatcherHolder.getDesktopDispatcherPromise(initOptions);\n          desktopDispatcherPromise\n            ?.then((dispatcherFactory) => this.onDispatcherReceived(dispatcherFactory, isExtensionDialog, contextMenuCallbacks))\n            .then((openPayload) => {\n              resolve(openPayload);\n            })\n            .catch((error) => {\n              reject(error);\n            });\n        } else {\n          // We must be running in server, so we should try to kick of the server dispatcher bootstrapping\n          const onDispatcherReceivedCallback = this.onDispatcherReceived.bind(this);\n          doCrossFrameBootstrap(window, INTERNAL_CONTRACT_VERSION, initOptions)\n            .then((factory: InternalApiDispatcherFactory) => {\n              return onDispatcherReceivedCallback(factory, isExtensionDialog, contextMenuCallbacks);\n            })\n            .then((openPayload) => {\n              resolve(openPayload);\n            })\n            .catch((error) => {\n              reject(error);\n            });\n        }\n      });\n    }\n\n    return this._initializationPromise;\n  }\n\n  public createVizImageAsync(inputSpec: object): Promise<string> {\n    const vizService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<VizService>(ServiceNames.Viz);\n\n    return vizService.createVizImageAsync(inputSpec);\n  }\n\n  public setClickThroughAsync(clickThroughEnabled: boolean): Promise<void> {\n    const uiService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<UIService>(ExtensionsServiceNames.UIService);\n\n    return uiService.setClickThroughAsync(clickThroughEnabled, this.extensionZoneId);\n  }\n\n  private isDashboardExtensionLocator(locator: ExtensionLocator): locator is DashboardExtensionLocator {\n    const dashboardExtensionLocator = locator as DashboardExtensionLocator;\n    if (!dashboardExtensionLocator.dashboardPath) {\n      throw new TableauError(ErrorCodes.InternalError, 'Unexpected error during initialization.');\n    }\n    return true;\n  }\n\n  private onDispatcherReceived(\n    dispatcherFactory: InternalApiDispatcherFactory,\n    isExtensionDialog: boolean,\n    contextMenuFunctions?: CallbackMap,\n  ): Promise<string> {\n    let dispatcher: InternalApiDispatcher = dispatcherFactory(INTERNAL_CONTRACT_VERSION);\n\n    // Call to register all the services which will use the newly initialized dispatcher\n    registerInitializationExtensionsServices(dispatcher);\n\n    // Get the initialization service and initialize this extension\n    const initializationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<InitializationService>(\n      ExtensionsServiceNames.InitializationService,\n    );\n\n    const callbackMapKeys = contextMenuFunctions ? Object.keys(contextMenuFunctions) : [];\n    return initializationService.initializeDashboardExtensionsAsync(isExtensionDialog, callbackMapKeys).then<string>((result) => {\n      // If we receive an invalid plaform version, this means that platform is runnning 1.4 or 2.1 and\n      // doesn't pass the platform version to external. In this case we assume the platform version to be 1.9\n      const platformVersion = result.extensionEnvironment.platformVersion\n        ? result.extensionEnvironment.platformVersion\n        : { major: 1, minor: 9, fix: 0 };\n\n      // Wrap our existing dispatcher in a dispatcher that can downgrade/upgrade for an older platform.\n      if (VersionedExternalApiDispatcher.needsVersionConverter(platformVersion)) {\n        dispatcher = new VersionedExternalApiDispatcher(dispatcher, platformVersion);\n      }\n      // Registration of services must happen before initializing content and environment\n      // Extensions doesn't need to pass in a registryId. By default, the service registry instance is associated with registryId=0.\n      registerAllSharedServices(dispatcher, ExtensionsRegistryId, platformVersion);\n      registerAllExtensionsServices(dispatcher);\n\n      if (result.extensionDashboardInfo && this.isDashboardExtensionLocator(result.extensionInstance.locator)) {\n        this.dashboardContent = this.initializeDashboardContent(\n          result.extensionDashboardInfo,\n          result.extensionInstance.locator.dashboardPath,\n        );\n        this.extensionZoneId = result.extensionDashboardInfo.extensionZoneId;\n      }\n\n      if (result.extensionWorksheetInfo) {\n        this.worksheetContent = this.initializeWorksheetContent(result.extensionWorksheetInfo);\n      }\n\n      this.environment = new Environment(result.extensionEnvironment);\n      this.settings = this.initializeSettings(result.extensionSettingsInfo);\n      this.ui = new UI(new UIImpl());\n      this.workbook = new Workbook(new ExtensionWorkbookImpl());\n\n      if (result.extensionEnvironment.workbookFormatting) {\n        this.initializeTableauFonts(dispatcher, result.extensionEnvironment.workbookFormatting);\n        this.applyAllFormatting(result.extensionEnvironment.workbookFormatting);\n      }\n\n      // After initialization has completed, setup listeners for the callback functions that\n      // are meant to be triggered whenever a context menu item is clicked.\n      this.initializeContextMenuCallbacks(contextMenuFunctions);\n\n      // Also set up listeners for ExtensionStylesChangedEvent\n      this.initializeWorkbookFormattingChangedEventCallback(dispatcher);\n\n      // In the normal initialization case, this will be an empty string.  When returning from initializeAsync to the\n      // developer, we just ingore that string.  In the case of initializing from an extension dialog, this string\n      // is an optional payload sent from the parent extension.\n      return result.extensionDialogPayload;\n    });\n  }\n\n  public applyAllFormatting(formattingModel: WorkbookFormatting | undefined): void {\n    if (!this._styleElement) {\n      this._styleElement = document.createElement('style');\n      this._styleElement.id = 'Tableau-Extension-Formatting';\n      document.head.appendChild(this._styleElement);\n    }\n\n    if (!this._styleElement.sheet || !formattingModel) {\n      return;\n    }\n\n    const stylesheet: CSSStyleSheet = this._styleElement.sheet as CSSStyleSheet;\n    while (stylesheet.cssRules.length > 0) {\n      stylesheet.deleteRule(stylesheet.cssRules.length - 1);\n    }\n    formattingModel.formattingSheets.map((currentFormattingSheet) => {\n      this.applyFormattingSheetToStyleSheet(currentFormattingSheet, stylesheet);\n    });\n  }\n\n  private applyFormattingSheetToStyleSheet(currentFormattingSheet: FormattingSheet, stylesheet: CSSStyleSheet): void {\n    let styleInfo = '';\n\n    const cssProperties = currentFormattingSheet.cssProperties;\n    if (cssProperties.fontFamily) {\n      styleInfo += 'font-family: ' + cssProperties.fontFamily.toString() + '; ';\n    }\n\n    if (cssProperties.fontSize) {\n      styleInfo += 'font-size: ' + cssProperties.fontSize.toString() + '; ';\n    }\n\n    if (cssProperties.fontWeight) {\n      styleInfo += 'font-weight: ' + cssProperties.fontWeight.toString() + '; ';\n    }\n\n    if (cssProperties.fontStyle) {\n      styleInfo += 'font-style: ' + cssProperties.fontStyle.toString() + '; ';\n    }\n\n    if (cssProperties.textDecoration) {\n      styleInfo += 'text-decoration: ' + cssProperties.textDecoration.toString() + '; ';\n    }\n\n    if (cssProperties.color) {\n      styleInfo += 'color: ' + cssProperties.color + '; ';\n    }\n\n    const selector: string = '.' + currentFormattingSheet.classNameKey;\n    const rule: string = selector + ' { ' + styleInfo + ' }';\n    stylesheet.insertRule(rule, stylesheet.cssRules.length);\n  }\n\n  private initializeWorkbookFormattingChangedEventCallback(dispatcher: InternalApiDispatcher): void {\n    const notificationService: NotificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(\n      ServiceNames.Notification,\n    );\n    // Unregister function not used since these notifications should be\n    // observed for the full lifetime of the extension.\n    notificationService.registerHandler(\n      NotificationId.WorkbookFormattingChanged,\n      () => true,\n      (eventFormatting: WorkbookFormatting) => {\n        if (eventFormatting) {\n          this.initializeTableauFonts(dispatcher, eventFormatting);\n          this.applyAllFormatting(eventFormatting);\n        }\n      },\n    );\n  }\n\n  private initializeTableauFonts(dispatcher: InternalApiDispatcher, workbookFormatting: WorkbookFormatting): void {\n    const fontNames: Model[] = [...SupportedBentonSansFontFaces, ...SupportedTableauFontFaces];\n    workbookFormatting.formattingSheets.forEach((formattingSheet) => {\n      if (formattingSheet.cssProperties.fontFamily) {\n        fontNames.push(formattingSheet.cssProperties.fontFamily);\n      }\n    });\n\n    if (fontNames.length > 0) {\n      const parameters: ExecuteParameters = { [ParameterId.FontNameListItems]: fontNames };\n      dispatcher\n        .execute(VerbId.GetFonts, parameters)\n        .then((response) => {\n          this.loadFonts(response.result as Array<FontNameAndInfo>);\n        })\n        .catch();\n    }\n  }\n\n  private loadFonts(fonts: Array<FontNameAndInfo>): void {\n    fonts.forEach((fontNameAndInfo) => {\n      if (SupportedTableauFontFaces.includes(fontNameAndInfo.fontName)) {\n        this.loadTableauFonts(fontNameAndInfo);\n      } else if (SupportedBentonSansFontFaces.includes(fontNameAndInfo.fontName)) {\n        this.loadBentonSansFonts(fontNameAndInfo);\n      } else {\n        document.fonts.add(new FontFace(fontNameAndInfo.fontName, fontNameAndInfo.fontBinaryInfo));\n      }\n    });\n  }\n\n  private initializeDashboardContent(info: ExtensionDashboardInfo, sheetPath: SheetPath): DashboardContent {\n    // sheets are always active for Extensions\n    const sheetInfoImpl = new SheetInfoImpl(info.name, SheetType.Dashboard, { width: info.size.w, height: info.size.h }, undefined, true);\n    const dashboardImpl = new DashboardImpl(sheetInfoImpl, info.zones, sheetPath, ExtensionsRegistryId, null, info.activeDashboardObjectId);\n    const dashboard = new Dashboard(dashboardImpl);\n    return new DashboardContent(dashboard);\n  }\n\n  private initializeWorksheetContent(info: ExtensionWorksheetInfo): WorksheetContent {\n    const sheetInfoImpl = new SheetInfoImpl(\n      info.visualId.worksheet,\n      SheetType.Worksheet,\n      { width: info.size.w, height: info.size.h },\n      undefined, // index property is embedding specific\n      true, // sheets are always active for Extensions\n    );\n\n    const worksheetImpl = new WorksheetImpl(\n      sheetInfoImpl,\n      ExtensionsRegistryId,\n      info.visualId,\n      null, // parentDashboard is always null for worksheet in WorksheetContent\n      null, // parentStoryPoint is only used for embedding\n    );\n    const worksheet = new Worksheet(worksheetImpl);\n    return new WorksheetContent(worksheet);\n  }\n\n  private initializeSettings(settingsInfo: ExtensionSettingsInfo): Settings {\n    const settingsImpl = new SettingsImpl(settingsInfo);\n    return new Settings(settingsImpl);\n  }\n\n  private initializeContextMenuCallbacks(contextMenuFunctions?: CallbackMap): void {\n    const notificationService: NotificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(\n      ServiceNames.Notification,\n    );\n\n    // Unregister function not used since these notifications should be\n    // observed for the full lifetime of the extension.\n    notificationService.registerHandler(\n      NotificationId.ContextMenuClick,\n      () => {\n        // Let through any context menu event, these are already filtered on api-core\n        // based on the extension locator.\n        return true;\n      },\n      (event: ContextMenuEvent) => {\n        // Execute the function associated with this context menu ID\n        if (contextMenuFunctions) {\n          if (!contextMenuFunctions[event.id]) {\n            throw new TableauError(ErrorCodes.InternalError, `Received unexpected context menu Id from event: ${event.id}`);\n          }\n\n          contextMenuFunctions[event.id]();\n        }\n      },\n    );\n  }\n\n  private loadTableauFonts(fontNameAndInfo: FontNameAndInfo): void {\n    switch (fontNameAndInfo.fontName) {\n      case TableauBookFontFaceName:\n        document.fonts.add(new FontFace(TableauBookFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        break;\n\n      case TableauLightFontFaceName:\n        document.fonts.add(new FontFace(TableauLightFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        break;\n\n      case TableauRegularFontFaceName:\n        document.fonts.add(\n          new FontFace(TableauRegularFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        break;\n\n      case TableauSemiBoldFontFaceName:\n        document.fonts.add(\n          new FontFace(TableauSemiboldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        document.fonts.add(new FontFace(TableauRegularFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        break;\n\n      case TableauBoldFontFaceName:\n        document.fonts.add(new FontFace(TableauBoldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        document.fonts.add(new FontFace(TableauBoldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(new FontFace(TableauMediumFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(\n          new FontFace(TableauSemiboldFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }),\n        );\n        break;\n\n      case TableauMediumFontFaceName:\n        document.fonts.add(\n          new FontFace(TableauMediumFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        document.fonts.add(new FontFace(TableauLightFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(new FontFace(TableauBookFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        break;\n\n      default:\n        throw new TableauError(ErrorCodes.InternalError, `'attempted to load unsupported font: ${fontNameAndInfo.fontName}.'`);\n    }\n  }\n\n  private loadBentonSansFonts(fontNameAndInfo: FontNameAndInfo): void {\n    switch (fontNameAndInfo.fontName) {\n      case BentonSansBookFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }));\n        document.fonts.add(\n          new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: '100', style: 'normal' }),\n        );\n        break;\n\n      case BentonSansLightFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: '100', style: 'normal' }));\n        break;\n\n      case BentonSansMediumFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }));\n        document.fonts.add(\n          new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'bold', style: 'normal' }),\n        );\n        break;\n\n      case BentonSansSemiDemiFontFaceName:\n        document.fonts.add(\n          new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { weight: 'normal', style: 'normal' }),\n        );\n        break;\n\n      case BentonSansBookItalicFontFaceName:\n        document.fonts.add(new FontFace(BentonSansFontFamilyName, fontNameAndInfo.fontBinaryInfo, { style: 'italic' }));\n        break;\n\n      case BentonSansSemiDemiItalicFontFaceName:\n        document.fonts.add(new FontFace(BentonSansLowDPIFontFamilyName, fontNameAndInfo.fontBinaryInfo, { style: 'italic' }));\n        break;\n\n      default:\n        throw new TableauError(ErrorCodes.InternalError, `'attempted to load unsupported font: ${fontNameAndInfo.fontName}.'`);\n    }\n  }\n}\n","import { InitializationOptions, InternalApiDispatcherFactory, INTERNAL_CONTRACT_VERSION, VerbId } from '@tableau/api-internal-contract-js';\n\n/**\n * LegacyInternalApiDispatcherHolder has been moved (and renamed) from api-internal-contract.\n * It supports running a newer external library against a pre 2019.3 desktop.\n * Starting in 2019.3, we have a merged bootstrap style for both desktop and server.\n * In addition, the alpha checking that is happening here is not necessary in external-api-js\n *  after 2019.3 because that checking happens in api-platform-js (ApiDispatcherTest.ts)\n * TFSID: 1091561 tracks an improvement to this system to make it less complex and tie it directly to\n *  tableau beta release versions.\n * @deprecated\n */\n// eslint-disable-next-line @typescript-eslint/no-namespace\nexport namespace LegacyInternalApiDispatcherHolder {\n  /**\n   * @param options\n   */\n  export function getDesktopDispatcherPromise(options?: InitializationOptions): Promise<InternalApiDispatcherFactory> | undefined {\n    if ((!options || typeof options.isAlpha === 'undefined') && !window.__warningIssued) {\n      // tslint:disable-next-line:no-console\n      console.warn('This is a beta version of the Extensions API. Please upgrade to an official release.');\n      window.__warningIssued = true;\n    } else if (options?.isAlpha && window.__platformIsOfficialRelease) {\n      window.__tableauDesktopDispatcher\n        .then((dispatcherFactory) => {\n          const dispatcher = dispatcherFactory(INTERNAL_CONTRACT_VERSION);\n          dispatcher.execute(VerbId.BlockExtension, {}).catch();\n        })\n        .catch();\n    }\n\n    // this will be undefined if promise is rejected or throws\n    return window.__tableauDesktopDispatcher;\n  }\n\n  /**\n   * @param options\n   */\n  export function hasDesktopApiDispatcherPromise(options?: InitializationOptions): boolean {\n    return !!getDesktopDispatcherPromise(options);\n  }\n}\n\ndeclare global {\n  interface Window {\n    __tableauDesktopDispatcher: Promise<InternalApiDispatcherFactory>;\n    __platformIsOfficialRelease: boolean;\n    __warningIssued: boolean;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExtensionSettingsInfo, NotificationId, SettingsEvent } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  ErrorHelpers,\n  NotificationService,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n  TableauError,\n} from '@tableau/api-shared-js';\nimport { TableauEvent } from '../Events/TableauEvent';\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { SettingsCollection, SettingsService } from '../Services/SettingsService';\n\nclass SettingsChangedEvent extends TableauEvent implements Contract.SettingsChangedEvent {\n  public constructor(private _newSettings: { [key: string]: string }) {\n    super(Contract.TableauEventType.SettingsChanged);\n  }\n\n  public get newSettings(): SettingsCollection {\n    return this._newSettings;\n  }\n}\n\nexport class SettingsImpl {\n  private static ASYNC_SAVE_IN_PROGRESS = 'Async Save is in progress, updating settings is not allowed.';\n  private _isModified: boolean;\n  private _currentSettings: SettingsCollection;\n\n  // Since promises can't be introspected for state, keep a variable that\n  // indicates a save is in progress, so that set/erase can't be called during a save.\n  private _saveInProgress = false;\n\n  public constructor(settingsInfo: ExtensionSettingsInfo) {\n    this.initializeSettings(settingsInfo);\n  }\n\n  public erase(key: string): void {\n    ErrorHelpers.verifyParameter(key, 'key');\n\n    // Only make a modification if we have the key already\n    if (this._currentSettings[key]) {\n      this.verifySettingsAreUnlocked();\n\n      delete this._currentSettings[key];\n      this._isModified = true;\n    }\n  }\n\n  public get(key: string): string | undefined {\n    ErrorHelpers.verifyParameter(key, 'key');\n\n    return this._currentSettings[key];\n  }\n\n  public getAll(): SettingsCollection {\n    // Returns a mutable copy of the settings\n    return Object.assign({}, this._currentSettings);\n  }\n\n  public get isModified(): boolean {\n    return this._isModified;\n  }\n\n  public saveAsync(): Promise<SettingsCollection> {\n    this.verifySettingsAreUnlocked();\n\n    // Just resolve immediately if settings are unchanged\n    if (!this._isModified) {\n      return Promise.resolve<SettingsCollection>(this._currentSettings);\n    }\n\n    this._saveInProgress = true;\n\n    // Use the settings service to save settings to twb\n    const settingsService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<SettingsService>(\n      ExtensionsServiceNames.SettingsService,\n    );\n\n    return settingsService.saveSettingsAsync(this._currentSettings).then<SettingsCollection>(\n      (newSettings) => {\n        this._saveInProgress = false;\n        this._isModified = false;\n        if (this._currentSettings === undefined) {\n          this._currentSettings = newSettings;\n        } else {\n          Object.assign(this._currentSettings, newSettings);\n        }\n        return newSettings;\n      },\n      (reason) => {\n        this._saveInProgress = false;\n        return Promise.reject(reason);\n      },\n    );\n  }\n\n  public set(key: string, value: string): void {\n    ErrorHelpers.verifyStringParameter(key, 'key'); // Key shouldn't be an empty string.\n    ErrorHelpers.verifyParameter(value, 'value'); // Empty string value is allowed.\n    this.verifySettingsAreUnlocked();\n\n    this._currentSettings[key] = value;\n    this._isModified = true;\n  }\n\n  /**\n   * Initializes all events relevant to settings object.  This is only a settingsUpdate event currently.\n   *\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager.\n   */\n  public initializeEvents(): Array<SingleEventManager> {\n    const results = new Array<SingleEventManager>();\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return\n      return results;\n    }\n\n    const settingsChangedEvent = new SingleEventManagerImpl<SettingsChangedEvent>(Contract.TableauEventType.SettingsChanged);\n    notificationService.registerHandler(\n      NotificationId.SettingsChanged,\n      () => true,\n      (event: SettingsEvent) => {\n        this._currentSettings = event.newSettings;\n        settingsChangedEvent.triggerEvent(() => new SettingsChangedEvent(event.newSettings));\n      },\n    );\n\n    results.push(settingsChangedEvent);\n\n    return results;\n  }\n\n  private initializeSettings(settingsInfo: ExtensionSettingsInfo): void {\n    ErrorHelpers.verifyParameter(settingsInfo, 'settingsInfo');\n    ErrorHelpers.verifyParameter(settingsInfo.settingsValues, 'settingsInfo.SettingsValues');\n\n    this._currentSettings = settingsInfo.settingsValues;\n\n    // Reset the isModified flag\n    this._isModified = false;\n  }\n\n  /**\n   * This helper should be called before any local update to this.currentSettings.\n   * Checks if a current save call is still in progress and throws an error if so.\n   */\n  private verifySettingsAreUnlocked(): void {\n    if (this._saveInProgress) {\n      throw new TableauError(Contract.ErrorCodes.SettingSaveInProgress, SettingsImpl.ASYNC_SAVE_IN_PROGRESS);\n    }\n  }\n}\n","import { Model } from '@tableau/api-internal-contract-js';\n\nexport const TableauBookFontFamilyName = 'Tableau Book';\nexport const TableauLightFontFamilyName = 'Tableau Light';\nexport const TableauRegularFontFamilyName = 'Tableau Regular';\nexport const TableauMediumFontFamilyName = 'Tableau Medium';\nexport const TableauSemiboldFontFamilyName = 'Tableau Semibold';\nexport const TableauBoldFontFamilyName = 'Tableau Bold';\n\nexport const TableauBookFontFaceName = 'Tableau Book';\nexport const TableauBoldFontFaceName = 'Tableau Bold';\nexport const TableauLightFontFaceName = 'Tableau Light';\nexport const TableauMediumFontFaceName = 'Tableau Medium';\nexport const TableauRegularFontFaceName = 'Tableau Regular';\nexport const TableauSemiBoldFontFaceName = 'Tableau Semi Bold';\n\nexport const SupportedTableauFontFaces: Model[] = [\n  TableauBookFontFaceName,\n  TableauBoldFontFaceName,\n  TableauLightFontFaceName,\n  TableauMediumFontFaceName,\n  TableauRegularFontFaceName,\n  TableauSemiBoldFontFaceName,\n];\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { DialogUpdateEvent, NotificationId } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, NotificationService, ServiceNames, TableauError } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../Services/ExtensionsServiceNames';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { UIService } from '../Services/UIService';\n\nexport class UIImpl {\n  public displayDialogAsync(url: string, payload?: string, options?: Contract.DialogOptions): Promise<string> {\n    const uiService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<UIService>(ExtensionsServiceNames.UIService);\n    const notificationService: NotificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(\n      ServiceNames.Notification,\n    );\n\n    return new Promise((resolve, reject) => {\n      uiService\n        .displayDialogAsync(url, payload || '', options)\n        .then(() => {\n          const unregisterFn = notificationService.registerHandler(\n            NotificationId.ExtensionDialogUpdate,\n            () => {\n              // Let through any dialog update event\n              return true;\n            },\n            (event: DialogUpdateEvent) => {\n              if (event.isCloseEvent) {\n                if (event.closePayload === undefined) {\n                  throw new TableauError(Contract.ErrorCodes.InternalError, 'closePayload is undefined');\n                }\n                resolve(event.closePayload);\n              } else {\n                reject(new TableauError(ErrorCodes.DialogClosedByUser, 'Extension dialog closed by user.'));\n              }\n\n              unregisterFn();\n            },\n          );\n        })\n        .catch((error) => {\n          reject(error);\n        });\n    });\n  }\n\n  public closeDialog(payload?: string): void {\n    const uiService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<UIService>(ExtensionsServiceNames.UIService);\n\n    uiService.closeDialog(payload);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardLayoutChangeDetails, TableauEventType, WorkbookFormatting } from '@tableau/api-external-contract-js';\nimport { DashboardLayoutEvent, NotificationId } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  DashboardImpl,\n  DashboardObjectImpl,\n  NotificationService,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n  WorksheetImpl,\n} from '@tableau/api-shared-js';\nimport { DashboardLayoutChangedEvent } from '../Events/DashboardLayoutChangedEvent';\nimport { WorkbookFormattingChangedEvent } from '../Events/WorkbookFormattingChangedEvent';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { DashboardObject } from './DashboardObject';\nimport { Sheet } from './Sheet';\nimport { Worksheet } from './Worksheet';\n\nexport class Dashboard extends Sheet implements Contract.ExtensionDashboard {\n  public constructor(private _dashboardImpl: DashboardImpl) {\n    super(_dashboardImpl);\n    _dashboardImpl.initializeWithPublicInterfaces();\n    this.initializeEvents().forEach((e) => this.addNewEventType(e));\n  }\n\n  public get worksheets(): Array<Contract.ExtensionWorksheet> {\n    return this._dashboardImpl.worksheetsImpl.map((worksheetImpl: WorksheetImpl) => {\n      return new Worksheet(worksheetImpl);\n    });\n  }\n\n  public get objects(): Array<Contract.ExtensionDashboardObject> {\n    return this._dashboardImpl.objects.map((dashboardObjectImpl: DashboardObjectImpl) => {\n      return new DashboardObject(dashboardObjectImpl);\n    });\n  }\n\n  public get activeDashboardObjectId(): number {\n    return this._dashboardImpl.activeDashboardObjectId;\n  }\n\n  public get activeDashboardName(): string {\n    return this._dashboardImpl.activeDashboardName;\n  }\n\n  public setZoneVisibilityAsync(zoneVisibilityMap: Contract.ZoneVisibilityMap): Promise<void> {\n    return this._dashboardImpl.setDashboardObjectVisibilityAsync(zoneVisibilityMap);\n  }\n\n  public setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap: Contract.DashboardObjectVisibilityMap): Promise<void> {\n    return this._dashboardImpl.setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap);\n  }\n\n  public getDashboardObjectById(dashboardObjectId: number): DashboardObject | undefined {\n    const zone = this._dashboardImpl.getDashboardObjectById(dashboardObjectId);\n    return zone && new DashboardObject(zone);\n  }\n\n  public initializeEvents(): Array<SingleEventManager> {\n    const results = new Array<SingleEventManager>();\n\n    // Initializing events and registering notification service\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return (allows unit testing without NotificationService mock)\n      return results;\n    }\n\n    const dashboardLayoutChangedEvent = new SingleEventManagerImpl<DashboardLayoutChangedEvent>(TableauEventType.DashboardLayoutChanged);\n    notificationService.registerHandler(\n      NotificationId.DashboardLayoutChanged,\n      () => true,\n      (event: DashboardLayoutEvent) => {\n        const dashboardObjectChanges: DashboardLayoutChangeDetails = this._dashboardImpl.updateZones(\n          event.zones,\n          event.activeZoneId,\n          event.activeDashboardName,\n        );\n        dashboardLayoutChangedEvent.triggerEvent(() => new DashboardLayoutChangedEvent(dashboardObjectChanges));\n      },\n    );\n\n    results.push(dashboardLayoutChangedEvent);\n\n    const workbookFormattingChangedEvent = new SingleEventManagerImpl<WorkbookFormattingChangedEvent>(\n      TableauEventType.WorkbookFormattingChanged,\n    );\n\n    notificationService.registerHandler(\n      NotificationId.WorkbookFormattingChanged,\n      () => true,\n      (eventFormatting: WorkbookFormatting) => {\n        workbookFormattingChangedEvent.triggerEvent(() => new WorkbookFormattingChangedEvent(eventFormatting));\n      },\n    );\n\n    results.push(workbookFormattingChangedEvent);\n\n    return results;\n  }\n\n  public moveAndResizeDashboardObjectsAsync(\n    dashboardObjectPositionAndSizeUpdateArray: Contract.DashboardObjectPositionAndSizeUpdateArray,\n  ): Promise<void> {\n    return this._dashboardImpl.moveAndResizeDashboardObjectsAsync(dashboardObjectPositionAndSizeUpdateArray);\n  }\n\n  public replayAnimationAsync(replaySpeed: Contract.ReplaySpeedType): Promise<void> {\n    return this._dashboardImpl.replayAnimationAsync(replaySpeed);\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    return this._dashboardImpl.getFiltersAsync();\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    return this._dashboardImpl.applyFilterAsync(fieldName, values, updateType, options);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardObjectImpl } from '@tableau/api-shared-js';\nimport { Dashboard } from './Dashboard';\nimport { Worksheet } from './Worksheet';\n\n/**\n * Implementation of the dashboard objects - the zones in a dashboard.\n */\nexport class DashboardObject implements Contract.ExtensionDashboardObject {\n  public constructor(private _dashboardObjectImpl: DashboardObjectImpl) {}\n\n  public get dashboard(): Contract.ExtensionDashboard {\n    return new Dashboard(this._dashboardObjectImpl.dashboardImpl);\n  }\n\n  public get type(): Contract.DashboardObjectType {\n    return this._dashboardObjectImpl.type;\n  }\n\n  public get position(): Contract.Point {\n    return this._dashboardObjectImpl.position;\n  }\n\n  public get size(): Contract.Size {\n    return this._dashboardObjectImpl.size;\n  }\n\n  public get worksheet(): Contract.ExtensionWorksheet | undefined {\n    if (this._dashboardObjectImpl.worksheetImpl) {\n      return new Worksheet(this._dashboardObjectImpl.worksheetImpl);\n    }\n    return undefined;\n  }\n\n  public get name(): string {\n    return this._dashboardObjectImpl.name;\n  }\n\n  public get isFloating(): boolean {\n    return this._dashboardObjectImpl.isFloating;\n  }\n\n  public get isVisible(): boolean {\n    return this._dashboardObjectImpl.isVisible;\n  }\n\n  public get id(): number {\n    return this._dashboardObjectImpl.id;\n  }\n\n  public get fieldId(): string | undefined {\n    return this._dashboardObjectImpl.fieldId;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { NotificationId } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  ErrorHelpers,\n  EventListenerManager,\n  NotificationService,\n  ParameterImpl,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n} from '@tableau/api-shared-js';\nimport { ParameterChangedEvent } from '../Events/ParameterChangedEvent';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\n\n/**\n * Implementation of the Parameter contract. Calls down to the impl\n * class for almost all of the work it does.\n */\nexport class Parameter extends EventListenerManager implements Contract.Parameter {\n  public constructor(private parameterImpl: ParameterImpl, sheet: Contract.ExtensionSheet) {\n    super();\n\n    // Initialize our event handling for this class\n    this.initializeEvents(sheet).forEach((e) => this.addNewEventType(e));\n  }\n\n  public get name(): string {\n    return this.parameterImpl.name;\n  }\n\n  public get currentValue(): Contract.DataValue {\n    return this.parameterImpl.currentValue;\n  }\n\n  public get dataType(): Contract.DataType {\n    return this.parameterImpl.dataType;\n  }\n\n  public get allowableValues(): Contract.ParameterDomainRestriction {\n    return this.parameterImpl.allowableValues;\n  }\n\n  public get id(): string {\n    return this.parameterImpl.id;\n  }\n\n  public changeValueAsync(newValue: string | number | boolean | Date): Promise<Contract.DataValue> {\n    return this.parameterImpl.changeValueAsync(newValue);\n  }\n\n  /**\n   * Helper method which goes through and registers each event type this impl knows about\n   * with the NotificationService. It returns an array of SingleEventManager objects which\n   * can then be passed to an EventListenerManager to handle user registration / unregistration.\n   *\n   * @param sheet The sheet object which will be included with the event notifications\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager\n   */\n  public initializeEvents(sheet: Contract.ExtensionSheet): Array<SingleEventManager> {\n    ErrorHelpers.verifyInternalValue(sheet, 'sheet');\n\n    const results = new Array<SingleEventManager>();\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return\n      return results;\n    }\n\n    // Initialize all of the event managers we'll need (one for each event type)\n    const parameterEvent = new SingleEventManagerImpl<ParameterChangedEvent>(Contract.TableauEventType.ParameterChanged);\n    notificationService.registerHandler(\n      NotificationId.ParameterChanged,\n      (model) => {\n        const fieldName = model as string;\n        return fieldName === this.parameterImpl.id;\n      },\n      (fieldName: string) => {\n        parameterEvent.triggerEvent(() => new ParameterChangedEvent(fieldName, sheet));\n      },\n    );\n\n    results.push(parameterEvent);\n\n    return results;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { EventListenerManager, SheetImpl, TableauError } from '@tableau/api-shared-js';\nimport { Parameter } from './Parameter';\n\nexport class Sheet extends EventListenerManager implements Contract.ExtensionSheet {\n  public constructor(private _sheetImpl: SheetImpl) {\n    super();\n  }\n\n  public get name(): string {\n    return this._sheetImpl.name;\n  }\n\n  public get sheetType(): Contract.SheetType {\n    return this._sheetImpl.sheetType;\n  }\n\n  public get size(): Contract.Size {\n    if (this.isValidSize(this._sheetImpl.size)) {\n      return this._sheetImpl.size;\n    }\n\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, 'Size not implemented');\n  }\n\n  private isValidSize(size: any): size is Contract.Size {\n    const testSize = size as Contract.Size;\n    if (testSize.width !== undefined && testSize.height !== undefined) {\n      return true;\n    }\n\n    return false;\n  }\n\n  public findParameterAsync(parameterName: string): Promise<Contract.Parameter | undefined> {\n    return this._sheetImpl.findParameterAsync(parameterName).then((parameterImpl) => {\n      if (parameterImpl) {\n        return new Promise<Contract.Parameter>((resolve) => resolve(new Parameter(parameterImpl, this)));\n      } else {\n        return new Promise<undefined>((resolve) => resolve(undefined));\n      }\n    });\n  }\n\n  public getParametersAsync(): Promise<Array<Contract.Parameter>> {\n    return this._sheetImpl.getParametersAsync().then((parametersImpl) => {\n      return parametersImpl.map((parameterImpl) => {\n        return new Parameter(parameterImpl, this);\n      });\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExtensionWorkbookImpl } from '../Impl/ExtensionWorkbookImpl';\n\nexport class Workbook implements Contract.ExtensionWorkbook {\n  public constructor(private _workbookImpl: ExtensionWorkbookImpl) {}\n\n  public getAllDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    return this._workbookImpl.getAllDataSourcesAsync();\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { Column, FilterUpdateType, SelectionUpdateType, TableauEventType, TooltipContext } from '@tableau/api-external-contract-js';\nimport { FilterEvent, NotificationId, SummaryDataEvent, VisualId } from '@tableau/api-internal-contract-js';\nimport {\n  ApiServiceRegistry,\n  NotificationService,\n  ServiceNames,\n  SingleEventManager,\n  SingleEventManagerImpl,\n  TableauError,\n  WorksheetImpl,\n} from '@tableau/api-shared-js';\nimport { FilterChangedEvent } from '../Events/FilterChangedEvent';\nimport { MarksSelectedEvent } from '../Events/MarksSelectedEvent';\nimport { SummaryDataChangedEvent } from '../Events/SummaryDataChangedEvent';\nimport { ExtensionsRegistryId } from '../Services/ServiceRegistryUtil';\nimport { Dashboard } from './Dashboard';\nimport { Sheet } from './Sheet';\n\nexport class Worksheet extends Sheet implements Contract.ExtensionWorksheet {\n  public constructor(protected _worksheetImpl: WorksheetImpl) {\n    super(_worksheetImpl);\n\n    // Call to initialize events and then call down to the event listener manager to handle things\n    this.initializeEvents().forEach((e) => this.addNewEventType(e));\n  }\n\n  public get parentDashboard(): Contract.ExtensionDashboard {\n    // This should never happen for Extensions if the DashboardImpls are created correctly\n    if (this._worksheetImpl.parentDashboard == null) {\n      throw new TableauError(Contract.SharedErrorCodes.ImplementationError, `Parent dashboard not implemented`);\n    }\n\n    return new Dashboard(this._worksheetImpl.parentDashboard);\n  }\n\n  /**\n   * Helper method which goes through and registers each event type this impl knows about\n   * with the NotificationService. It returns an array of SingleEventManager objects which\n   * can then be passed to an EventListenerManager to handle user registration / unregistration.\n   *\n   * @param {Worksheet} worksheet The worksheet object which will be included with the event notifications\n   * @returns {Array<SingleEventManager>} Collection of event managers to pass to an EventListenerManager\n   */\n  public initializeEvents(): Array<SingleEventManager> {\n    const results = new Array<SingleEventManager>();\n    let notificationService: NotificationService;\n\n    try {\n      notificationService = ApiServiceRegistry.get(ExtensionsRegistryId).getService<NotificationService>(ServiceNames.Notification);\n    } catch (e) {\n      // If we don't have this service registered, just return\n      return results;\n    }\n\n    // Initialize all of the event managers we'll need (one for each event type)\n    const marksEvent = new SingleEventManagerImpl<MarksSelectedEvent>(TableauEventType.MarkSelectionChanged);\n    notificationService.registerHandler(\n      NotificationId.SelectedMarksChanged,\n      (model) => {\n        const visualId = model as VisualId;\n        return this.visualIdsAreEqual(visualId, this._worksheetImpl.visualId);\n      },\n      () => marksEvent.triggerEvent(() => new MarksSelectedEvent(this)),\n    );\n\n    const filterEvent = new SingleEventManagerImpl<FilterChangedEvent>(TableauEventType.FilterChanged);\n    notificationService.registerHandler(\n      NotificationId.FilterChanged,\n      (model) => {\n        const filterEventResponse = model as FilterEvent;\n        return this._worksheetImpl.visualId.worksheet === filterEventResponse.visualId.worksheet;\n      },\n      (event: FilterEvent) => {\n        filterEvent.triggerEvent(() => new FilterChangedEvent(this, event.fieldName, event.fieldId));\n      },\n    );\n\n    const summaryDataEvent = new SingleEventManagerImpl<SummaryDataChangedEvent>(TableauEventType.SummaryDataChanged);\n    notificationService.registerHandler(\n      NotificationId.SummaryDataChanged,\n      (model) => {\n        const summaryDataEventResponse = model as SummaryDataEvent;\n        return this._worksheetImpl.visualId.worksheet === summaryDataEventResponse.visualId.worksheet;\n      },\n      (event: SummaryDataEvent) => {\n        summaryDataEvent.triggerEvent(() => new SummaryDataChangedEvent(this));\n      },\n    );\n\n    results.push(marksEvent);\n    results.push(filterEvent);\n    results.push(summaryDataEvent);\n\n    return results;\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    return this._worksheetImpl.applyFilterAsync(fieldName, values, updateType, options);\n  }\n\n  public applyRangeFilterAsync(fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\n    return this._worksheetImpl.applyRangeFilterAsync(fieldName, filterOptions);\n  }\n\n  public applyHierarchicalFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    return this._worksheetImpl.applyHierarchicalFilterAsync(fieldName, values, updateType, options);\n  }\n\n  public applyRelativeDateFilterAsync(fieldName: string, options: Contract.RelativeDateFilterOptions): Promise<string> {\n    return this._worksheetImpl.applyRelativeDateFilterAsync(fieldName, options);\n  }\n\n  public clearFilterAsync(fieldName: string): Promise<string> {\n    return this._worksheetImpl.clearFilterAsync(fieldName);\n  }\n\n  public getDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    return this._worksheetImpl.getDataSourcesAsync();\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    return this._worksheetImpl.getFiltersAsync();\n  }\n\n  public getSelectedMarksAsync(): Promise<Contract.MarksCollection> {\n    return this._worksheetImpl.getSelectedMarksAsync();\n  }\n\n  public getHighlightedMarksAsync(): Promise<Contract.MarksCollection> {\n    return this._worksheetImpl.getHighlightedMarksAsync();\n  }\n\n  public getSummaryDataAsync(options: Contract.GetSummaryDataOptions): Promise<Contract.DataTable> {\n    return this._worksheetImpl.getSummaryDataAsync(options);\n  }\n\n  public getSummaryDataReaderAsync(pageRowCount: number, options: Contract.GetSummaryDataOptions): Promise<Contract.DataTableReader> {\n    return this._worksheetImpl.getSummaryDataReaderAsync(pageRowCount, options);\n  }\n\n  public getSummaryColumnsInfoAsync(): Promise<Array<Column>> {\n    return this._worksheetImpl.getSummaryColumnsInfoAsync();\n  }\n\n  public getUnderlyingDataAsync(options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    console.warn(\n      'Worksheet.getUnderlyingDataAsync is deprecated. Please use ' +\n        'Worksheet.getUnderlyingTablesAsync and Worksheet.getUnderlyingTableDataAsync',\n    );\n    return this._worksheetImpl.getUnderlyingDataAsync(options);\n  }\n\n  public getUnderlyingTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    return this._worksheetImpl.getUnderlyingTablesAsync();\n  }\n\n  public getUnderlyingTableDataAsync(logicalTableId: string, options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    return this._worksheetImpl.getUnderlyingTableDataAsync(logicalTableId, options);\n  }\n\n  public getUnderlyingTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount: number,\n    options: Contract.GetUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    return this._worksheetImpl.getUnderlyingTableDataReaderAsync(logicalTableId, pageRowCount, options);\n  }\n\n  public getVisualSpecificationAsync(): Promise<Contract.VisualSpecification> {\n    return this._worksheetImpl.getVisualSpecificationAsync();\n  }\n\n  public clearSelectedMarksAsync(): Promise<void> {\n    return this._worksheetImpl.clearSelectedMarksAsync();\n  }\n\n  public selectMarksByIDAsync(marksInfo: Array<Contract.MarkInfo>, updateType: SelectionUpdateType): Promise<void> {\n    return this._worksheetImpl.selectMarksByIdAsync(marksInfo, updateType);\n  }\n\n  public selectMarksByValueAsync(selections: Array<Contract.SelectionCriteria>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    return this._worksheetImpl.selectMarksByValueAsync(selections, selectionUpdateType);\n  }\n\n  public selectMarksByIdAsync(selections: Array<Contract.MarkInfo>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    return this._worksheetImpl.selectMarksByIdAsync(selections, selectionUpdateType);\n  }\n\n  public annotateMarkAsync(mark: Contract.MarkInfo, annotationText: string): Promise<void> {\n    return this._worksheetImpl.annotateMarkAsync(mark, annotationText);\n  }\n\n  public getAnnotationsAsync(): Promise<Array<Contract.Annotation>> {\n    return this._worksheetImpl.getAnnotationsAsync();\n  }\n\n  public removeAnnotationAsync(annotation: Contract.Annotation): Promise<void> {\n    return this._worksheetImpl.removeAnnotationAsync(annotation);\n  }\n\n  public hoverTupleAsync(hoveredTuple?: number, tooltip?: TooltipContext | null, allowHoverActions = true): Promise<void> {\n    return this._worksheetImpl.hoverTupleAsync(hoveredTuple, tooltip, allowHoverActions);\n  }\n\n  public selectTuplesAsync(selectedTuples: Array<number>, selectOption: Contract.SelectOptions, tooltip?: TooltipContext): Promise<void> {\n    return this._worksheetImpl.selectTuplesAsync(selectedTuples, selectOption, tooltip);\n  }\n\n  public getTooltipTextAsync(tupleId: number): Promise<String> {\n    return this._worksheetImpl.getTooltipTextAsync(tupleId);\n  }\n\n  public leaveMarkNavigationAsync(): Promise<void> {\n    return this._worksheetImpl.leaveMarkNavigationAsync();\n  }\n\n  private visualIdsAreEqual(a: VisualId, b: VisualId): boolean {\n    return (\n      a &&\n      b &&\n      a.worksheet === b.worksheet &&\n      a.dashboard === b.dashboard &&\n      a.storyboard === b.storyboard &&\n      a.storyPointID === b.storyPointID\n    );\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\n\n/**\n * Implementation of the external DashboardContent namespace.\n * This does not follow the Impl pattern as DashboardContent is\n * currently just a (single) property bag.\n */\nexport class DashboardContent implements Contract.DashboardContent {\n  public constructor(private _dashboard: Contract.ExtensionDashboard) {}\n\n  public get dashboard(): Contract.ExtensionDashboard {\n    return this._dashboard;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExtensionEnvironment } from '@tableau/api-internal-contract-js';\nimport { ApiVersion, InternalToExternalEnumMappings as EnumMappings } from '@tableau/api-shared-js';\nimport { ConnectedServer } from '../Impl/ConnectedServer';\nimport { WorkbookFormattingEnvUtil } from './WorkbookFormattingEnvUtil';\n\n/**\n * Implementation of the external environment namespace.\n * Environment does not follow the Impl pattern as it is\n * just a property bag.\n * First class extensions can get to ConnectedServer with: environment['connectedServer']\n */\nexport class Environment implements Contract.Environment {\n  /**The following is an index signature. It allows properties to be accessed by name.\n   * This allows us to add properties dynamically (see usage of this.connectedServer below) without Typescript errors.\n   * The reason we do this is so that 3rd-party extension developers do not see the connectedServer property\n   * that is only available to first class extension developers.\n   * The type of the index sigature needs to be a union of all properties in the object, since we could\n   * access any property using the property index method.\n   */\n  [x: string]: ConnectedServer | string | Contract.WorkbookFormatting | string[] | undefined;\n  private _apiVersion: string;\n  private _context: Contract.ExtensionContext;\n  private _formatting?: Contract.WorkbookFormatting;\n  private _language: string;\n  private _country?: string;\n  private _locale: string;\n  private _mode: Contract.ExtensionMode;\n  private _operatingSystem: string;\n  private _tableauVersion: string;\n  private _uniqueUserId?: string;\n\n  public constructor(extensionEnvironment: ExtensionEnvironment) {\n    this._apiVersion = ApiVersion.Instance && ApiVersion.Instance.formattedValue; // maj.min.fix (no build)\n    this._context = EnumMappings.extensionContext.convert(extensionEnvironment.extensionContext);\n    this._formatting = WorkbookFormattingEnvUtil.convertToWorkbookFormatting(extensionEnvironment.workbookFormatting);\n    this._language = extensionEnvironment.extensionLanguage;\n    this._country = extensionEnvironment.extensionCountry;\n    this._locale = extensionEnvironment.extensionLocale;\n    this._mode = EnumMappings.extensionMode.convert(extensionEnvironment.extensionMode);\n    this._operatingSystem = extensionEnvironment.operatingSystem;\n    this._tableauVersion = extensionEnvironment.tableauVersion;\n    this._uniqueUserId = extensionEnvironment.uniqueUserId;\n\n    // If we have a userId, then we are a first class extension\n    if (extensionEnvironment.userId) {\n      this.connectedServer = new ConnectedServer(\n        extensionEnvironment.userId,\n        extensionEnvironment.siteId,\n        extensionEnvironment.siteNamespace,\n        extensionEnvironment.workbookId,\n      );\n\n      this.featureFlags = extensionEnvironment.featureFlags;\n    }\n  }\n\n  public get apiVersion(): string {\n    return this._apiVersion;\n  }\n\n  public get context(): Contract.ExtensionContext {\n    return this._context;\n  }\n\n  public get workbookFormatting(): Contract.WorkbookFormatting | undefined {\n    return this._formatting;\n  }\n\n  public get language(): string {\n    return this._language;\n  }\n\n  public get country(): string | undefined {\n    return this._country;\n  }\n\n  public get locale(): string {\n    return this._locale;\n  }\n\n  public get mode(): Contract.ExtensionMode {\n    return this._mode;\n  }\n\n  public get operatingSystem(): string {\n    return this._operatingSystem;\n  }\n\n  public get tableauVersion(): string {\n    return this._tableauVersion;\n  }\n\n  public get uniqueUserId(): string | undefined {\n    return this._uniqueUserId;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { CallbackMap, ExtensionsImpl } from '../Impl/ExtensionsImpl';\n\n/**\n * Implementation of the external Extensions namespace.\n */\nexport class Extensions implements Contract.Extensions {\n  public constructor(private extensionImpl: ExtensionsImpl) {\n    this.extensionImpl = extensionImpl;\n  }\n\n  public get dashboardContent(): Contract.DashboardContent | undefined {\n    return this.extensionImpl.dashboardContent;\n  }\n\n  public get worksheetContent(): Contract.WorksheetContent | undefined {\n    return this.extensionImpl.worksheetContent;\n  }\n\n  public get environment(): Contract.Environment {\n    return this.extensionImpl.environment;\n  }\n\n  public get settings(): Contract.Settings {\n    return this.extensionImpl.settings;\n  }\n\n  public get ui(): Contract.UI {\n    return this.extensionImpl.ui;\n  }\n\n  public get workbook(): Contract.ExtensionWorkbook {\n    return this.extensionImpl.workbook;\n  }\n\n  public get dashboardObjectId(): number {\n    return this.extensionImpl.extensionZoneId;\n  }\n\n  public initializeAsync(contextMenuCallbacks?: CallbackMap): Promise<void> {\n    return this.extensionImpl.initializeAsync(false, contextMenuCallbacks).then<void>();\n  }\n\n  public initializeDialogAsync(): Promise<string> {\n    return this.extensionImpl.initializeAsync(true);\n  }\n\n  public createVizImageAsync(inputSpec: object): Promise<string> {\n    return this.extensionImpl.createVizImageAsync(inputSpec);\n  }\n\n  public setClickThroughAsync(clickThroughEnabled: boolean): Promise<void> {\n    return this.extensionImpl.setClickThroughAsync(clickThroughEnabled);\n  }\n}\n","import { Settings as SettingsContract } from '@tableau/api-external-contract-js';\nimport { EventListenerManager } from '@tableau/api-shared-js';\nimport { SettingsImpl } from '../Impl/SettingsImpl';\nimport { SettingsCollection } from '../Services/SettingsService';\n\n/**\n * Implementation of the external settings namespace.\n */\nexport class Settings extends EventListenerManager implements SettingsContract {\n  public constructor(private _settingsImpl: SettingsImpl) {\n    super();\n\n    // Initialize our event handling for this class\n    this._settingsImpl.initializeEvents().forEach((e) => this.addNewEventType(e));\n  }\n\n  public erase(key: string): void {\n    this._settingsImpl.erase(key);\n  }\n\n  public get(key: string): string | undefined {\n    return this._settingsImpl.get(key);\n  }\n\n  public getAll(): SettingsCollection {\n    return this._settingsImpl.getAll();\n  }\n\n  public get isModified(): boolean {\n    return this._settingsImpl.isModified;\n  }\n\n  public saveAsync(): Promise<SettingsCollection> {\n    return this._settingsImpl.saveAsync();\n  }\n\n  public set(key: string, value: string): void {\n    this._settingsImpl.set(key, value);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { UIImpl } from '../Impl/UIImpl';\n\n/**\n * Implementation of the external UI namespace.\n */\nexport class UI implements Contract.UI {\n  public constructor(private _impl: UIImpl) {}\n\n  public displayDialogAsync(url: string, payload?: string, options?: Contract.DialogOptions): Promise<string> {\n    return this._impl.displayDialogAsync(url, payload, options);\n  }\n\n  public closeDialog(payload?: string): void {\n    this._impl.closeDialog(payload);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { InternalToExternalEnumMappings as EnumMappings } from '@tableau/api-shared-js';\nimport { WorkbookFormatting } from '../../../../api-internal-contract-js/lib/src/JsApiInternalContract';\n\nexport class WorkbookFormattingEnvUtil {\n  public static convertToWorkbookFormatting(workbookFormattingModel?: WorkbookFormatting): Contract.WorkbookFormatting | undefined {\n    if (!workbookFormattingModel) {\n      return undefined;\n    } else {\n      const formattingMap: Array<Contract.FormattingSheet> = workbookFormattingModel.formattingSheets.map((currentFormattingSheet) => {\n        const formattingSheet: Contract.FormattingSheet = {\n          classNameKey: EnumMappings.classNameKey.convert(currentFormattingSheet.classNameKey),\n          cssProperties: {\n            fontFamily: currentFormattingSheet.cssProperties.fontFamily,\n            fontSize: currentFormattingSheet.cssProperties.fontSize,\n            fontWeight: currentFormattingSheet.cssProperties.fontWeight,\n            fontStyle: currentFormattingSheet.cssProperties.fontStyle,\n            textDecoration: currentFormattingSheet.cssProperties.textDecoration,\n            color: currentFormattingSheet.cssProperties.color,\n          },\n        };\n        return formattingSheet;\n      });\n      const result: Contract.WorkbookFormatting = {\n        formattingSheets: formattingMap,\n      };\n      return result;\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\n\n/**\n * Implementation of the external WorksheetContent namespace.\n * This does not follow the Impl pattern as WorksheetContent is\n * currently just a (single) property bag.\n */\nexport class WorksheetContent implements Contract.WorksheetContent {\n  public constructor(private _worksheet: Contract.ExtensionWorksheet) {}\n\n  public get worksheet(): Contract.ExtensionWorksheet {\n    return this._worksheet;\n  }\n}\n","import { ExecuteParameters, ExtensionBootstrapInfo, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceImplBase } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\nimport { InitializationService } from '../InitializationService';\n\nexport class InitializationServiceImpl extends ServiceImplBase implements InitializationService {\n  public get serviceName(): string {\n    return ExtensionsServiceNames.InitializationService;\n  }\n\n  public initializeDashboardExtensionsAsync(isExtensionDialog: boolean, contextMenuIds: string[]): Promise<ExtensionBootstrapInfo> {\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'initializeDashboardExtensionsAsync',\n      [ParameterId.ExtensionContextMenuIds]: contextMenuIds,\n      [ParameterId.IsExtensionDialog]: isExtensionDialog,\n    };\n\n    return this.execute(VerbId.InitializeExtension, params).then<ExtensionBootstrapInfo>((response) => {\n      // TODO - Validate return value\n\n      const result = response.result as ExtensionBootstrapInfo;\n      return result;\n    });\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ExtensionSettingsInfo, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceImplBase, TableauError } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\nimport { SettingsCollection, SettingsService } from '../SettingsService';\n\nexport class SettingsServiceImpl extends ServiceImplBase implements SettingsService {\n  public get serviceName(): string {\n    return ExtensionsServiceNames.SettingsService;\n  }\n\n  public saveSettingsAsync(settings: SettingsCollection): Promise<SettingsCollection> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'saveSettingsAsync',\n      [ParameterId.SettingsValues]: settings,\n    };\n\n    return this.execute(VerbId.SaveExtensionSettings, parameters).then<SettingsCollection>((value) => {\n      const result = value.result as ExtensionSettingsInfo;\n\n      if (!result || !result.settingsValues) {\n        throw new TableauError(ErrorCodes.InternalError, 'Unexpected error savings settings.');\n      }\n\n      return result.settingsValues;\n    });\n  }\n}\n","import { DialogOptions, DialogStyle, ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ExtensionDialogResult, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ErrorHelpers, ExternalToInternalEnumMappings, ServiceImplBase, TableauError } from '@tableau/api-shared-js';\nimport { ExtensionsServiceNames } from '../ExtensionsServiceNames';\nimport { UIService } from '../UIService';\n\nconst DEFAULT_DIALOG_HEIGHT = 400; // in pixels\nconst DEFAULT_DIALOG_WIDTH = 600; // in pixels\nconst DEFAULT_DIALOG_STYLE: DialogStyle = DialogStyle.Window;\n\nexport class UIServiceImpl extends ServiceImplBase implements UIService {\n  public get serviceName(): string {\n    return ExtensionsServiceNames.UIService;\n  }\n\n  public displayDialogAsync(url: string, payload: string, options?: DialogOptions): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'displayDialogAsync',\n      [ParameterId.ExtensionDialogUrl]: url,\n      [ParameterId.ExtensionDialogPayload]: payload,\n    };\n\n    const h: number = options && options.height ? options.height : DEFAULT_DIALOG_HEIGHT;\n    const w: number = options && options.width ? options.width : DEFAULT_DIALOG_WIDTH;\n    const dialogStyle: DialogStyle = options && options.dialogStyle ? options.dialogStyle : DEFAULT_DIALOG_STYLE;\n\n    // On the platform side, we do something reasonable regardess of whether the passed\n    // height and width are too large or too small.  But this likely indicates a developer error,\n    // so we throw an error here to help with debugging.\n    if (h <= 0 || w <= 0) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'Size parameters for displayDialogAsync must be positive');\n    }\n\n    parameters[ParameterId.ExtensionDialogH] = h;\n    parameters[ParameterId.ExtensionDialogW] = w;\n    ErrorHelpers.verifyEnumValue<DialogStyle>(dialogStyle, DialogStyle, 'DialogStyle');\n    parameters[ParameterId.ExtensionDialogStyle] = ExternalToInternalEnumMappings.dialogStyles.convert(dialogStyle);\n\n    return this.execute(VerbId.DisplayDialog, parameters).then((response) => {\n      const dialogResult = response.result as ExtensionDialogResult;\n      switch (dialogResult) {\n        case ExtensionDialogResult.DialogAlreadyOpen:\n          throw new TableauError(ErrorCodes.DialogAlreadyOpen, 'There already exists an open dialog for this extension.');\n        case ExtensionDialogResult.InvalidDomain:\n          throw new TableauError(\n            ErrorCodes.InvalidDomainDialog,\n            'The url of an extension dialog must match the domain of the parent extension.',\n          );\n        default:\n          // Success case\n          return;\n      }\n    });\n  }\n\n  public closeDialog(payload?: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'closeDialog',\n    };\n\n    if (payload) {\n      parameters[ParameterId.ExtensionDialogPayload] = payload;\n    }\n\n    return this.execute(VerbId.CloseDialog, parameters).then(() => {\n      return;\n    });\n  }\n\n  public setClickThroughAsync(clickThroughEnabled: boolean, extensionZoneId: number): Promise<void> {\n    ErrorHelpers.verifyParameterType(clickThroughEnabled, 'boolean', 'clickThroughEnabled');\n\n    if (extensionZoneId === undefined || extensionZoneId <= 0) {\n      throw new TableauError(ErrorCodes.InternalError, 'Extension Id is invalid.');\n    }\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.ExtensionZoneId]: extensionZoneId,\n      [ParameterId.ClickThroughEnabled]: clickThroughEnabled,\n    };\n\n    return this.execute(VerbId.SetClickThrough, parameters).then(() => {\n      return;\n    });\n  }\n}\n","import { InternalApiDispatcher } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry } from '@tableau/api-shared-js';\nimport { InitializationServiceImpl } from './Impl/InitializationServiceImpl';\nimport { SettingsServiceImpl } from './Impl/SettingsServiceImpl';\nimport { UIServiceImpl } from './Impl/UIServiceImpl';\nimport { ExtensionsRegistryId } from './ServiceRegistryUtil';\n\nexport function registerAllExtensionsServices(dispatcher: InternalApiDispatcher): void {\n  ApiServiceRegistry.get(ExtensionsRegistryId).registerService(new SettingsServiceImpl(dispatcher, ExtensionsRegistryId));\n  ApiServiceRegistry.get(ExtensionsRegistryId).registerService(new UIServiceImpl(dispatcher, ExtensionsRegistryId));\n}\n\nexport function registerInitializationExtensionsServices(dispatcher: InternalApiDispatcher): void {\n  ApiServiceRegistry.get(ExtensionsRegistryId).registerService(new InitializationServiceImpl(dispatcher, ExtensionsRegistryId));\n}\n","export const ExtensionsRegistryId = 0;\n","// This file re-exports everything which is part of the extensions api public interface\n\nexport * from './ExternalContract/Embedding/AskDataInterfaces';\nexport {\n  ApiMenuType,\n  CrosstabFileFormat,\n  DeviceType,\n  EmbeddingErrorCodes,\n  TableauEventType as EmbeddingTableauEventType,\n  FileFormats,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  PulseLayout,\n  SheetSizeBehavior,\n  TableauDialogType,\n  Toolbar,\n} from './ExternalContract/Embedding/Enums';\nexport {\n  CustomViewEvent,\n  CustomMarkContextMenuEvent as EmbeddingCustomMarkContextMenuEvent,\n  FilterChangedEvent as EmbeddingFilterChangedEvent,\n  MarksSelectedEvent as EmbeddingMarkSelectedEvent,\n  ParameterChangedEvent as EmbeddingParameterChangedEvent,\n  SummaryDataChangedEvent as EmbeddingSummaryDataChangedEvent,\n  TableauSheetEvent as EmbeddingTableauSheetEvent,\n  TableauWorksheetEvent as EmbeddingTableauWorksheetEvent,\n  ToolbarStateChangedEvent as EmbeddingToolbarStateChangedEvent,\n  FirstVizSizeKnownEvent,\n  StoryPointSwitchedEvent,\n  TabSwitchedEvent,\n  UrlActionEvent,\n  VizLoadErrorEvent,\n  WorkbookPublishedAsEvent,\n} from './ExternalContract/Embedding/EventInterfaces';\nexport { Parameter as EmbeddingParameter } from './ExternalContract/Embedding/ParameterInterfaces';\nexport * from './ExternalContract/Embedding/PulseInterfaces';\nexport {\n  ContextMenuOptions,\n  EmbeddingAbstractQuery,\n  AuthoringWorksheet as EmbeddingAuthoringWorksheet,\n  Dashboard as EmbeddingDashboard,\n  DashboardObject as EmbeddingDashboardObject,\n  Sheet as EmbeddingSheet,\n  EmbeddingVizStateWithDataModel,\n  Worksheet as EmbeddingWorksheet,\n  HierarchicalLevels,\n  SheetInfo,\n  SheetSize,\n} from './ExternalContract/Embedding/SheetInterfaces';\nexport { Story, StoryPoint, StoryPointInfo } from './ExternalContract/Embedding/StoryInterfaces';\nexport * from './ExternalContract/Embedding/TableauError';\nexport * from './ExternalContract/Embedding/VizInterfaces';\nexport * from './ExternalContract/Embedding/WebComponentInterfaces';\nexport {\n  CustomView,\n  AuthoringWorkbook as EmbeddingAuthoringWorkbook,\n  Workbook as EmbeddingWorkbook,\n} from './ExternalContract/Embedding/WorkbookInterface';\nexport * from './SharedApiExternalContract';\n","// This file re-exports everything which is part of the extensions api public interface\n\nexport * from './ExternalContract/Extensions/EventInterface';\nexport { DashboardContent } from './ExternalContract/Extensions/Namespaces/DashboardContent';\nexport { Environment } from './ExternalContract/Extensions/Namespaces/Environment';\nexport { Extensions } from './ExternalContract/Extensions/Namespaces/Extensions';\nexport { Settings } from './ExternalContract/Extensions/Namespaces/Settings';\nexport {\n  ErrorCodes,\n  ExtensionContext,\n  ExtensionMode,\n  TableauEventType,\n  VizImageEncodingType,\n  VizImagePaletteType,\n  VizImageSizeSettingAlignmentType,\n  VizImageSizeSettingType,\n  VizImageSortDirectionType,\n} from './ExternalContract/Extensions/Namespaces/Tableau';\nexport * from './ExternalContract/Extensions/Namespaces/UI';\nexport { WorksheetContent } from './ExternalContract/Extensions/Namespaces/WorksheetContent';\nexport * from './ExternalContract/Extensions/ParameterInterfaces';\nexport {\n  DashboardObjectPositionAndSizeUpdate,\n  DashboardObjectPositionAndSizeUpdateArray,\n  DashboardObjectVisibilityMap,\n  Dashboard as ExtensionDashboard,\n  DashboardObject as ExtensionDashboardObject,\n  Sheet as ExtensionSheet,\n  Worksheet as ExtensionWorksheet,\n  Point,\n  ZoneVisibilityMap,\n} from './ExternalContract/Extensions/SheetInterfaces';\nexport * from './ExternalContract/Extensions/TableauError';\nexport { Workbook as ExtensionWorkbook } from './ExternalContract/Extensions/WorkbookInterfaces';\nexport * from './SharedApiExternalContract';\n","/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\n\nexport * from './EmbeddingApiExternalContract';\nexport * from './ExtensionsApiExternalContract';\n","import { WebComponentLocalSettings, WebComponentSettingsShared } from './WebComponentInterfaces';\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-ask-data> web component.\n * @ignore\n * @deprecated\n */\nexport enum AskDataAttributes {\n  Origin = 'origin',\n  ShowEmbed = 'show-embed',\n  ShowPin = 'show-pin',\n  ShowSave = 'show-save',\n  ShowShare = 'show-share',\n}\n\n/**\n * @deprecated\n */\nexport interface AskDataSettings extends WebComponentSettingsShared, WebComponentLocalSettings {\n  /**\n   * Indicates whether the embed button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-embed>\n   * ```\n   */\n  showEmbed?: boolean;\n\n  /**\n   * Indicates whether the pin button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-pin>\n   * ```\n   */\n  showPin?: boolean;\n\n  /**\n   * Indicates whether the save button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-save>\n   * ```\n   */\n  showSave?: boolean;\n\n  /**\n   * Indicates whether the share button is hidden or visible.\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" show-share>\n   * ```\n   */\n  showShare?: boolean;\n\n  /**\n   *  Used for telemetry\n   * ```\n   * <tableau-ask-data id=\"tableauAskData\" origin=\"embeddingSite\">\n   * ```\n   */\n  origin?: string;\n}\n\n/**\n * The interface for the top level AskData object.\n * @deprecated\n **/\nexport interface AskData extends AskDataSettings {}\n","// All enum values made available to Embedding developers.\n// Enums should be kept in alphabetical order.\n// Most of them should match an enum on the server defined at\n// workgroup/vqlweb/scriptsharp/src/ApiShared/PublicEnums.cs#L398:17\n\n/**\n * Crosstab file formats available to use with {@link Viz.exportCrosstabAsync}\n */\nexport enum CrosstabFileFormat {\n  CSV = 'csv',\n  Excel = 'xlsx',\n}\n\n/**\n * Device types available to use with {@link Viz.device}\n */\nexport enum DeviceType {\n  Default = 'default',\n  Desktop = 'desktop',\n  Tablet = 'tablet',\n  Phone = 'phone',\n}\n\n/**\n * All error codes used by the Embedding API.\n */\nexport enum EmbeddingErrorCodes {\n  /**\n   * Raised when a request to the auth endpoint fails.\n   */\n  AuthFailed = 'auth-failed',\n  /**\n   * The browser is not capable of supporting the Tableau Embedding API\n   */\n  BrowserNotCapable = 'browser-not-capable',\n  /**\n   * The permissions on a workbook or a view do not allow downloading the workbook.\n   */\n  DownloadWorkbookNotAllowed = 'download-workbook-not-allowed',\n  /**\n   * Thrown when an error occurs while attempting to perform a filter operation.\n   */\n  FilterCannotBePerformed = 'filter-cannot-be-performed',\n  /**\n   * Thrown when attempting to switch to a sheet by index that does not exist in the workbook.\n   */\n  IndexOutOfRange = 'index-out-of-range',\n  /**\n   * Thrown when an error occurs within the Tableau Embedding API. Contact Tableau Support.\n   */\n  InternalError = 'internal-error',\n  /**\n   * An operation was attempted on a custom view that does not exist.\n   */\n  InvalidCustomViewName = 'invalid-custom-view-name',\n  /**\n   * An invalid date was specified in a method that required a date parameter.\n   */\n  InvalidDateParameter = 'invalid-date-parameter',\n  /**\n   * Either a filter operation was attempted on a field that does not exist in the data source, or the value supplied\n   * in the filter operation is the wrong data type or format.\n   */\n  invalidFilterFieldNameOrValue = 'invalid-filter-field-name',\n  /**\n   * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message\n   * field.\n   */\n  InvalidParameter = 'invalid-parameter',\n  /**\n   * A negative size was specified or the maxSize value is less than minSize in Sheet.changeSizeAsync().\n   */\n  InvalidSize = 'invalid-size',\n  /**\n   * Attempted to get an authoring worksheet when the current sheet is not a worksheet.\n   * @ignore\n   */\n  InvalidSheetType = 'invalid-sheet-type',\n  /**\n   * A behavior value was found that is not included in the SheetSizeBehavior enum.\n   */\n  InvalidSizeBehavior = 'invalid-size-behavior',\n  /**\n   * A behavior other than SheetSizeBehavior.Automatic was specified in Sheet.changeSizeAsync() when the sheet is a\n   * Worksheet instance.\n   */\n  InvalidSizeBehaviorOnWorksheet = 'invalid-size-behavior-on-worksheet',\n  /**\n   * The URL specified in the Viz class constructor is not valid.\n   */\n  InvalidUrl = 'invalid-url',\n  /**\n   * The maxSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.AtMost.\n   */\n  MissingMaxSize = 'missing-max-size',\n  /**\n   * The minSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.AtLeast.\n   */\n  MissingMinSize = 'missing-min-size',\n  /**\n   * The minSize or maxSize field is missing in Sheet.changeSizeAsync() when specifying SheetSizeBehavior.Range.\n   */\n  MissingMinMaxSize = 'missing-min-max-size',\n  /**\n   * Can occur if the embedding app interacts with a parameter that has been removed from the worksheet.\n   */\n  MissingParameter = 'missing-parameter',\n  /**\n   * The rangeN field is missing for a relative date filter of type LASTN or NEXTN.\n   */\n  MissingRangeNForRelativeDateFilters = 'missing-range-n-for-relative-date-filters',\n  /**\n   * An attempt was made to access Sheet.getUrl() on a hidden sheet. Hidden sheets do not have URLs.\n   */\n  NoUrlForHiddenWorksheet = 'no-url-for-hidden-worksheet',\n  /**\n   * One or both of the parentElement or the URL parameters is not specified in the Viz constructor.\n   */\n  NoUrlOrParentElementNotFound = 'no-url-or-parent-element-not-found',\n  /**\n   * An operation was attempted on a sheet that is not active or embedded within the active dashboard.\n   */\n  NotActiveSheet = 'not-active-sheet',\n  /**\n   * A required parameter was not specified, null, or an empty string/array.\n   */\n  NullOrEmptyParameter = 'null-or-empty-parameter',\n  /**\n   * An operation was attempted on a sheet that does not exist in the workbook.\n   */\n  SheetNotInWorkbook = 'sheet-not-in-workbook',\n  /**\n   * An operation is performed on a CustomView object that is no longer valid (it has been removed).\n   */\n  StaleDataReference = 'stale-data-reference',\n  /**\n   * Unknown error triggered during the auth flow.\n   */\n  UnknownAuthError = 'unknown-auth-error',\n  /**\n   * An unknown event name was specified in the call to Viz.addEventListener or Viz.removeEventListener.\n   */\n  UnsupportedEventName = 'unsupported-event-name',\n  /**\n   * A Viz object has already been created as a child of the parentElement specified in the Viz constructor.\n   */\n  VizAlreadyInManager = 'viz-already-in-manager',\n  /**\n   * Function is not supported in the embedding api.\n   */\n  ImplementationError = 'wrong-implementation',\n  /**\n   * @NotImplemented\n   */\n  NotImplemented = 'not-implemented',\n  /**\n   * Unknown error during event initialization\n   */\n  EventInitializationError = 'event-initialization-error',\n  /**\n   * Version of the embedding api not supported by the version of tableau\n   */\n  IncompatibleVersionError = 'incompatible-version-error',\n\n  /**\n   * Unknown {@link TableauDialogType} passed in to Viz.displayDialogAsync.\n   */\n  UnknownDialogType = 'unknown-dialog-type',\n\n  /**\n   * Can occur if the API interacts with a filter that has been removed from the worksheet.\n   * Can also occurs if a {@link FilterType} has not been implemented.\n   */\n  FilterMissingOrNotImplemented = 'filter-missing-not-implemented',\n\n  /**\n   * Can occur if story point ids no longer match.\n   */\n  StoryPointIdMismatch = 'storypoint-id-mismatch',\n}\n\n/**\n * Formats available to use with displayStaticImage in @VizInterfaces\n */\nexport enum FileFormats {\n  PDF = 'pdf',\n  PNG = 'png',\n}\n\nexport enum PrintOrientation {\n  Portrait = 'portrait',\n  Landscape = 'landscape',\n}\n\nexport enum PrintPageSize {\n  Letter = 'letter',\n  Legal = 'legal',\n  Note = 'note',\n  Folio = 'folio',\n  Tabloid = 'tabloid',\n  Ledger = 'ledger',\n  Statement = 'statement',\n  Executive = 'executive',\n  A3 = 'A3',\n  A4 = 'A4',\n  A5 = 'A5',\n  B4 = 'B4',\n  B5 = 'B5',\n  Quarto = 'quarto',\n  Unspecified = 'unspecified',\n}\n\nexport enum PrintScaling {\n  Automatic = 'automatic',\n  Perc25 = '25%',\n  Perc50 = '50%',\n  Perc60 = '60%',\n  Perc75 = '75%',\n  Perc80 = '80%',\n  Perc90 = '90%',\n  Perc100 = '100%',\n  Perc200 = '200%',\n  Perc400 = '400%',\n  AtMost1PageHigh = 'at-most-1-page-high',\n  AtMost2PagesHigh = 'at-most-2-pages-high',\n  AtMost1PageWide = 'at-most-1-page-wide',\n  AtMost2PagesWide = 'at-most-2-pages-wide',\n}\n\nexport enum RevertVizSelection {\n  All = 'all',\n  Axes = 'axes',\n  Filters = 'filters',\n  Sorts = 'sorts',\n  Shelves = 'shelves',\n}\n\nexport enum ToolbarButtons {\n  Alerts = 'alerts',\n  AskData = 'askData',\n  CustomViews = 'customViews',\n  DataDetails = 'dataDetails',\n  Share = 'share',\n  Subscribe = 'subscribe',\n}\n\nexport enum Toolbar {\n  Top = 'top',\n  Bottom = 'bottom',\n  Hidden = 'hidden',\n}\n\nexport enum SheetSizeBehavior {\n  Automatic = 'automatic',\n  Exactly = 'exactly',\n  Range = 'range',\n  AtLeast = 'atleast',\n  AtMost = 'atmost',\n}\n\nexport enum PulseLayout {\n  Default = 'default',\n  Card = 'card',\n  Ban = 'ban',\n}\n\n/**\n * Be careful when adding new event types. Extensions and embedding follow two different patterns on how events are named.\n * Events should be all lower case and without hyphens or underscores.\n */\n\n/**\n * Represents the type of tableau embedding event that can be listened for.\n */\nexport enum TableauEventType {\n  /**\n   * Raised when a custom view has finished loading. This event is raised after the callback function for {@link FirstInteractive} (if any) has been called.\n   *\n   * @category Viewing\n   */\n  CustomViewLoaded = 'customviewloaded',\n\n  /**\n   * Raised when a custom view has been removed.\n   *\n   * @category Viewing\n   */\n  CustomViewRemoved = 'customviewremoved',\n\n  /**\n   * Raised when a custom view has been saved (newly created or updated).\n   *\n   * @category Viewing\n   */\n  CustomViewSaved = 'customviewsaved',\n\n  /**\n   * Raised when a custom view has been set as the default view for a workbook.\n   *\n   * @category Viewing\n   */\n  CustomViewSetDefault = 'customviewsetdefault',\n\n  /** Raised when the user clicks on the Edit Button.\n   *\n   * @category Viewing\n   */\n  EditButtonClicked = 'editbuttonclicked',\n\n  /** Raised when the user clicks on the Edit In Desktop Button.\n   *\n   * @category Authoring, Viewing\n   */\n  EditInDesktopButtonClicked = 'editindesktopbuttonclicked',\n\n  /** Raised when any filter has changed state. You can use this event type with TableauViz objects.\n   *\n   * @category Viewing\n   */\n  FilterChanged = 'filterchanged',\n\n  /** Fired when viz size is known\n   *\n   * @category Authoring, Viewing\n   */\n  FirstVizSizeKnown = 'firstvizsizeknown',\n\n  /** Fired when a viz first becomes interactive\n   *\n   * @category Authoring, Viewing\n   */\n  FirstInteractive = 'firstinteractive',\n\n  /** Raised when a custom mark context menu is clicked.\n   *\n   * @category Viewing\n   */\n  CustomMarkContextMenuEvent = 'custommarkcontextmenu',\n\n  /** The selected marks on a visualization have changed. You can use this event type with TableauViz objects.\n   *\n   * @category Viewing\n   */\n  MarkSelectionChanged = 'markselectionchanged',\n\n  /** A parameter has had its value modified. You can use this event type with [[Parameter]] objects.\n   *\n   * @category Viewing\n   */\n  ParameterChanged = 'parameterchanged',\n\n  /** Raised when a toolbar button or control becomes available or becomes unavailable.\n   *\n   * @category Viewing\n   */\n  ToolbarStateChanged = 'toolbarstatechanged',\n\n  /** Raised when the workbook is ready to close. This notification is sent when using embedded web authoring functionality.\n   *\n   * @category Authoring\n   */\n  WorkbookReadyToClose = 'workbookreadytoclose',\n\n  /** Raised when the workbook has been published. This notification is sent when using embedded web authoring functionality.\n   *\n   * @category Authoring\n   */\n  WorkbookPublished = 'workbookpublished',\n\n  /** Raised when \"publish as\" is successful. This notification is sent when using embedded web authoring functionality.\n   *\n   * @category Authoring\n   */\n  WorkbookPublishedAs = 'workbookpublishedas',\n\n  /**\n   * Raised when a URL action occurs. See the {@link UrlActionEvent} class.\n   *\n   * @category Viewing\n   */\n  UrlAction = 'urlaction',\n\n  /**\n   * Raised after a tab switch occurs (the active sheet has changed). Guarantees the viz object will be interactive after this.\n   *\n   * @category Viewing\n   */\n  TabSwitched = 'tabswitched',\n  /**\n   *\n   * Raised after a new story point becomes active.\n   *\n   * @category Viewing\n   */\n  StoryPointSwitched = 'storypointswitched',\n  /**\n   *\n   * Raised when an error occurs while loading the contents of the webcomponent.\n   *\n   * @category Authoring, Viewing, AskData\n   */\n  VizLoadError = 'vizloaderror',\n  /**\n   * Raised after the iframe src attribute has been updated\n   *\n   * @category Authoring, Viewing, AskData\n   */\n  IframeSrcUpdated = 'iframesrcupdated',\n\n  /**\n   * Raised when changes are made to summary data.\n   *\n   * @category Viewing\n   */\n  SummaryDataChanged = 'summarydatachanged',\n\n  /**\n   * Raised when tableau (viz-client) is ready to receive an auth token.\n   * Used for authentication in salesforce native mode.\n   *\n   * @hidden\n   * @category Authoring, Viewing,\n   */\n  ReadyToReceiveAuthToken = 'readytoreceiveauthtoken',\n}\n\n/**\n * Represents the location of a context menu where users can add external menu items.\n */\nexport enum ApiMenuType {\n  /** External menu item will be injected in ubertip dialog */\n  Ubertip = 'ubertip',\n}\n\n/** You can use this type with a {@link Viz} object. */\nexport enum TableauDialogType {\n  /**\n   * Used to display the download PDF dialog.\n   */\n  ExportPDF = 'export-pdf',\n  /**\n   * Used to display the download PowerPoint dialog.\n   */\n  ExportPowerPoint = 'export-powerpoint',\n  /**\n   * Used to display the download Data dialog.\n   */\n  ExportData = 'export-data',\n  /**\n   * Used to display the download CrossTab dialog.\n   */\n  ExportCrossTab = 'export-cross-tab',\n  /**\n   * Used to display the download Workbook dialog.\n   */\n  ExportWorkbook = 'export-workbook',\n  /**\n   * Used to display the Share dialog.\n   */\n  Share = 'share',\n}\n","import { PulseLayout } from './Enums';\nimport { WebComponentLocalSettings } from './WebComponentInterfaces';\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-pulse> web component.\n * @ignore\n */\nexport enum PulseAttributes {\n  DisableExploreFilter = 'disable-explore-filter',\n  Layout = 'layout',\n}\n\nexport interface PulseSettings extends WebComponentLocalSettings {\n  /**\n   * Indicates whether the explore filter is hidden or visible.\n   * ```\n   * <tableau-pulse id=\"tableauPulse\" disable-explore-filter>\n   * ```\n   */\n  disableExploreFilter?: boolean;\n\n  /**\n   * Specifies the desired custom layout of the Pulse metric.\n   * ```\n   * <tableau-pulse id=\"tableauPulse\" layout=\"card\">\n   * ```\n   */\n  layout?: PulseLayout;\n\n  /**\n   * The token used for authorization\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-authoring-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-pulse id=\"tableauPulse\" token=\"some-token-containing-clientId\" />\n   * ```\n   */\n  token?: string;\n}\n\n/**\n * The interface for the top-level Pulse object.\n **/\nexport interface Pulse extends PulseSettings {}\n","import {\n  CrosstabFileFormat,\n  DeviceType,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  TableauDialogType,\n  TableauEventType,\n  Toolbar,\n} from './Enums';\nimport { SheetSize } from './SheetInterfaces';\nimport { WebComponentLocalSettings, WebComponentSettingsShared } from './WebComponentInterfaces';\nimport { Workbook } from './WorkbookInterface';\n\n/**\n * The shared string constants you can use as HTML attributes for the <tableau-viz> and <tableau-authoring-viz> web component.\n * @ignore\n */\nexport enum VizSharedAttributes {\n  TouchOptimize = 'touch-optimize',\n  HideEditInDesktopButton = 'hide-edit-in-desktop-button',\n  SuppressDefaultEditBehavior = 'suppress-default-edit-behavior',\n  DisableVersionCheck = 'disable-version-check',\n  OnEditInDesktopButtonClicked = 'onEditInDesktopButtonClicked',\n  OnFirstVizSizeKnown = 'onFirstVizSizeKnown',\n  OnFirstInteractive = 'onFirstInteractive',\n}\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-viz> web component.\n * @ignore\n */\nexport enum VizAttributes {\n  DisableUrlActionsPopups = 'disable-url-actions',\n  HideTabs = 'hide-tabs',\n  Toolbar = 'toolbar',\n  InstanceIdToClone = 'instance-id-to-clone',\n  Device = 'device',\n  HideEditButton = 'hide-edit-button',\n  OnEditButtonClicked = 'onEditButtonClicked',\n  OnFilterChanged = 'onFilterChanged',\n  OnCustomMarkContextMenuEvent = 'onCustomMarkContextMenuEvent',\n  OnMarkSelectionChanged = 'onMarkSelectionChanged',\n  OnParameterChanged = 'onParameterChanged',\n  OnToolbarStateChanged = 'onToolbarStateChanged',\n  OnUrlAction = 'onUrlAction',\n  OnTabSwitched = 'onTabSwitched',\n  OnCustomViewLoaded = 'onCustomViewLoaded',\n  OnCustomViewRemoved = 'onCustomViewRemoved',\n  OnCustomViewSaved = 'onCustomViewSaved',\n  OnCustomViewSetDefault = 'onCustomViewSetDefault',\n  OnStoryPointSwitched = 'onStoryPointSwitched',\n  OnSummaryDataChanged = 'onSummaryDataChanged',\n  OnReadyToReceiveAuthToken = 'onReadyToReceiveAuthToken',\n}\n\n/**\n * The names of the string constants you can use as HTML attributes for the <tableau-authoring-viz> web component.\n * @ignore\n */\nexport enum VizAuthoringAttributes {\n  OnWorkbookPublished = 'onWorkbookPublished',\n  OnWorkbookPublishedAs = 'onWorkbookPublishedAs',\n  OnWorkbookReadyToClose = 'onWorkbookReadyToClose',\n  HideCloseButton = 'hide-close-button',\n}\n\n/**\n * The names of the string constants you can use as child tags for TableauViz and TableauAuthoringViz custom elements.\n */\nexport enum VizChildElements {\n  /**\n   * Contains a list of filter parameters. Available only in viewing mode.\n   */\n  VizFilter = 'viz-filter',\n\n  /**\n   * Contains a name and value for a parameter. Available only in viewing mode.\n   */\n  VizParameter = 'viz-parameter',\n\n  /**\n   * Contains a list of custom parameters.  Available in both viewing and authoring modes.\n   */\n  CustomParameter = 'custom-parameter',\n}\n\nexport enum VizChildElementAttributes {\n  Field = 'field',\n  Value = 'value',\n  Name = 'name',\n}\n\n/**\n * The interface for the top level Viz object.\n **/\nexport interface Viz extends VizSettings, WebComponentLocalSettings, VizActions {\n  /**\n   * One Workbook is supported per visualization.\n   */\n  readonly workbook?: Workbook;\n\n  /**\n   * Provide an auth token for salesforce native mode\n   * @param token\n   */\n  setAuthToken(token: string): void;\n}\n\n/**\n * The interface for the top level Authoring Viz object.\n */\nexport interface AuthoringViz extends VizAuthoringSettings, WebComponentLocalSettings {\n  /**\n   * Gets the visualization's current URL.\n   */\n  getCurrentSrcAsync(): Promise<string>;\n\n  /**\n   * Provide an auth token for salesforce native mode\n   * @param token\n   */\n  setAuthToken(token: string): void;\n}\n\n/**\n * Partially implemented - Actions related to events and state of the viz\n */\nexport interface VizActions {\n  /**\n   * Indicates whether automatic updates are currently paused.\n   */\n  readonly automaticUpdatesArePaused: boolean;\n\n  /**\n   * Pause layout updates. This is useful if you are resizing the visualization or performing multiple calls that could affect the layout.\n   */\n  pauseAutomaticUpdatesAsync(): Promise<void>;\n\n  /**\n   * Resume layout updates.\n   */\n  resumeAutomaticUpdatesAsync(): Promise<void>;\n\n  /**\n   * Toggle layout updates.\n   */\n  toggleAutomaticUpdatesAsync(): Promise<void>;\n\n  /**\n   * Equivalent to clicking on the Revert All toolbar button, which restores the workbook to its starting state.\n   */\n  revertAllAsync(): Promise<void>;\n\n  /**\n   * Equivalent to clicking on the Refresh Data toolbar button.\n   */\n  refreshDataAsync(): Promise<void>;\n\n  /**\n   * Equivalent to clicking on Download > Image from the toolbar, which creates a PNG file of the current visualization.\n   */\n  exportImageAsync(): Promise<void>;\n\n  /**\n   * Exports the crosstab of any given worksheet within the current view to a\n   * specified format (CrosstabFileFormat.Excel, CrosstabFileFormat.CSV).\n   * Throws an error if the sheet name does not match any worksheets within the active sheet.\n   * Throws an error if the crosstab file failed to be created.\n   * Note: exportCrosstabAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * viz.exportCrosstabAsync('Sales by Segment', CrosstabFileFormat.CSV);\n   * ```\n   */\n  exportCrosstabAsync(sheetName: string, format: CrosstabFileFormat): Promise<void>;\n\n  /**\n   * Exports the summary data shown in the View Data window\n   * (shown when you click Download > Data from the toolbar for any given worksheet within the current view).\n   * The current file format is CSV. There is no limitation on the amount of summary data you can export.\n   * Throws an error if the sheet name does not match any worksheets within the active sheet.\n   * Throws an error if the CSV file failed to be created.\n   * Note: exportDataAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * const activeSheet = viz.workbook.activeSheet;\n   * if (activeSheet.sheetType === SheetType.Worksheet) {\n   *   const columns = await activeSheet.getSummaryColumnsInfoAsync();\n   *   // Getting fieldId's for Latitude and Longitude columns\n   *   const columnsToIncludeById = columns.map((column) => {\n   *     if (column.fieldName === 'Latitude' || column.fieldName === 'Longitude') {\n   *       return column.fieldId;\n   *     }\n   *   });\n   *   await viz.exportDataAsync(activeSheet.name, { columnsToIncludeById });\n   * }\n   * else if (activeSheet.sheetType === SheetType.Dashboard) {\n   *   // Exporting the summary data for each worksheet in the dashboard while also ignoring aliases\n   *   for (const worksheet of activeSheet.worksheets) {\n   *     await viz.exportDataAsync(worksheet.name, { ignoreAliases: true });\n   *   }\n   * }\n   * else\n   * {\n   *   // activeSheet is a Story and we want to export worksheets within the current view\n   *   const containedSheet = activeSheet.activeStoryPoint.containedSheet;\n   *   if (containedSheet !== undefined && containedSheet.sheetType === SheetType.Worksheet) {\n   *     // Exporting summary data of a worksheet within the active story point\n   *     await viz.exportDataAsync(containedSheet.name);\n   *   } else if (containedSheet !== undefined && containedSheet.sheetType === SheetType.Dashboard) {\n   *     // Exporting the summary data for each worksheet within the active story point\n   *     for (const worksheet of containedSheet.worksheets) {\n   *       await viz.exportDataAsync(worksheet.name);\n   *     }\n   *   }\n   * }\n   * ```\n   */\n  exportDataAsync(sheetName: string, options?: ExportDataOptions): Promise<void>;\n\n  /**\n   * Exports the list of sheets to a PowerPoint file. If no sheets are specified, the current sheet is exported.\n   * The order the sheets appear in the list is the order the sheets appear in the PowerPoint file.\n   * The list of sheets can either exclusively include the worksheets within a dashboard or exclusively include the published sheets from the workbook.\n   *\n   * Throws an error if the list of sheets contains both worksheets within a dashboard and published sheets from the workbook.\n   * Throws an error if the PowerPoint file fails to be created.\n   *\n   * Note: exportPowerPointAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * const workbook = viz.workbook;\n   * const activeSheet = workbook.activeSheet;\n   * if (activeSheet.sheetType === SheetType.Worksheet || activeSheet.sheetType === SheetType.Story) {\n   *   await viz.exportPowerPointAsync();\n   * } else if (activeSheet.sheetType ===  SheetType.Dashboard) {\n   *   const worksheetNames = activeSheet.worksheets.map((worksheet) => worksheet.name);\n   *   await viz.exportPowerPointAsync(worksheetNames);\n   * }\n   * // exporting all sheets within the workbook to PowerPoint\n   * const publishedSheetNames = workbook.publishedSheetsInfo.map((publishedSheetInfo) => publishedSheetInfo.name);\n   * await viz.exportPowerPointAsync(publishedSheetNames);\n   * ```\n   */\n  exportPowerPointAsync(sheetNames?: Array<string>): Promise<void>;\n\n  /**\n   * Exports the list of sheets with the given {@link ExportPDFOptions} options. If no sheets are specified, the current sheet is exported.\n   * The list of sheets can either exclusively include the worksheets within a dashboard or exclusively include the published sheets from the workbook.\n   * If no ExportPDFOptions are specified, the default settings are: Scaling = Automatic, PageSize = Letter, and Orientation = Portrait.\n   *\n   * Throws an error if the list of sheets contains both worksheets within a dashboard and published sheets from the workbook.\n   * Throws an error if the PDF file fails to be created.\n   *\n   * Note: exportPDFAsync resolves when a download is initiated. It does not indicate that a download was successful or if the download was complete.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * const workbook = viz.workbook;\n   * const activeSheet = workbook.activeSheet;\n   * if (activeSheet.sheetType === SheetType.Worksheet || activeSheet.sheetType === SheetType.Story) {\n   *   await viz.exportPDFAsync();\n   * } else if (activeSheet.sheetType ===  SheetType.Dashboard) {\n   *   const worksheetNames = activeSheet.worksheets.map((worksheet) => worksheet.name);\n   *   await viz.exportPDFAsync(worksheetNames);\n   * }\n   * // exporting all sheets within the workbook to PDF\n   * const publishedSheetNames = workbook.publishedSheetsInfo.map((publishedSheetInfo) => publishedSheetInfo.name);\n   * await viz.exportPDFAsync(publishedSheetNames);\n   * ```\n   */\n  exportPDFAsync(sheetNames?: Array<string>, options?: ExportPDFOptions): Promise<void>;\n\n  /**\n   * Display one of the export dialogs based on the dialogType parameter\n   *\n   * Throws an error if dialogType is invalid\n   */\n  displayDialogAsync(dialogType: TableauDialogType): Promise<void>;\n\n  /**\n   * Gets the visualization's current URL.\n   */\n  getCurrentSrcAsync(): Promise<string>;\n\n  /**\n   * Redoes the last action performed on a sheet.\n   */\n  redoAsync(): Promise<void>;\n\n  /**\n   * Undoes the last action performed on a sheet.\n   */\n  undoAsync(): Promise<void>;\n\n  /**\n   * Adds an event listener to the specified event.\n   *\n   * ```\n   * async function getSelectedMarks(event) {\n   *     const marksSelected = await event.detail.getMarksAsync();\n   *     const numMarks = marksSelected.data[0].data.length;\n   *     console.log(`${numMarks} marks Selected`);\n   * }\n   *\n   * let viz = document.getElementById('tableauViz');\n   * viz.addEventListener(\"markselectionchanged\", getSelectedMarks);\n   * ```\n   */\n  addEventListener(type: TableauEventType, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;\n\n  /**\n   * Removes an event listener from the specified event.\n   *\n   * ```\n   * let viz = document.getElementById('tableauViz');\n   * viz.removeEventListener(\"markselectionchanged\", getSelectedMarks);\n   * ```\n   */\n  removeEventListener(type: TableauEventType, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;\n\n  /**\n   * Use this method to filter the viz before initialization. If used after initialization, it will re-render the viz.\n   * For filtering after initialization, use the other filtering methods, such as `applyFilterAsync`.\n   *\n   * If you add the same filter fields using the `addFilter()` method and by using the `<viz-filter>` element in the `<tableau-viz>` web component,\n   * you might experience unexpected behavior.\n   *\n   * @param fieldName The name of the field to filter on.\n   * @param value Single value or a list of comma separated values to filter on.\n   *\n   * ```\n   * viz.addFilter('Region', 'Central,West');\n   * ```\n   */\n  addFilter(fieldName: string, value: string): void;\n}\n\nexport interface VizSize {\n  /**\n   * Gets the sheetSize record for the current sheet\n   */\n  readonly sheetSize: SheetSize;\n\n  /**\n   * Gets the height of the Tableau UI elements (the chrome) surrounding the view.\n   */\n  readonly chromeHeight: number;\n}\n\n/**\n * This interface represents all of the options for configuring a viz that are common between\n * viewing and authoring mode.\n */\ninterface VizSettingsShared extends WebComponentSettingsShared {\n  /**\n   * Indicates whether to touch optimize viz controls.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" touch-optimize />\n   * <tableau-authoring-viz id=\"tableauViz\" touch-optimize />\n   * ```\n   */\n  touchOptimize?: boolean;\n\n  /**\n   * Indicates whether the Edit in Desktop button is hidden or visible.\n   * If not specified, defaults to false, meaning that the Edit in Desktop button is visible.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" hide-edit-in-desktop-button>\n   * <tableau-authoring-viz id=\"tableauViz\" hide-edit-in-desktop-button>\n   * ```\n   */\n  hideEditInDesktopButton?: boolean;\n\n  /**\n   * Indicates whether the default edit behavior is suppressed.\n   * If not specified, defaults to false, meaning that the default edit behavior is not suppressed.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" suppress-default-edit-behavior>\n   * <tableau-authoring-viz id=\"tableauViz\" suppress-default-edit-behavior>\n   * ```\n   */\n  suppressDefaultEditBehavior?: boolean;\n\n  /**\n   * An event raised when the user clicks on the Edit In Desktop Button. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onEditInDesktopButtonClicked=\"onEditInDesktopButtonClickedHandler\" />\n   * <tableau-authoring-viz id=\"tableauViz\" onEditInDesktopButtonClicked=\"onEditInDesktopButtonClickedHandler\" />\n   * ```\n   */\n  onEditInDesktopButtonClicked?: string;\n\n  /**\n   * An event raised when the size of the viz is known. You can use this event to perform tasks such as resizing\n   * the elements surrounding the Viz object once the object's size has been established.\n   * ```\n   * <tableau-viz id=\"tableauViz\" \"onFirstVizSizeKnown\"=\"onFirstVizSizeKnownHandler\" />\n   * <tableau-authoring-viz id=\"tableauViz\" onFirstVizSizeKnown=\"onFirstVizSizeKnownHandler\" />\n   * ```\n   */\n  onFirstVizSizeKnown?: string;\n\n  /**\n   * An event raised when the Viz object first becomes interactive. This is only raised once.\n   * ```\n   * <tableau-viz id=\"tableauViz\" \"onFirstInteractive\"=\"onFirstInteractiveHandler\" />\n   * <tableau-authoring-viz id=\"tableauViz\" onFirstInteractive=\"onFirstInteractiveHandler\" />\n   * ```\n   */\n  onFirstInteractive?: string;\n}\n\n/**\n * The options for configuring a viz in view mode.\n */\nexport interface VizSettings extends VizSettingsShared {\n  /**\n   * Indicates whether to suppress the execution of URL actions. This option does not prevent the URL action\n   * event from being raised. You can use this option to change what happens when a URL action occurs. If set\n   * to true and you create an event listener for the URL_ACTION event, you can use an event listener\n   * handler to customize the actions.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" disable-url-actions />\n   * ```\n   */\n  disableUrlActionsPopups?: boolean;\n\n  /**\n   * Indicates whether tabs are hidden or shown.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  hide-tabs />\n   * ```\n   */\n  hideTabs?: boolean;\n\n  /**\n   * Specifies the position of the toolbar, if it is shown. The values can be Toolbar.Top,\n   * Toolbar.Bottom or Toolbar.Hidden.\n   * If not specified, defaults to Toolbar.Bottom.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  toolbar=\"hidden\" />\n   * ```\n   */\n  toolbar?: Toolbar;\n\n  /**\n   * Specifies a device layout for a dashboard, if it exists.\n   * Values can be default, desktop, tablet, or phone.\n   * If not specified, defaults to loading a layout based on the\n   * smallest dimension of the hosting iframe element.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  device=\"desktop\" />\n   * ```\n   */\n  device?: DeviceType;\n\n  /**\n   * Specifies the ID of an existing instance to make a copy (clone) of.\n   * This is useful if the user wants to continue analysis of an existing visualization\n   * without losing the state of the original. If the ID does not refer to an existing visualization,\n   * the cloned version is derived from the original visualization.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\"  instance-id-to-clone=\"id1\" />\n   * ```\n   */\n  instanceIdToClone?: string;\n\n  /**\n   * Indicates whether the Edit button is hidden or visible.\n   * If not set, defaults to false, meaning that the Edit button is visible.\n   * ```\n   * <tableau-viz id=\"tableauViz\" hide-edit-button>\n   * ```\n   */\n  hideEditButton?: boolean;\n\n  /**\n   * An event raised when the user clicks on the Edit Button.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onEditButtonClicked=\"onEditButtonClickedHandler\" />\n   * ```\n   */\n  onEditButtonClicked?: string;\n\n  /**\n   * An event raised when any filter has changed state. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onFilterChanged=\"onFilterChangedHandler\" />\n   * ```\n   */\n  onFilterChanged?: string;\n\n  /**\n   * An event raised when a custom mark context menu is clicked.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomMarkContextMenuEvent=\"onCustomMarkContextMenuEventHandler\" />\n   * ```\n   */\n  onCustomMarkContextMenuEvent?: string;\n\n  /**\n   * An event raised when the selected marks on a visualization have changed. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onMarkSelectionChanged=\"onMarkSelectionChangedHandler\" />\n   * ```\n   */\n  onMarkSelectionChanged?: string;\n\n  /**\n   * An event raised when a parameter has had its value modified. You can use this event type with [[Parameter]] objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onParameterChanged=\"onParameterChangedHandler\" />\n   * ```\n   */\n  onParameterChanged?: string;\n\n  /**\n   * An event raised when a toolbar button or control becomes available or becomes unavailable.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onToolbarStateChanged=\"onToolbarStateChangedHandler\" />\n   * ```\n   */\n  onToolbarStateChanged?: string;\n\n  /**\n   * An event raised when a URL action occurs. See the {@link UrlActionEvent} class.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onUrlAction=\"onUrlActionHandler\" />\n   * ```\n   */\n  onUrlAction?: string;\n\n  /**\n   * An event raised after a tab switch occurs (the active sheet has changed). Guarantees the viz object will be interactive after this.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onTabSwitched=\"onTabSwitchedHandler\" />\n   * ```\n   */\n  onTabSwitched?: string;\n\n  /**\n   * An event raised when a custom view has finished loading. This event is raised after the callback\n   * function for {@link FirstInteractive} (if any) has been called.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewLoaded=\"onCustomViewLoadedHandler\" />\n   * ```\n   */\n  onCustomViewLoaded?: string;\n\n  /**\n   * An event raised when a custom view has been removed.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewRemoved=\"onCustomViewRemovedHandler\" />\n   * ```\n   */\n  onCustomViewRemoved?: string;\n\n  /**\n   * An event raised when a custom view has been saved (newly created or updated).\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewSaved=\"onCustomViewSavedHandler\" />\n   * ```\n   */\n  onCustomViewSaved?: string;\n\n  /**\n   * An event raised when a custom view has been set as the default view for a workbook.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onCustomViewSetDefault=\"onCustomViewSetDefaultHandler\" />\n   * ```\n   */\n  onCustomViewSetDefault?: string;\n\n  /**\n   * An event raised after a new story point becomes active.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onStoryPointSwitched=\"onStoryPointSwitchedHandler\" />\n   * ```\n   */\n  onStoryPointSwitched?: string;\n\n  /**\n   * An event raised when the summary data on a visualization have changed. You can use this event type with TableauViz objects.\n   * ```\n   * <tableau-viz id=\"tableauViz\" onSummaryDataChanged=\"onSummaryDataChangedHandler\" />\n   * ```\n   */\n  onSummaryDataChanged?: string;\n}\n\n/**\n * (Beta) Represents the options for configuring a viz in authoring mode.\n */\nexport interface VizAuthoringSettings extends VizSettingsShared {\n  /**\n   * Indicates whether the Close button is hidden or visible.\n   * If not set, defaults to false, meaning that the Close button is visible.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" hide-close-button />\n   * ```\n   */\n  hideCloseButton?: boolean;\n\n  /**\n   * An event raised when the workbook has been published. This notification is sent when using embedded web authoring functionality.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" onWorkbookPublished=\"onWorkbookPublishedHandler\" />\n   * ```\n   */\n  onWorkbookPublished?: string;\n\n  /**\n   * An event raised when \"publish as\" is successful. This notification is sent when using embedded web authoring functionality.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" onWorkbookPublishedAs=\"onWorkbookPublishedAsHandler\" />\n   * ```\n   */\n  onWorkbookPublishedAs?: string;\n\n  /**\n   * An event raised when the workbook is ready to close. This notification is sent when using embedded web authoring functionality.\n   * ```\n   * <tableau-authoring-viz id=\"tableauViz\" onWorkbookReadyToClose=\"onWorkbookReadyToCloseHandler\" />\n   * ```\n   */\n  onWorkbookReadyToClose?: string;\n}\n\nexport interface FilterParameters {\n  field: string;\n  value: string;\n}\n\n/**\n * VizParameters are used to set Parameter values on the viz.\n *\n * * ```\n * <tableau-viz id=\"tableauViz\">\n *  <viz-parameter name=\"parameter-name\" value=\"parameter-value\"></viz-parameter>\n * </tableau-viz>\n * ```\n *\n */\nexport interface VizParameter {\n  /**\n   * Name of the parameter to be set.\n   */\n  name: string;\n\n  /**\n   * Valid value for the parameter being set.\n   */\n  value: string;\n}\n\n/**\n * CustomParameters are used to pass along settings, information, etc., that aren't exposed on the\n * tableau-viz element. CustomParameters will override attributes, or filters, set on the tableau-viz element.\n *\n * * ```\n * <tableau-viz id=\"tableauViz\">\n *  <custom-parameter name=\"parameter-name\" value=\"parameter-value\"></custom-parameter>\n * </tableau-viz>\n * ```\n *\n */\nexport interface CustomParameter {\n  /**\n   * Name of the parameter to be set.\n   */\n  name: string;\n\n  /**\n   * Valid value for the parameter being set.\n   */\n  value: string;\n}\n\n/**\n * Configuration object for exporting data.\n */\nexport interface ExportDataOptions {\n  /**\n   * Do not use aliases specified in the data source in Tableau. Default is false.\n   */\n  ignoreAliases?: boolean;\n  /**\n   * The columns to include specified by field id, includes all by default.\n   * The order of the column ids in the array determines the column order shown in the summary data table.\n   */\n  columnsToIncludeById?: Array<string>;\n}\n\nexport interface ExportPDFOptions {\n  scaling: PrintScaling;\n  pageSize: PrintPageSize;\n  orientation: PrintOrientation;\n}\n\nexport interface ExportScenariosForPDFAndPowerPoint {\n  currentSheetName: string;\n  exportableSheetNamesFromDashboard: Array<string>;\n  exportableSheetNamesFromWorkbook: Array<string>;\n}\n","/**\n * User supplied options that do not get passed as request parameters to load a Tableau viz, Tableau askdata\n */\nexport interface WebComponentLocalSettings {\n  /**\n   * The viz src\n   */\n  src?: string | null;\n\n  /**\n   * Represents width in pixels\n   * Can be any valid CSS size specifier. If not specified, defaults to the published width of the view.\n   */\n  width?: string | number;\n\n  /**\n   * Represents height in pixels\n   * Can be any valid CSS size specifier. If not specified, defaults to the published height of the view.\n   */\n  height?: string | number;\n}\n\n/**\n * This interface represents all of the options for configuring a webcomponent that are common between\n * viz and askdata.\n */\nexport interface WebComponentSettingsShared {\n  /**\n   * The token used for authorization\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-authoring-viz id=\"tableauViz\" token=\"some-token-containing-clientId\" />\n   * <tableau-ask-data id=\"tableauAskData\" token=\"some-token-containing-clientId\" />\n   * ```\n   */\n  token?: string;\n\n  /**\n   * Indicates whether the non-minified version of JavaScript is loaded. If specified (or set to true), the\n   * non-minified version is used for both the local component and the Tableau Server visualization (if enabled).\n   * If not specified (or set to false), the minified version of the JavaScript files are loaded.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" debug />\n   * <tableau-authoring-viz id=\"tableauViz\" debug />\n   * <tableau-ask-data id=\"tableauAskData\" debug />\n   * ```\n   */\n  debug?: boolean;\n\n  /**\n   * Indicates whether to use the old auth mechanism for authentication which happens inside the iframe. If specified, VizLoadErrorEvents\n   * triggered due to auth failures will not be thrown.\n   *\n   * ```\n   * <tableau-viz id=\"tableauViz\" iframe-auth />\n   * <tableau-authoring-viz id=\"tableauViz\" iframe-auth />\n   * <tableau-ask-data id=\"tableauAskData\" iframe-auth />\n   * ```\n   */\n  iframeAuth?: boolean;\n}\n\n/**\n * The names of the common string constants you can use as HTML attributes for the tableau web component.\n * @ignore\n */\nexport enum WebComponentAttributes {\n  Src = 'src',\n  Width = 'width',\n  Height = 'height',\n  Token = 'token',\n  Debug = 'debug',\n  IframeAuth = 'iframe-auth',\n  OnVizLoadError = 'onvizloaderror',\n  ForceTokenSync = 'force-token-sync',\n}\n\n/**\n * The names of the string constants you can use as child tags for TableauViz, TableauAuthoringViz and TableauAskData custom elements.\n * @ignore\n */\nexport enum WebComponentChildElements {\n  /**\n   * Contains a list of custom parameters.  Available in viz viewing, viz authoring and askdata.\n   */\n  CustomParameter = 'custom-parameter',\n}\n\nexport enum WebComponentChildElementAttributes {\n  Field = 'field',\n  Value = 'value',\n  Name = 'name',\n}\n","// All enum values made available to Extensions developers.\n// Enums should be kept in alphabetical order.\n\nimport { Extensions } from './Extensions';\n\nnamespace Tableau {\n  export let extensions: Extensions;\n  /**\n   * All error codes used by the Extensions API.\n   */\n  export enum ErrorCodes {\n    /**\n     * Thrown when caller attempts to execute command before initialization has completed.\n     */\n    APINotInitialized = 'api-not-initialized',\n    /**\n     * Thrown when caller attempts to execute command while extension is not visible.\n     */\n    VisibilityError = 'visibility-error',\n    /**\n     * Only one dialog can be opened at time with the UI namespace functionality.\n     */\n    DialogAlreadyOpen = 'dialog-already-open',\n    /**\n     * The open dialog was closed by the user.\n     */\n    DialogClosedByUser = 'dialog-closed-by-user',\n    /**\n     * An error occurred within the Tableau Extensions API. Contact Tableau Support.\n     */\n    InternalError = 'internal-error',\n    /**\n     * A dialog must start on the same domain as the parent extenion.\n     */\n    InvalidDomainDialog = 'invalid-dialog-domain',\n    /**\n     * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.\n     */\n    InvalidParameter = 'invalid-parameter',\n    /**\n     * Can occur if the extension interacts with a filter that has been removed from the worksheet.\n     */\n    MissingFilter = 'missing-filter',\n    /**\n     * Can occur if the extension interacts with a parameter that has been removed from the worksheet.\n     */\n    MissingParameter = 'missing-parameter',\n    /**\n     * Internal Server Error\n     */\n    ServerError = 'server-error',\n    /**\n     * Developer cannot save settings while another save is still in progress.\n     */\n    SettingSaveInProgress = 'setting-save-in-progress',\n    /**\n     * An unknown event name was specified in the call to `addEventListener` or `removeEventListener`.\n     */\n    UnsupportedEventName = 'unsupported-event-name',\n    /**\n     * A method was used for a type of data source that doesn't support that method (see getActiveTablesAsync for an example)\n     */\n    UnsupportedMethodForDataSourceType = 'unsupported-method-for-data-source-type',\n  }\n\n  /**\n   * The context in which the Extensions is currently running.\n   */\n  export enum ExtensionContext {\n    Desktop = 'desktop',\n    Server = 'server',\n  }\n\n  /**\n   * The mode in which the Extensions is currently running.\n   */\n  export enum ExtensionMode {\n    Authoring = 'authoring',\n    Viewing = 'viewing',\n  }\n\n  /**\n   * Represents the type of event that can be listened for.\n   */\n  export enum TableauEventType {\n    /** Raised when any filter has changed state. You can use this event type with [Worksheet](../interfaces/worksheet.html) objects.*/\n    FilterChanged = 'filter-changed',\n\n    /** The selected marks on a visualization has changed.\n     * You can use this event type with [Worksheet](../interfaces/worksheet.html) objects. */\n    MarkSelectionChanged = 'mark-selection-changed',\n\n    /** The summary data backing a worksheet has changed\n     * You can use this event type with [Worksheet](../interfaces/worksheet.html) objects.*/\n    SummaryDataChanged = 'summary-data-changed',\n\n    /** A parameter has had its value modified. You can use this event type with [[Parameter]] objects. */\n    ParameterChanged = 'parameter-changed',\n\n    /** Settings have been changed for this extension. You can use this event type with [[Settings]] objects. */\n    SettingsChanged = 'settings-changed',\n\n    /** The dashboard layout has changed\n     * @category Dashboard Extensions\n     */\n    DashboardLayoutChanged = 'dashboard-layout-changed',\n\n    /** The workbook formatting has changed\n     * @category Dashboard Extensions\n     */\n    WorkbookFormattingChanged = 'workbook-formatting-changed',\n  }\n\n  /**\n   * Enum that represents the data type of encodings for createVizImageAsync.\n   * @since 1.6.0\n   */\n  export enum VizImageEncodingType {\n    Discrete = 'discrete',\n    Continuous = 'continuous',\n  }\n\n  /**\n   * Enum that represents the sort direction for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImageSortDirectionType {\n    Ascending = 'ascending',\n    Descending = 'descending',\n  }\n\n  /**\n   * Enum that represents the palette type for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImagePaletteType {\n    CustomDiverging = 'custom-diverging',\n    CustomSequential = 'custom-sequential',\n  }\n\n  /**\n   * Enum that represents the Size Setting type for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImageSizeSettingType {\n    Fixed = 'fixed',\n    Manual = 'manual',\n  }\n\n  /**\n   * Enum that represents the Size Setting alignment type for createVizImageAsync.\n   * @since 1.8.0 and Tableau 2021.4\n   */\n  export enum VizImageSizeSettingAlignmentType {\n    Right = 'right',\n    Left = 'left',\n    Center = 'center',\n  }\n}\nexport = Tableau;\n","export enum SharedErrorCodes {\n  /**\n   * A CSV or Excel file failed to be created in Viz.exportCrosstabAsync().\n   */\n  CrosstabCreationError = 'crosstab-creation-error',\n  /**\n   * A CSV file failed to be created in Viz.exportDataAsync().\n   */\n  DataCreationError = 'data-creation-error',\n  /**\n   * An invalid aggregation was specified for the filter, such as setting a range filter to \"SUM(Sales)\" instead of\n   * \"Sales\".\n   */\n  InvalidAggregationFieldName = 'invalid-aggregation-field-name',\n  /**\n   * A filter operation was attempted on a field that does not exist in the data source.\n   */\n  InvalidFilterFieldName = 'invalid-filter-name',\n  /**\n   * A filter operation was attempted using a value that is the wrong data type or format.\n   */\n  InvalidFilterFieldValue = 'invalid-filter-fieldValue',\n  /**\n   * An invalid date value was specified in a Sheet.selectMarksAsync() call for a date field.\n   */\n  InvalidSelectionDate = 'invalid-selection-date',\n  /**\n   * A field was specified in a Sheet.selectMarksAsync() call that does not exist in the data source.\n   */\n  InvalidSelectionFieldName = 'invalid-selection-fieldName',\n  /**\n   * An invalid value was specified in a Sheet.selectMarksAsync() call.\n   */\n  InvalidSelectionValue = 'invalid-selection-value',\n  /**\n   * A parameter did not include a valid sheet selection for exporting.\n   */\n  InvalidSelectionSheet = 'invalid-selection-sheet',\n  /**\n   * An error occurred within the Tableau API. Contact Tableau Support.\n   */\n  InternalError = 'internal-error',\n  /**\n   * A parameter is not the correct data type or format. The name of the parameter is specified in the Error.message field.\n   */\n  InvalidParameter = 'invalid-parameter',\n  /**\n   * A PDF file failed to be created in Viz.exportPDFAsync().\n   */\n  PDFCreationError = 'pdf-creation-error',\n  /**\n   * A PowerPoint file failed to be created in Viz.exportPowerPointAsync().\n   */\n  PowerPointCreationError = 'powerpoint-creation-error',\n  /**\n   * An operation was attempted on a sheet that is not active or embedded within the active dashboard.\n   */\n  NotActiveSheet = 'not-active-sheet',\n  /**\n   * Property or Function is not supported within the Tableau API.\n   */\n  ImplementationError = 'wrong-implementation',\n  /**\n   * Can occur when two incompatible calls are triggered together.\n   */\n  ApiExecutionError = 'api-execution-error',\n  /**\n   * A general-purpose server error occurred. Details are contained in the Error object.\n   */\n  ServerError = 'server-error',\n  /**\n   * Can occur when an api call times out.\n   */\n  Timeout = 'timeout',\n}\n","/**\n * The tableau namespace exists for organization and to avoid polluting\n * the global namespace. It contains no constructs other than sub-namespaces and the Tableau enumerations.\n */\nnamespace Tableau {\n  export enum AnalyticsObjectType {\n    Cluster = 'cluster',\n    Forecast = 'forecast',\n    TrendLine = 'trend-line',\n  }\n\n  export enum AnnotationType {\n    Mark = 'mark',\n    Point = 'point',\n    Area = 'area',\n  }\n\n  export enum ColumnType {\n    Discrete = 'discrete',\n    Continuous = 'continuous',\n    Unknown = 'unknown',\n  }\n\n  export enum ClassNameKey {\n    WorksheetTitle = 'tableau-worksheet-title',\n    Worksheet = 'tableau-worksheet',\n    Tooltip = 'tableau-tooltip',\n    StoryTitle = 'tableau-story-title',\n    DashboardTitle = 'tableau-dashboard-title',\n  }\n\n  /**\n   * What the object represents in a dashboard.\n   */\n  export enum DashboardObjectType {\n    Blank = 'blank',\n    Worksheet = 'worksheet',\n    QuickFilter = 'quick-filter',\n    ParameterControl = 'parameter-control',\n    PageFilter = 'page-filter',\n    Legend = 'legend',\n    Title = 'title',\n    Text = 'text',\n    Image = 'image',\n    WebPage = 'web-page',\n    Extension = 'extension',\n  }\n\n  /**\n   * Enum that represents the visibility state of a dashboard object.\n   * @since 1.7.0\n   */\n  export enum DashboardObjectVisibilityType {\n    /** Used for turning on the visibility of a dashboard object.*/\n    Show = 'show',\n\n    /** Used for turning off the visibility of a dashboard object.*/\n    Hide = 'hide',\n  }\n\n  /**\n   * The different types of data a value can have\n   */\n  export enum DataType {\n    String = 'string',\n    Int = 'int',\n    Float = 'float',\n    Bool = 'bool',\n    Date = 'date',\n    DateTime = 'date-time',\n    Spatial = 'spatial',\n    Unknown = 'unknown',\n  }\n\n  /**\n   * Enum that represents the changes that occur to a dashboard object.\n   */\n  export enum DashboardLayoutChange {\n    /** A dashboard object was added */\n    Added = 'added',\n\n    /** A dashboard object was removed */\n    Removed = 'removed',\n\n    /** A dashboard object's floating state changed */\n    IsFloatingChanged = 'is-floating-changed',\n\n    /** A dashboard object's visibility changed */\n    IsVisibleChanged = 'is-visible-changed',\n\n    /** A dashboard object's position changed */\n    PositionChanged = 'position-changed',\n\n    /** A dashboard object's size changed */\n    SizeChanged = 'size-changed',\n\n    /** A dashboard object was renamed */\n    NameChanged = 'name-changed',\n\n    /** A dashboard object is selected */\n    Selected = 'selected',\n\n    /** A dashboard object is deselected */\n    Deselected = 'deselected',\n\n    /** Navigate to another dashboard */\n    DashboardChanged = 'dashboard-changed',\n  }\n\n  /**\n   * Valid date ranges for a relative date filter.\n   */\n  export enum DateRangeType {\n    Last = 'last',\n    LastN = 'last-n',\n    Next = 'next',\n    NextN = 'next-n',\n    Current = 'current',\n    ToDate = 'to-date',\n  }\n\n  /**\n   * Enum that represents the types of dialog popup styles.\n   */\n  export enum DialogStyle {\n    Window = 'window',\n    Modal = 'modal',\n    Modeless = 'modeless',\n  }\n\n  export enum EncodingType {\n    Column = 'column',\n    Row = 'row',\n    Page = 'page',\n    Filter = 'filter',\n    MarksType = 'marks-type',\n    MeasureValues = 'measure-values',\n    Color = 'color',\n    Size = 'size',\n    Label = 'label',\n    Detail = 'detail',\n    Tooltip = 'tooltip',\n    Shape = 'shape',\n    Path = 'path',\n    Angle = 'angle',\n    Geometry = 'geometry',\n    Custom = 'custom',\n  }\n\n  /**\n   *  Type of aggregation on a field.\n   */\n  export enum FieldAggregationType {\n    Sum = 'sum',\n    Avg = 'avg',\n    Min = 'min',\n    Max = 'max',\n    Stdev = 'stdev',\n    Stdevp = 'stdevp',\n    Var = 'var',\n    Varp = 'varp',\n    Collect = 'collect',\n    Count = 'count',\n    Countd = 'countd',\n    Median = 'median',\n    Attr = 'attr',\n    None = 'none',\n    Year = 'year',\n    Qtr = 'qtr',\n    Month = 'month',\n    Day = 'day',\n    Hour = 'hour',\n    Minute = 'minute',\n    Second = 'second',\n    Week = 'week',\n    Weekday = 'weekday',\n    MonthYear = 'month-year',\n    Mdy = 'mdy',\n    End = 'end',\n    TruncYear = 'trunc-year',\n    TruncQtr = 'trunc-qtr',\n    TruncMonth = 'trunc-month',\n    TruncWeek = 'trunc-week',\n    TruncDay = 'trunc-day',\n    TruncHour = 'trunc-hour',\n    TruncMinute = 'trunc-minute',\n    TruncSecond = 'trunc-second',\n    Quart1 = 'quart1',\n    Quart3 = 'quart3',\n    Skewness = 'skewness',\n    Kurtosis = 'kurtosis',\n    InOut = 'in-out',\n    User = 'user',\n  }\n\n  /**\n   * Role of a field.\n   */\n  export enum FieldRoleType {\n    Dimension = 'dimension',\n    Measure = 'measure',\n    Unknown = 'unknown',\n  }\n\n  /**\n   * An enumeration of the valid types of filters that can be applied.\n   */\n  export enum FilterType {\n    Categorical = 'categorical',\n    Range = 'range',\n    Hierarchical = 'hierarchical',\n    RelativeDate = 'relative-date',\n  }\n\n  /**\n   * The different update types for applying filter\n   */\n  export enum FilterUpdateType {\n    Add = 'add',\n    All = 'all',\n    Replace = 'replace',\n    Remove = 'remove',\n  }\n\n  /**\n   * The domain type for a filter\n   */\n  export enum FilterDomainType {\n    /**\n     * The domain values that are relevant to the specified filter\n     * i.e. the domain is restricted by a previous filter\n     */\n    Relevant = 'relevant',\n    /**\n     * list of all possible domain values from database\n     */\n    Database = 'database',\n  }\n\n  /**\n   * The option for specifying which values to include for filtering\n   * Indicates what to do with null values for a given filter or mark selection call.\n   */\n  export enum FilterNullOption {\n    NullValues = 'null-values',\n    NonNullValues = 'non-null-values',\n    AllValues = 'all-values',\n  }\n\n  /**\n   * Enum that serves as a filter on the DataValues returned from `getSummaryDataReaderAsync`,\n   * `getUnderlyingTableDataReaderAsync` and `getLogicalTableDataReaderAsync`.\n   * This is an optimization of returned data values only. Tableau versions prior to 2021.2\n   * will pass the data across and populate the DataValue properties.\n   * Please note that all properties not requested will be `undefined` in the DataValue results.\n   * @since 1.5.0\n   */\n  export enum IncludeDataValuesOption {\n    /** DataValues will include all properties.*/\n    AllValues = 'all-values',\n\n    /** DataValues will only include value and nativeValue properties.*/\n    OnlyNativeValues = 'only-native-values',\n\n    /** DataValues will only include formattedValue properties. */\n    OnlyFormattedValues = 'only-formatted-values',\n  }\n\n  /**\n   * Type of mark for a given marks card in a viz.\n   */\n  export enum MarkType {\n    Bar = 'bar',\n    Line = 'line',\n    Area = 'area',\n    Square = 'square',\n    Circle = 'circle',\n    Shape = 'shape',\n    Text = 'text',\n    Map = 'map',\n    Pie = 'pie',\n    GanttBar = 'gantt-bar',\n    Polygon = 'polygon',\n    Heatmap = 'heatmap',\n    VizExtension = 'viz-extension',\n  }\n\n  /**\n   * An enumeration describing the different types of allowable values.\n   * This is used for restricting the domain of a parameter\n   */\n  export enum ParameterValueType {\n    All = 'all',\n    List = 'list',\n    Range = 'range',\n  }\n\n  /**\n   * Date period used in filters and in parameters.\n   */\n  export enum PeriodType {\n    Years = 'years',\n    Quarters = 'quarters',\n    Months = 'months',\n    Weeks = 'weeks',\n    Days = 'days',\n    Hours = 'hours',\n    Minutes = 'minutes',\n    Seconds = 'seconds',\n  }\n\n  export enum QuickTableCalcType {\n    RunningTotal = 'running-total',\n    Difference = 'difference',\n    PercentDifference = 'percent-difference',\n    PercentOfTotal = 'percent-of-total',\n    Rank = 'rank',\n    Percentile = 'percentile',\n    MovingAverage = 'moving-average',\n    YTDTotal = 'ytd-total',\n    CompoundGrowthRate = 'compound-growth-rate',\n    YearOverYearGrowth = 'year-over-year-growth',\n    YTDGrowth = 'ytd-growth',\n    Undefined = 'undefined',\n  }\n\n  /**\n   * Enum for specifying the selection type for select marks api.\n   */\n  export enum SelectionUpdateType {\n    Replace = 'select-replace',\n    Add = 'select-add',\n    Remove = 'select-remove',\n  }\n\n  /**\n   * Enum for specifying the select option for the `extensions.Worksheet.selectTuplesAsync` method.\n   */\n  export enum SelectOptions {\n    /**\n     * Clears existing selection before selecting the tuples specified\n     */\n    Simple = 'select-options-simple',\n    /**\n     * Adds specified tuples to the existing selection\n     */\n    Toggle = 'select-options-toggle',\n  }\n\n  /**\n   * The type of sheet a [[Sheet]] object represents\n   */\n  export enum SheetType {\n    Dashboard = 'dashboard',\n    Story = 'story',\n    Worksheet = 'worksheet',\n  }\n\n  export enum SortDirection {\n    Increasing = 'increasing',\n    Decreasing = 'decreasing',\n  }\n\n  export enum TrendLineModelType {\n    Linear = 'linear',\n    Logarithmic = 'logarithmic',\n    Exponential = 'exponential',\n    Polynomial = 'polynomial',\n  }\n\n  /**\n   * Enum that represents the replay speed of an animation.\n   * @since 1.7.0\n   */\n  export enum ReplaySpeedType {\n    /** Used for setting the replay speed of an animation to 0.5x.*/\n    Slow = 'slow',\n\n    /** Used for setting the replay speed of an animation to 1.0x.*/\n    Normal = 'normal',\n\n    /** Used for setting the replay speed of an animation to 2.0x.*/\n    Fast = 'fast',\n  }\n\n  /**\n   * Enum that represents the selection state of a level in a hierarchical filter\n   * @since Extensions 1.10.0\n   */\n  export enum HierarchicalLevelSelectionState {\n    AllSelected = 'all-selected',\n    NoneSelected = 'none-selected',\n    SomeSelected = 'some-selected',\n    UnknownSelected = 'unknown-selected',\n  }\n\n  /**\n   * ZoneVisibilityType\n   * @deprecated use DashboardObjectVisibilityType\n   */\n  export declare type ZoneVisibilityType = DashboardObjectVisibilityType;\n  export const ZoneVisibilityType = { ...DashboardObjectVisibilityType };\n}\nexport = Tableau;\n","// This file re-exports everything which is part of the shared api public interface\n\nexport * from './ExternalContract/Shared/AnnotationInterfaces';\nexport * from './ExternalContract/Shared/DataSourceInterfaces';\nexport * from './ExternalContract/Shared/DataTableInterfaces';\nexport * from './ExternalContract/Shared/Enums';\nexport * from './ExternalContract/Shared/EnvironmentInterfaces';\nexport * from './ExternalContract/Shared/FilterInterfaces';\nexport {\n  AnalyticsObjectType,\n  AnnotationType,\n  ClassNameKey,\n  ColumnType,\n  DashboardLayoutChange,\n  DashboardObjectType,\n  DashboardObjectVisibilityType,\n  DataType,\n  DateRangeType,\n  DialogStyle,\n  EncodingType,\n  FieldAggregationType,\n  FieldRoleType,\n  FilterDomainType,\n  FilterNullOption,\n  FilterType,\n  FilterUpdateType,\n  HierarchicalLevelSelectionState,\n  IncludeDataValuesOption,\n  MarkType,\n  ParameterValueType,\n  PeriodType,\n  QuickTableCalcType,\n  ReplaySpeedType,\n  SelectOptions,\n  SelectionUpdateType,\n  SheetType,\n  SortDirection,\n  TrendLineModelType,\n  ZoneVisibilityType,\n} from './ExternalContract/Shared/Namespaces/Tableau';\nexport * from './ExternalContract/Shared/SelectionInterfaces';\nexport * from './ExternalContract/Shared/SheetInterfaces';\nexport * from './ExternalContract/Shared/VisualModelInterface';\nexport * from './ExternalContract/Shared/WorkbookFormattingInterfaces';\n","/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\n\n// The following polyfills are needed for IE11\nimport 'core-js/es/number/is-integer';\nimport 'core-js/es/number/is-nan';\nimport 'core-js/es/object/assign';\n// Export the version of the internal contract to be available at runtime\n//  This file is generated by yarn publish:bump via scripts/publish-check.ts\n//  updateInternalContractRuntimeVersion in the monorepo root.\nimport * as internalContractVersion from '../internal-contract-version.json';\nexport const INTERNAL_CONTRACT_VERSION = internalContractVersion;\n\nexport * from './contract/DataTypeConverter';\nexport * from './contract/Enums';\nexport * from './contract/Models';\nexport * from './contract/Notifications';\nexport * from './contract/Parameters';\nexport * from './contract/Verbs';\nexport * from './interface/AskDataInterface';\nexport * from './interface/InitializationOptions';\nexport * from './interface/InternalApiDispatcher';\nexport * from './interface/PulseInterface';\nexport * from './interface/VersionNumber';\nexport * from './interface/VqlInterface';\nexport * from './messaging/CrossFrameMessenger';\nexport * from './messaging/interface/MessageDispatcher';\nexport * from './messaging/interface/MessageListener';\nexport * from './messaging/interface/MessageTypes';\nexport * from './messaging/interface/Messenger';\nexport * from './messaging/interface/PreparedMessage';\nexport * from './versioning/InternalContractVersionConverter';\nexport * from './versioning/VersionConverterFactory';\nexport * from './versioning/external/ExternalContractVersionConverter';\nexport * from './versioning/external/ExternalIdentityVersionConverter';\nexport * from './versioning/external/ExternalVersionConverterFactory';\n\n// Export the version number of messaging for consumers to use.\n// Be very careful making any updates to this contract which break version compatibility.\nexport const MESSAGING_VERSION = {\n  major: 1,\n  minor: 0,\n  fix: 0,\n};\n","import { DataType } from './Enums';\n\nexport class DataTypeConverter {\n  private static isSpecial(valueAsString: string): boolean {\n    // Prior to ShowDataTablePresModel, special values come to us as\n    // '%null%', '%all%', '%wildcard%', '%missing%'...\n    // While this function will never return true for ShowDataTablePresModel conversion,\n    // it is as cheap as passing around a version and checking that.\n    // (See DataValueFormatter.cpp)\n\n    if (valueAsString.length > 2 && valueAsString[0] === '%' && valueAsString[valueAsString.length - 1] === '%') {\n      return true;\n    }\n    return false;\n  }\n\n  private static specialValueIndicator = '%null%';\n\n  // tslint:disable-next-line:no-any\n  private static parseBoolean(booleanString: string): boolean | string {\n    // boolean values come to us as 'true'|'false'\n    const normalizedBoolean: string = booleanString.toLowerCase();\n    return normalizedBoolean !== 'true' && normalizedBoolean !== 'false' ? this.specialValueIndicator : normalizedBoolean === 'true';\n  }\n\n  // tslint:disable-next-line:no-any\n  private static parseNumber(valueAsString: string): number | string {\n    const value = Number(valueAsString);\n    return isNaN(value) ? this.specialValueIndicator : value;\n  }\n\n  private static parseDate(dateAsString: string): Date | null {\n    // Note that without a time, the date is assumed to be UTC\n    // Input of 2020-03-25 is printed as: Mar 24 2020 17:00:00 GMT-0700\n    // This matches style used in existing convertFilterValuePresModel\n    const value = new Date(dateAsString);\n    return Number.isNaN(value.getTime()) ? null : value;\n  }\n\n  private static parseDateTime(dateAsString: string): Date | null {\n    // With a time, the date is assumed to be UTC.\n    // Our date format is always: yyyy-mm-dd hh:mm:ss\n    // Unfortunately, IE11 can't parse that format so we add a T between the day and time.\n    // We also add a Z so that it is UTC. (Without the Z, some browsers assume local, and others UTC)\n    const formattedDateString: string = dateAsString.replace(' ', 'T').concat('Z');\n    const value = new Date(formattedDateString);\n    return Number.isNaN(value.getTime()) ? null : value;\n  }\n\n  // It would be nice to merge this and the method FilterConverter::convertFilterValuePresModel in api-platform-js\n  public static convertValueAsStringToValue(valueAsString: string, type: DataType): boolean | number | string | undefined {\n    // This is both DataDictionary and ShowDataTablePresModel compatible.\n    // In the DataDictionary, valueAsString can be '%null%' or '%missing%', while in\n    // ShowDataTablePresModel, we can get 'null' or 'missing', or '%null%' for string special values.\n    // For either of these cases, we return specialValueIndicator (or the original special string).\n    // To maintain backwards compatibilty, this converter:\n    // 1. returns a string for any special values\n    // 2. returns a string for any date\n\n    // Parameter min/max values can be undefined, so result is also undefined\n    if (valueAsString === undefined || valueAsString === null) {\n      return undefined;\n    }\n\n    if (this.isSpecial(valueAsString)) {\n      return valueAsString;\n    }\n\n    switch (type) {\n      case DataType.Bool:\n        return this.parseBoolean(valueAsString);\n\n      case DataType.Int:\n      case DataType.Float:\n        // Return special value '%null%' for any failure in parsing.\n        // We need to do that because ShowDataTablePresModel will give us strings like 'null'\n        // for special values.\n        return this.parseNumber(valueAsString);\n\n      case DataType.Date:\n        // For ShowDataTablePresModel, special values will be \"null\" which will fail to parse.\n        // In that case, we return '%null%'.\n        return this.parseDate(valueAsString) === null ? this.specialValueIndicator : valueAsString;\n\n      case DataType.DateTime:\n        // For ShowDataTablePresModel, special values will be \"null\" which will fail to parse.\n        // In that case, we return '%null%'\n        return this.parseDateTime(valueAsString) === null ? this.specialValueIndicator : valueAsString;\n\n      case DataType.Spatial:\n      case DataType.String:\n      default:\n        return valueAsString;\n    }\n  }\n\n  // tslint:disable-next-line:no-any\n  public static convertValueToNativeValue(value: any, type: DataType): boolean | number | Date | string | null {\n    // This converts from our 1.2 API that returns strings for specials, and dates as strings.\n    // It takes the special case of '%null%' and returns a null.\n    // For dates, it returns a Date object rather than a string.\n    // convertValueToNativeValue should be used to build a DataValue.nativeValue field.\n\n    // Parameter min/max can be undefined. If that is the case, nativeValue is treated like a special\n    if (value === undefined || value === null) {\n      return null;\n    }\n\n    switch (type) {\n      case DataType.Bool:\n        return typeof value === 'string' ? null : value;\n\n      case DataType.Int:\n      case DataType.Float:\n        return typeof value === 'string' ? null : value;\n\n      case DataType.Date:\n        // Convert the string to Date object (or null if parsing fails ... we assume special)\n        return this.parseDate(value);\n\n      case DataType.DateTime:\n        // Convert the string to Date object (or null if parsing fails ... we assume special)\n        return this.parseDateTime(value);\n\n      case DataType.String:\n        return this.isSpecial(value) ? null : value;\n\n      case DataType.Spatial:\n      default:\n        return value;\n    }\n  }\n\n  // tslint:disable-next-line:no-any\n  public static convertStringValueToNativeValue(value: string, type: DataType): boolean | number | Date | string | null {\n    // This handles the conversion from string directly to native value for all types\n    return this.convertValueToNativeValue(this.convertValueAsStringToValue(value, type), type);\n  }\n}\n","export enum ExtensionContext {\n  Desktop = 'desktop',\n  Server = 'server',\n  Unknown = 'unknown',\n}\n\nexport enum ExtensionMode {\n  Authoring = 'authoring',\n  Viewing = 'viewing',\n  Unknown = 'unknown',\n}\n\nexport enum AnnotateEnum {\n  Mark = 'mark',\n  Point = 'point',\n  Area = 'area',\n}\n\nexport enum ColumnType {\n  Discrete = 'discrete',\n  Continuous = 'continuous',\n  Unknown = 'unknown',\n}\n\nexport enum DashboardObjectType {\n  Blank = 'blank',\n  Worksheet = 'worksheet',\n  QuickFilter = 'quick-filter',\n  ParameterControl = 'parameter-control',\n  PageFilter = 'page-filter',\n  Legend = 'legend',\n  Title = 'title',\n  Text = 'text',\n  Image = 'image',\n  WebPage = 'web-page',\n  Extension = 'extension',\n}\n\nexport enum DataType {\n  String = 'string',\n  Int = 'int',\n  Float = 'float',\n  Bool = 'bool',\n  Date = 'date',\n  DateTime = 'date-time',\n  Spatial = 'spatial',\n  Unknown = 'unknown',\n}\n\nexport enum DialogStyle {\n  Window = 'window',\n  Modal = 'modal',\n  Modeless = 'modeless',\n}\n\nexport enum EncodedDataType {\n  Number = 'number',\n  String = 'string',\n  Date = 'date',\n  Boolean = 'boolean',\n}\n\nexport enum ErrorCodes {\n  INITIALIZATION_ERROR = 'initialization-error',\n  INTERNAL_ERROR = 'internal-error',\n  MISSING_ENUM_MAPPING = 'missing-enum-mapping',\n  MISSING_PARAMETER = 'missing-parameter',\n  PERMISSION_DENIED = 'permission-denied',\n  PRES_MODEL_PARSING_ERROR = 'pres-model-parsing-error',\n  VERSION_NOT_CONFIGURED = 'version-not-configured',\n  VISIBILITY_ERROR = 'visibility-error',\n  UNKNOWN_VERB_ID = 'unknown-verb-id',\n}\n\nexport enum FieldAggregationType {\n  Sum = 'sum',\n  Avg = 'avg',\n  Min = 'min',\n  Max = 'max',\n  Stdev = 'stdev',\n  Stdevp = 'stdevp',\n  Var = 'var',\n  Varp = 'varp',\n  Collect = 'collect',\n  Count = 'count',\n  Countd = 'countd',\n  Median = 'median',\n  Attr = 'attr',\n  None = 'none',\n  Year = 'year',\n  Qtr = 'qtr',\n  Month = 'month',\n  Day = 'day',\n  Hour = 'hour',\n  Minute = 'minute',\n  Second = 'second',\n  Week = 'week',\n  Weekday = 'weekday',\n  MonthYear = 'month-year',\n  Mdy = 'mdy',\n  End = 'end',\n  TruncYear = 'trunc-year',\n  TruncQtr = 'trunc-qtr',\n  TruncMonth = 'trunc-month',\n  TruncWeek = 'trunc-week',\n  TruncDay = 'trunc-day',\n  TruncHour = 'trunc-hour',\n  TruncMinute = 'trunc-minute',\n  TruncSecond = 'trunc-second',\n  Quart1 = 'quart1',\n  Quart3 = 'quart3',\n  Skewness = 'skewness',\n  Kurtosis = 'kurtosis',\n  InOut = 'in-out',\n  User = 'user',\n}\n\nexport enum FieldRoleType {\n  Dimension = 'dimension',\n  Measure = 'measure',\n  Unknown = 'unknown',\n}\n\n/**\n *  The different update types for applying filter.\n */\nexport enum FilterUpdateType {\n  Add = 'add',\n  All = 'all',\n  Replace = 'replace',\n  Remove = 'remove',\n}\n\nexport enum SheetType {\n  Dashboard = 'dashboard',\n  Story = 'story',\n  Worksheet = 'worksheet',\n}\n\nexport enum DomainRestrictionType {\n  All = 'all',\n  List = 'list',\n  Range = 'range',\n}\n\nexport enum DateStepPeriod {\n  Years = 'years',\n  Quarters = 'quarters',\n  Months = 'months',\n  Weeks = 'weeks',\n  Days = 'days',\n  Hours = 'hours',\n  Minutes = 'minutes',\n  Seconds = 'seconds',\n}\n\n/**\n * The option for specifying which values to include for filtering.\n */\nexport enum FilterNullOption {\n  NullValues = 'nullvalues',\n  NonNullValues = 'nonnullvalues',\n  AllValues = 'allvalues',\n}\n\n/**\n * The type of filter domain\n */\nexport enum FilterDomainType {\n  Relevant = 'relevant',\n  Database = 'database',\n}\n\n/**\n * Internal enum for specifying the selection type for select marks api.\n */\nexport enum SelectionUpdateType {\n  Replace = 'select-replace',\n  Add = 'select-add',\n  Remove = 'select-remove',\n}\n\n/**\n * Internal enum for specifying the select option for the select tuples api.\n */\nexport enum SelectOptions {\n  Simple = 'select-options-simple',\n  Toggle = 'select-options-toggle',\n  Menu = 'select-options-menu', // not implemented in the external contract\n  Range = 'select-options-range', // not implemented in the external contract\n  Search = 'select-options-search', // not implemented in the external contract\n}\n\n/**\n * Internal enum for specifying the included values type for range selection.\n */\nexport enum QuantitativeIncludedValues {\n  IncludeNull = 'include-null',\n  IncludeNonNull = 'include-non-null',\n  IncludeAll = 'include-all',\n}\n\n/**\n * Internal enum for specifying a hierarchical level selection state.\n */\nexport enum HierarchicalLevelSelectionState {\n  AllSelected = 'all-selected',\n  NoneSelected = 'none-selected',\n  SomeSelected = 'some-selected',\n  UnknownSelected = 'unknown-selected',\n}\n\n/**\n * Type of mark for a given marks card in a viz.\n */\nexport enum MarkType {\n  Bar = 'bar',\n  Line = 'line',\n  Area = 'area',\n  Square = 'square',\n  Circle = 'circle',\n  Shape = 'shape',\n  Text = 'text',\n  Map = 'map',\n  Pie = 'pie',\n  GanttBar = 'gantt-bar',\n  Polygon = 'polygon',\n  Heatmap = 'heatmap',\n  VizExtension = 'viz-extension',\n}\n\n/**\n * Internal enum for specifying the type of filter\n */\nexport enum FilterType {\n  Categorical = 'categorical',\n  Range = 'range',\n  RelativeDate = 'relativeDate',\n  Hierarchical = 'hierarchical',\n}\n\n/**\n * Internal enum for specifying the DateRangeType of a relative date filter\n */\nexport enum DateRangeType {\n  /**\n   * Refers to the last day, week, month, etc. of the date period.\n   */\n  Last = 'last',\n  /**\n   * Refers to the last N days, weeks, months, etc. of the date period.\n   */\n  LastN = 'lastN',\n  /**\n   * Refers to the next day, week, month, etc. of the date period.\n   */\n  Next = 'next',\n  /**\n   * Refers to the next N days, weeks, months, etc. of the date period.\n   */\n  NextN = 'nextN',\n  /**\n   * Refers to the current day, week, month, etc. of the date period.\n   */\n  Current = 'current',\n  /**\n   * Refers to everything up to and including the current day, week, month, etc. of the date period.\n   */\n  ToDate = 'toDate',\n}\n\n/**\n * Used to determine if the launching of an extension dialog succeeded or failed.\n */\nexport enum ExtensionDialogResult {\n  DialogAlreadyOpen = 'dialog-already-open',\n  InvalidDomain = 'invalid-domain',\n  Success = 'success',\n}\n\n// Enumeration for ApiShowData table id sentinels.\nexport enum ApiShowDataTableSentinel {\n  // find the one logical table - used in version compatibility check for getUnderlyingDataTable and getLogicalDataTable commands\n  SingleTableId = 'single-table-id-sentinel',\n  SingleTableCaption = 'Single table id sentinel',\n}\n\n/**\n * Used to optimize the getSummaryData/getUnderlyingTableData results\n * Mapped from external IncludeDataValuesOption\n */\nexport enum ApiShowDataTableFormat {\n  NativeValuesOnly = 'native-values-only',\n  FormattedValuesOnly = 'formatted-values-only',\n  NativeAndFormattedValues = 'native-and-formatted-values',\n}\n\n/**\n * Used to denote the sections of formatting within tableau\n */\nexport const enum ClassNameKey {\n  WorksheetTitle = 'tableau-worksheet-title',\n  Worksheet = 'tableau-worksheet',\n  Tooltip = 'tableau-tooltip',\n  StoryTitle = 'tableau-story-title',\n  DashboardTitle = 'tableau-dashboard-title',\n}\n\n/**\n * Used to set page size for export layout options.\n */\nexport enum PageSizeOption {\n  Letter = 'letter',\n  Legal = 'legal',\n  Note = 'note',\n  Folio = 'folio',\n  Tabloid = 'tabloid',\n  Ledger = 'ledger',\n  Statement = 'statement',\n  Executive = 'executive',\n  A3 = 'a3',\n  A4 = 'a4',\n  A5 = 'a5',\n  B4 = 'b4',\n  B5 = 'b5',\n  Quarto = 'quarto',\n  Unspecified = 'unspecified',\n}\n\n/**\n * Used to set the page orientation mode for export layout options.\n */\nexport enum PageOrientation {\n  Printer = 'printer',\n  Portrait = 'portrait',\n  Landscape = 'landscape',\n}\n\n/**\n * Used to set scale mode for export layout options.\n */\nexport enum ScaleMode {\n  ScaleAuto = 'auto',\n  ScalePercentage = 'percent',\n  ScaleFitPages = 'fit-pages',\n}\n\n/**\n * Used by setFitAndScaleValues to scale percent values\n */\nexport enum PageScalingOption {\n  ScalePctAuto = 'auto',\n  ScalePct400 = 'pct400',\n  ScalePct200 = 'pct200',\n  ScalePct100 = 'pct100',\n  ScalePct90 = 'pct90',\n  ScalePct80 = 'pct80',\n  ScalePct75 = 'pct75',\n  ScalePct60 = 'pct60',\n  ScalePct50 = 'pct50',\n  ScalePct25 = 'pct25',\n}\n\n/**\n * Used by setFitAndScaleValues to scale fit page values\n */\nexport enum FitPages {\n  FitOneHigh = 'fit0x1',\n  FitTwoHigh = 'fit0x2',\n  FitOneWide = 'fit1x0',\n  FitTwoWide = 'fit2x0',\n}\n\n/**\n * Used by getVisualSpecificationAsync\n */\nexport enum EncodingType {\n  Color = 'color',\n  Size = 'size',\n  Label = 'label',\n  Detail = 'detail',\n  Tooltip = 'tooltip',\n  Shape = 'shape',\n  Path = 'path',\n  Angle = 'angle',\n  Geometry = 'geometry',\n  Custom = 'custom',\n}\n","export enum NotificationId {\n  CustomMarkContextMenuClicked = 'custom-mark-context-menu-clicked',\n  ContextMenuClick = 'context-menu-click',\n  CustomViewRemoved = 'custom-view-removed',\n  CustomViewSaved = 'custom-view-saved',\n  CustomViewSetDefault = 'custom-view-set-default',\n  CustomViewsLoaded = 'custom-views-loaded',\n  DashboardLayoutChanged = 'dashboard-layout-changed',\n  EditButtonClicked = 'edit-button-clicked',\n  EditInDesktopButtonClicked = 'edit-in-desktop-button-clicked',\n  ExtensionDialogUpdate = 'extension-dialog-update',\n  FilterChanged = 'filter-changed',\n  FirstVizSizeKnown = 'first-viz-size-known',\n  ParameterChanged = 'parameter-changed',\n  SelectedMarksChanged = 'selected-marks-changed',\n  SettingsChanged = 'settings-changed',\n  SummaryDataChanged = 'summary-data-changed',\n  TestConversionNotification = 'test-conversion-notification',\n  ToolbarStateChanged = 'toolbar-state-changed',\n  VizInteractive = 'viz-interactive',\n  AskDataInteractive = 'ask-data-interactive',\n  WorkbookReadyToClose = 'workbook-ready-to-close',\n  WorkbookFormattingChanged = 'workbook-formatting-changed',\n  WorkbookPublished = 'workbook-published',\n  WorkbookPublishedAs = 'workbook-published-as',\n  UrlAction = 'url-action',\n  TabSwitched = 'tab-switched',\n  StoryPointSwitched = 'story-point-switched',\n  ReadyToReceiveAuthToken = 'ready-to-receive-auth-token',\n}\n","// PLEASE KEEP IN ALPHABETICAL ORDER. This helps with visually finding entries, knowing where to put\n// new ones, and merge conflicts.\nexport enum ParameterId {\n  ActiveTablesInfo = 'active-tables-info',\n  AnchorDate = 'anchor-date',\n  AnnotateEnum = 'annotate-enum',\n  AnnotationList = 'annotation-list',\n\n  CategoricalDomain = 'categorical-domain',\n  ClickThroughEnabled = 'click-through-enabled',\n  ColumnsToInclude = 'columns-to-include',\n  ColumnsToIncludeById = 'columns-to-include-by-id',\n  ConnectionDescriptionSummaries = 'connection-description-summaries',\n  CurrentSheetType = 'current-sheet-type',\n  CustomView = 'custom-view',\n  CustomViewIsDefault = 'custom-view-is-default',\n  CustomViewIsPublic = 'custom-view-is-public',\n  CustomViewLuid = 'custom-view-luid',\n  CustomViewName = 'custom-view-name',\n  CustomViews = 'custom-views',\n\n  Dashboard = 'dashboard',\n  DashboardFilters = 'dashboard-filters',\n  DashboardName = 'dashboard',\n  DashboardObjectPositionAndSizeUpdate = 'dashboard-object-position-and-size-update',\n  DashboardObjectPositionAndSizeUpdateList = 'dashboard-object-position-and-size-update-list',\n  DataRowIndex = 'data-row-index',\n  DataSchema = 'data-schema',\n  DataSource = 'data-source',\n  DataSourceDataTable = 'data-source-data-table',\n  DataSourceId = 'data-source-id',\n  DataSourceName = 'data-source-name',\n  DataTable = 'data-table',\n  DataTableReader = 'data-table-reader',\n  DateRangeType = 'date-range-type',\n  DeltaTimeMs = 'delta-time-ms',\n  DimValSelectionModels = 'dimensionValueSelectionModels',\n  DomainType = 'domain-type',\n\n  EmbeddingAbstractQuery = 'embedding-abstract-query',\n  EmbeddingBootstrapInfo = 'embedding-bootstrap-info',\n  ExportCrosstabSheetMap = 'export-crosstab-sheet-map',\n  ExportFile = 'export-file',\n  ExportOriginUrl = 'export-origin-url',\n  ExportPdfOptions = 'export-pdf-options',\n  ExtensionBootstrapInfo = 'extension-bootstrap-info',\n  ExtensionContextMenuIds = 'extension-context-menu-ids',\n  ExtensionDialogH = 'extension-dialog-height',\n  ExtensionDialogPayload = 'extension-dialog-payload',\n  ExtensionDialogResult = 'extension-dialog-result',\n  ExtensionDialogStyle = 'extension-dialog-style',\n  ExtensionDialogUrl = 'extension-dialog-url',\n  ExtensionDialogW = 'extension-dialog-width',\n  ExtensionLocator = 'extension-locator',\n  ExtensionSettingsInfo = 'extension-settings-info',\n  ExtensionZoneId = 'extension-zone-id',\n  ExternalMenuDescription = 'external-menu-description',\n  ExternalMenuHeader = 'external-menu-header',\n  ExternalMenuItemDisplayName = 'external-menu-item-display-name',\n  ExternalMenuItemId = 'external-menu-item-id',\n\n  Field = 'field',\n  FieldId = 'field-id',\n  FieldName = 'field-name',\n  FilterLevels = 'filter-levels',\n  FilterRangeMax = 'filter-range-max',\n  FilterRangeMin = 'filter-range-min',\n  FilterRangeNullOption = 'filter-range-null-option',\n  FilterUpdateType = 'filter-update-type',\n  FilterValues = 'filter-values',\n  FontNameListItems = 'font-name-list-items',\n  FormattedText = 'formatted-text',\n  FunctionName = 'function-name',\n\n  HierValSelectionModels = 'hierarchicalValueSelectionModels',\n  HighlightedData = 'highlighted-data',\n  HoverTupleInteraction = 'hover-tuple-interaction',\n\n  IgnoreAliases = 'ignore-aliases',\n  IgnoreSelection = 'ignore-selection',\n  IncludeAllColumns = 'include-all-columns',\n  InvalidAggFieldName = 'invalid-agg-field-name',\n  InvalidDates = 'invalid-dates',\n  InvalidFieldCaption = 'invalid-field-caption',\n  InvalidFields = 'invalid-fields',\n  InvalidValues = 'invalid-values',\n  IsExcludeMode = 'is-exclude',\n  IsExtensionDialog = 'is-extension-dialog',\n\n  JoinDescription = 'join-description',\n\n  LogicalTableId = 'logical-table-id',\n  LogicalTableInfoList = 'logical-table-info-list',\n\n  MaxHeight = 'max-height',\n  MaxRows = 'max-rows',\n  MaxWidth = 'max-width',\n  MinHeight = 'min-height',\n  MinWidth = 'min-width',\n\n  PageRowCount = 'page-row-count',\n  ParameterCaption = 'paremeter-caption',\n  ParameterError = 'parameter-error',\n  ParameterFieldName = 'parameter-field-name',\n  ParameterInfo = 'parameter-info',\n  ParameterInfos = 'parameter-infos',\n  ParameterValue = 'parameter-value',\n  PeriodType = 'period-type',\n\n  QuantitativeDomain = 'quantitative-dmain',\n  QuantRangeSelectionModels = 'quantativeRangeSelectionModels',\n\n  RangeN = 'range-n',\n  ReplaySpeed = 'replay-speed',\n\n  SelectedData = 'selected-data',\n  SelectedSheetNames = 'selected-sheet-names',\n  Selection = 'selection',\n  SelectionList = 'selection-list',\n  SelectionUpdateType = 'selectionUpdateType',\n  SelectTuplesInteraction = 'select-tuples-interaction',\n  SendNotifications = 'send-notifications',\n  SettingsValues = 'settings-values',\n  SharedFilterSheets = 'shared-filter-sheets',\n  SharedFiltersInfo = 'shared-filters-info',\n  SheetIdentifier = 'sheet-identifier',\n  SheetName = 'sheet-name',\n  SheetPath = 'sheet-path',\n  ShouldRefreshDS = 'should-refresh-ds',\n  ShowDataTableFormat = 'show-data-table-format',\n  State = 'state',\n  StoryPointIndex = 'story-point-index',\n  StoryPointInfo = 'story-point-info',\n  SwitchToSheetName = 'switch-to-sheet-name',\n\n  TargetPoint = 'target-point',\n  TestConversionParameter = 'test-conversion-parameter',\n  Text = 'formatted-text',\n  TooltipContext = 'tooltip-context',\n  TooltipTextRequest = 'tooltip-text-request',\n  TooltipText = 'tooltip-text',\n\n  UnderlyingDataTable = 'underlying-data-table',\n  UnderlyingSummaryDataTable = 'underlying-summary-data-table',\n  Url = 'url',\n  UseTabDelimiters = 'use-tab-delimiters',\n\n  ViewDataTableCacheId = 'view-data-table-cache-id',\n  ViewDataTableId = 'view-data-table-id',\n  VisualId = 'visual-id',\n  VisualSpecification = 'visual-specification',\n  VizAPIInputJson = 'vizapi-input-json',\n  VizAPIStateWithDataModel = 'vizapi-state-with-data-model',\n  VizAPIStateWarningMsg = 'vizapi-state-warning-msg',\n  VizAPISVG = 'vizapi-svg',\n\n  WorksheetName = 'worksheet-name',\n  WorksheetFilters = 'worksheet-filters',\n\n  ZoneIdsVisibilityMap = 'zone-ids-visibility-map',\n}\n","// Declare this key type and export the NotificationId to make this behave like a string enum.\n//\n// PLEASE KEEP IN ALPHABETICAL ORDER. This helps with visually finding entries, knowing where to put\n// new ones, and merge conflicts.\nexport enum VerbId {\n  ActivateNextStoryPoint = 'activate-next-story-point',\n  ActivatePreviousStoryPoint = 'activate-previous-story-point',\n  ActivateSheet = 'activateSheet',\n  ActivateStoryPoint = 'activate-story-point',\n  AppendExternalMenuItem = 'append-external-menu-item',\n  ApplyCategoricalFilter = 'categorical-filter',\n  ApplyRangeFilter = 'range-filter',\n  ApplyRelativeDateFilter = 'apply-relative-date-Filter',\n  Authenticate = 'authenticate',\n\n  BlockExtension = 'block-extension',\n\n  ChangeParameterValue = 'change-parameter-value',\n  ChangeSharedFilter = 'change-shared-filter',\n  ClearFilter = 'clear-filter',\n  ClearSelectedMarks = 'clear-selected-marks',\n  CloseDialog = 'close-dialog',\n  CreateAnnotation = 'create-annotation',\n\n  DashboardCategoricalFilter = 'dashboard-categorical-filter',\n  DisplayDialog = 'display-dialog',\n  DownloadWorkbook = 'download-workbook',\n\n  ExecuteExternalMenuItem = 'execute-external-menu-item',\n  ExportCrosstab = 'export-crosstab',\n  ExportCrosstabCsvDownload = 'export-crosstab-csv-download',\n  ExportCrosstabExcelDownload = 'export-crosstab-excel-download',\n  ExportData = 'export-data',\n  ExportDataDownload = 'export-data-download',\n  ExportImage = 'export-image',\n  ExportPdf = 'export-pdf',\n  ExportPdfDownload = 'export-pdf-download',\n  ExportPowerpoint = 'export-powerpoint',\n  ExportPowerpointDownload = 'export-powerpoint-download',\n\n  FindParameter = 'find-parameter',\n\n  GetActiveTables = 'get-active-tables',\n  GetAllDataSources = 'get-all-data-sources',\n  GetAnnotations = 'get-annotations',\n  GetCategoricalDomain = 'get-categorical-domain',\n  GetConnectionDescriptionSummaries = 'get-connection-description-summaries',\n  GetCurrentSrc = 'get-current-src',\n  GetCustomViews = 'get-custom-views',\n  GetDashboardFilters = 'get-dashboard-filters',\n  GetDataSource = 'get-datasource',\n  GetDataSourceData = 'get-datasource-data',\n  GetDataSources = 'get-data-sources',\n  GetDataSummaryData = 'get-summary-data',\n  GetDataSummaryDataReader = 'get-summary-data-reader',\n  GetDataTableReaderPage = 'get-data-table-reader-page',\n  GetEmbeddingAbstractQueryWithDataModel = 'get-embedding-abstract-query-with-data-model',\n  GetEmbeddingClientInfo = 'get-embedding-client-info',\n  GetVizStateWithDataModel = 'get-viz-state-with-data-model',\n  GetExportCrosstabSheetMap = 'get-export-crosstab-sheet-map',\n  GetExportPdfOptions = 'get-export-pdf-options',\n  GetField = 'get-field',\n  GetFieldAndDataSource = 'get-field-and-datasource',\n  GetVisualSpecification = 'get-visual-specification',\n  GetFilters = 'get-filters',\n  GetFonts = 'get-fonts',\n  GetHighlightedMarks = 'get-highlighted-marks',\n  GetJoinDescription = 'get-join-description',\n  GetLogicalTableData = 'get-logical-table-data',\n  GetLogicalTableDataReader = 'get-logical-table-data-reader',\n  GetLogicalTables = 'get-logical-tables',\n  GetParametersForSheet = 'get-parameters-for-sheet',\n  GetRangeDomain = 'get-range-domain',\n  GetSelectedMarks = 'get-selected-marks',\n  GetSharedFilter = 'get-shared-filter',\n  GetTooltipText = 'get-tooltip-text',\n  GetUnderlyingData = 'get-underlying-data',\n  GetUnderlyingTableData = 'get-underlying-table-data',\n  GetUnderlyingTableDataReader = 'get-underlying-table-data-reader',\n  GetUnderlyingTables = 'get-underlying-tables',\n\n  HierarchicalFilter = 'hierachical-filter',\n\n  InitializeExtension = 'initialize-extension',\n\n  MoveAndResizeZones = 'move-and-resize-zones',\n\n  RaiseLeaveMarkNavNotification = 'raise-leave-mark-nav-notification',\n  RaiseHoverTupleNotification = 'raise-hover-tuple-notification',\n  RaiseSelectTuplesNotification = 'raise-select-tuples-notification',\n  Redo = 'redo',\n  RefreshDataSource = 'refresh-data-source',\n  ReleaseDataTableReader = 'release-data-table-reader',\n  RemoveAnnotation = 'remove-annotation',\n  RemoveCustomView = 'remove-custom-view',\n  RemoveExternalMenuItem = 'remove-external-menu-item',\n  RenameExternalMenu = 'rename-external-menu',\n  ReplayAnimation = 'replay-animation',\n  RevertStoryPoint = 'revert-story-point',\n  RevertWorkbook = 'revert-workbook',\n\n  SaveExtensionSettings = 'save-extension-settings',\n  SaveWorkbookAsCustomView = 'save-workbook-as-custom-view',\n  SelectByValue = 'select-by-value',\n  SetActiveCustomViewAsDefault = 'set-active-custom-view-as-default',\n  SetAutoUpdate = 'set-auto-update',\n  SetClickThrough = 'set-click-through',\n  SetVizStateWithDataModel = 'set-viz-state-with-data-model',\n  SetSheetSize = 'set-sheet-size',\n  SetZoneVisibility = 'set-zone-visibility',\n  Share = 'share',\n  ShowCustomView = 'show-custom-view',\n\n  TestConversionVerb = 'test-conversion-verb',\n\n  Undo = 'undo',\n  UpdateCustomView = 'update-custom-view',\n\n  VizAPI = 'viz-api',\n}\n","export enum AskDataOptionNames {\n  token = 'token',\n  origin = 'origin',\n  showEmbed = 'showEmbed',\n  showPin = 'showPin',\n  showSave = 'showSave',\n  showShare = 'showShare',\n  debug = ':jsdebug',\n  ApiID = ':apiID',\n  ApiExternalVersion = ':apiExternalVersion',\n  ApiInternalVersion = ':apiInternalVersion',\n  AskDataWebComponent = ':askDataWebComponent',\n}\n","export enum PulseOptionNames {\n  embed = 'embed',\n  token = 'token',\n  disableExploreFilter = 'disableExploreFilter',\n  layout = 'embed_layout',\n  ApiExternalVersion = ':apiExternalVersion',\n  ApiInternalVersion = ':apiInternalVersion',\n  PulseWebComponent = ':pulseWebComponent',\n}\n","/**\n * These strings were *manually copied* from the server,\n * workgroup/src/silos/tableau-server/libraries/tab-controller-vizql/src/com/tableausoftware/\n * controller/vizql/constants/ParameterKeys.java#L9\n * should be exported instead\n * parameters that vizql will accept in an embedding URL\n **/\nenum VqlParameterNames {\n  ONE = '1',\n  ALERTS = ':alerts',\n  ALIAS = 'alias',\n  ALLOW_DEFERRED_BOOTSTRAP = ':allowDeferredBootstrap',\n  ALLOW_AUTOGEN_WORKSHEET_PHONE_LAYOUTS = 'allowAutogenWorksheetPhoneLayouts',\n  API_ID = ':apiID',\n  APP = ':app',\n  ATTACHMENT = 'attachment',\n  IS_IPAD_APP = 'app',\n  ANIMATE_TRANSITION = ':animate_transition',\n  ASCENDING = 'ascending',\n  AUTHENTICATION = 'authentication',\n  ATTRIBUTES = 'attributes',\n  AUTHORING_SHEET = ':authSheet',\n  AXIS = 'axis',\n  BOOTSTRAP_WHEN_NOTIFIED = ':bootstrapWhenNotified',\n  BROWSER_BACK_BUTTON_UNDO = ':browserBackButtonUndo',\n  BROWSER_RENDERING_ON = 'isBrowserRendering',\n  BROWSER_RENDERING_THRESHOLD = 'browserRenderingThreshold',\n  CHARSET = 'charset',\n  CLIENT_DIMENSION = 'clientDimension',\n  CLIENT_IP = 'client_ip',\n  CLIENT_NUM = 'clientNum',\n  COLON_EMBEDDED = ':embedded',\n  COLON_MOBILE = ':mobile',\n  COLON_DEEP_LINKING_DISABLED = ':deepLinkingDisabled',\n  COLON_WATERMARK = ':watermark',\n  COMMENTS = ':comments',\n  COMMENTING_ENABLED = ':commentingEnabled',\n  COMMENTING_MENTIONS_ENABLED = ':commentingMentions',\n  CONNECTION = 'connection',\n  CREATED_BY_FEATURE = 'createdByFeature',\n  CRYPTED_PASSWORD = 'crypted',\n  CSSDEBUG = ':cssdebug',\n  CSV = 'csv',\n  CUSTOM_VIEWS = ':customViews',\n  CV = ':cv',\n  CV_ID = 'cvId',\n  DASHBOARD_PORT_SIZE = 'dashboardPortSize',\n  DATA_DETAILS = ':dataDetails',\n  DATASOURCE = 'datasource',\n  DEBUG = ':debug',\n  DELAY = ':delay',\n  DEPTH = 'depth',\n  DEVICE_TYPE = ':device',\n  DEVICE_PIXEL_RATIO = 'devicePixelRatio',\n  DEVICE_PREVIEW_MODE = ':devicepreviewmode',\n  DIMENSIONS = ':dimensions',\n  DISABLE_SHARED_SESSIONS = ':disable_shared_sessions',\n  DISABLE_URL_ACTIONS_POPUPS = ':disableUrlActionsPopups',\n  DIRECTION = 'direction',\n  DISPLAY_OVERLAY = ':display_overlay',\n  DISPLAY_SHARE = ':display_share',\n  DISPLAY_SPINNER = ':display_spinner',\n  DISPLAY_STATIC_IMAGE = ':display_static_image',\n  DISPLAY_TABS = 'display_tabs',\n  DISPLAY_VIEW_COUNT = ':display_count',\n  IGNORE_STICKY_SESSION = ':ignore_sticky_session',\n  INCREMENT_VIEW_COUNT = ':increment_view_count',\n  DOCMODE = 'docmode',\n  DOMAIN = 'domain',\n  DO_WORK = 'do_work',\n  DX = 'dx',\n  DY = 'dy',\n  EDIT_DATA_ALERT = ':editDataAlert',\n  EMBED = ':embed',\n  EMBEDDED = 'embedded',\n  ENCRYPTED = 'encrypted',\n  API_EXTERNAL_VERSION = ':apiExternalVersion',\n  API_INTERNAL_VERSION = ':apiInternalVersion',\n  EXCLUDE = 'exclude',\n  EXPORT_FORMAT = ':export_format',\n  FIELDNAME = 'fieldname',\n  FIELD_NAME = 'field_name',\n  FIELD_SEP = 'field_sep',\n  FILE = 'file',\n  FILTER_TILE_SIZE = 'filterTileSize',\n  FN = 'fn',\n  FOCUS = 'focus',\n  FORCE_CACHE = 'force_cache',\n  FORMAT = 'format',\n  FORMAT_DATA_VALUE_LOCALLY = 'formatDataValueLocally',\n  FROM_WG = ':from_wg',\n  GRAPHQL_DATABASE_ID = ':graphQLDatabaseId',\n  GRAPHQL_TABLE_ID = ':graphQLTableId',\n  GUID = ':guid',\n  H = 'h',\n  HIDDEN = 'hidden',\n  HIDE_CLOSE_BUTTON = ':hideCloseButton',\n  HIDE_EDIT_BUTTON = ':hideEditButton',\n  HIDE_EDIT_IN_DESKTOP_BUTTON = ':hideEditInDesktopButton',\n  HIGH_DPI = ':highdpi',\n  IMAGE_SIZE_LIMIT = 'imageSizeLimit',\n  TRANSPARENT_LINE_MARKS_LIMIT = 'transparentLineMarkLimit',\n  CLIENT_RENDER_PIXEL_LIMIT = 'clientRenderPixelLimit',\n  IN = 'in',\n  INSTANCE_ID = ':iid',\n  IS_GUEST_REDIRECT_FROM_VIZPORTAL = ':isGuestRedirectFromVizportal',\n  IS_MARK_ANIMATION_ENABLED = 'isMarkAnimationEnabled',\n  IS_VIZPORTAL = ':isVizPortal',\n  INPUT_ = 'input_string',\n  JSDEBUG = ':jsdebug',\n  JSON = 'json',\n  JSON_ONLY = ':jsonOnly',\n  KEEPFILE = 'keepfile',\n  KEY = 'key',\n  LANGUAGE = 'language',\n  LANGUAGE_REQUESTED = ':language',\n  LINKTARGET = ':linktarget',\n  LOAD_ORDER_ID = ':loadOrderID', // used for Public\n  LOAD_NEWEST_REVISION = ':loadNewestRevision',\n  LOCAL_PATHS = ':localPaths',\n  LOCALE = 'locale',\n  LOCATION_ID = 'locationid',\n  LOCATION_TYPE = 'locationtype',\n  WORKBOOK_LOCALE = 'workbookLocale',\n  MAXROWS = 'maxrows',\n  MAX_AGE = 'maxAge',\n  MAX_ROWS = 'maxRows',\n  METHOD = 'method',\n  MOBILE = 'mobile',\n  MODIFIER = 'modifier',\n  NAME = 'name',\n  NAV_TYPE = 'navType',\n  NAV_SRC = 'navSrc',\n  NOATTACHMENT = 'no-attachment',\n  NO_OVERWRITE = 'no_overwrite',\n  OPEN_AUTHORING_IN_TOP_WINDOW = ':openAuthoringInTopWindow',\n  OPENID_HD = ':openid_hd',\n  OPENID_LOGIN_HINT = ':openid_login_hint',\n  OAUTHREQUEST = 'oauthrequest',\n  OAUTH_CREDENTIAL_IDS = 'oauth_credential_ids',\n  OFFLINE_MODE = ':offlinemode',\n  ORIGIN = ':origin',\n  OVERLAY = ':overlay',\n  P = 'p',\n  PATH = 'path',\n  PANE_RESOLVER_X = 'paneResolverX',\n  PANE_RESOLVER_Y = 'paneResolverY',\n  PARAM = 'param',\n  PARENT_ID = 'parent_id',\n  PASSWORD = 'password',\n  PATTERN = 'pattern',\n  PIXEL_RATIO = ':pixelratio',\n  PREFIX = ':prefix',\n  PREVIEW = ':preview',\n  PRIMARY_CONTENT_URL = 'primary_content_url',\n  PROJECT = 'project',\n  PROTOCOL = 'protocol',\n  PSEUDO = ':pseudo',\n  QUERY = 'query',\n  R = 'r',\n  RANGE_TYPE = 'range_type',\n  RECORD_SEP = 'record_sep',\n  RECORD_CLIENT_PERFORMANCE = ':record_client_performance',\n  RECORD_PERFORMANCE = ':record_performance',\n  RECOVER_OLD_SESSION_ID = ':recover_old_session_id',\n  RECOVER_SESSION_STATE_TICKETS = ':recover_session_state_tickets',\n  REFRESH = ':refresh',\n  REFRESHUNMODIFIED = ':refreshunmodified',\n  REGION = 'region',\n  RELOAD_ON_CUSTOM_VIEW_SAVE = ':reloadOnCustomViewSave',\n  RENDER = ':render',\n  RENDER_MAPS_CLIENT_SIDE = 'renderMapsClientSide',\n  RETRY = ':retry',\n  REUSE = 'reuse',\n  REUSE_FOREVER = 'reuse_forever',\n  REVERT = ':revert',\n  SAVE_DB_PASSWORDS = 'save_db_passwords',\n  SELECT_X = 'select_x',\n  SELECT_Y = 'select_y',\n  SESSION_FEATURE_PREFIX = ':ff_',\n  SESSION_FLAGS = ':session_feature_flags',\n  SHARE_BUTTON = 'share_button',\n  SHEET_ID = 'sheet_id',\n  SHARED = 'shared',\n  SHOWALL = 'showall',\n  SHOW_APP_BANNER = ':showAppBanner',\n  SHOW_ASK_DATA = ':showAskData',\n  SHOW_PARAMS = 'showParams',\n  SHOW_SHARE_OPTIONS = ':showShareOptions',\n  SIZE = ':size',\n  SOURCE = 'source',\n  STATE = 'state',\n  STICKY_SESSION_KEY = 'stickySessionKey',\n  SUBSCRIPTIONS = ':subscriptions',\n  SUMMARY = 'summary',\n  SUPPRESS_DEFAULT_EDIT_BEHAVIOR = ':suppressDefaultEditBehavior',\n  SYNC_SESSION = ':sync_session',\n  SYNC_SESSION_STATE = 'sync_session_state',\n  TABS = ':tabs',\n  TARGET = 'target',\n  TARGET_SITE = 'target_site',\n  TOOLBAR = ':toolbar',\n  TOOLTIP = ':tooltip',\n  TS = 'ts',\n  UNDERLYING_TABLE_ID = 'underlying_table_id',\n  UNDERLYING_TABLE_CAPTION = 'underlying_table_caption',\n  UPDATE_TYPE = 'update_type',\n  USE_GUEST = ':useGuest',\n  USE_INLINE_IMAGES = 'use_inline_images',\n  USERAGENT = 'useragent',\n  USERNAME = 'username',\n  VALUE = 'value',\n  VERBOSE_MODE = 'verboseMode',\n  VIEW_ID = 'views_id',\n  VIZ_SNAPSHOT_ID = 'viz_snapshot_id',\n  VW = ':vw',\n  W = 'w',\n  WORKSHEET_PORT_SIZE = 'worksheetPortSize',\n  WATERMARK = 'watermark',\n  WATERMARK_MARGIN = ':watermark_margin',\n  WB = ':wb',\n  WHICH = 'which',\n  X = 'x',\n  Y = 'y',\n  ZID = 'zid',\n  ZONE_ID = 'zone_id',\n  KEYCHAIN_VERSION = 'keychain_version',\n  DATASOURCE_ID = 'datasource_id',\n  DATASOURCE_NAME = 'datasource_name',\n  LENS_ID = 'lens_id',\n  WIDTH = 'width',\n  HEIGHT = 'height',\n\n  // Default Layout params\n  LAYOUT_VIEWS = 'views',\n  LAYOUT_MENUS = 'menus',\n  LAYOUT_GEOMETRY = 'geometry',\n  LAYOUT_PAGES = 'pages',\n  LAYOUT_CACHEURL = 'cacheurl',\n  LAYOUT_SHEET = 'sheet',\n  LAYOUT_DEPTH = 'depth',\n}\n\n/**\n * parameters that are only relevant when working with Tableau Public\n * maybe not really necessry to split them out\n */\nenum PublicParameterNames {\n  SHOW_VIZ_HOME = ':showVizHome',\n  // display view count\n}\n\n/**\n * Map the parameter names as used in the url to what we call them publicly in the embedding library.\n * The only parameters listed here should be the ones that get sent to vizql\n *  - this should match the interface at external-contract:VizInterfaces:VizSettings\n */\nexport enum VizOptionNames {\n  // publicName = internalStringValue\n  Size = VqlParameterNames.SIZE,\n  Embed = VqlParameterNames.EMBED,\n  ApiInternalVersion = VqlParameterNames.API_INTERNAL_VERSION,\n  ApiExternalVersion = VqlParameterNames.API_EXTERNAL_VERSION,\n  ShowVizHome = PublicParameterNames.SHOW_VIZ_HOME,\n  Jsdebug = VqlParameterNames.JSDEBUG,\n  BootstrapWhenNotified = VqlParameterNames.BOOTSTRAP_WHEN_NOTIFIED,\n  NavType = VqlParameterNames.NAV_TYPE,\n  NavSrc = VqlParameterNames.NAV_SRC,\n  debug = VqlParameterNames.JSDEBUG,\n  ApiID = VqlParameterNames.API_ID,\n\n  disableUrlActionsPopups = VqlParameterNames.DISABLE_URL_ACTIONS_POPUPS,\n  hideTabs = VqlParameterNames.TABS,\n  toolbar = VqlParameterNames.TOOLBAR,\n  device = VqlParameterNames.DEVICE_TYPE,\n  instanceIdToClone = VqlParameterNames.INSTANCE_ID,\n  touchOptimize = VqlParameterNames.MOBILE,\n  hideEditButton = VqlParameterNames.HIDE_EDIT_BUTTON,\n  hideEditInDesktopButton = VqlParameterNames.HIDE_EDIT_IN_DESKTOP_BUTTON,\n  suppressDefaultEditBehavior = VqlParameterNames.SUPPRESS_DEFAULT_EDIT_BEHAVIOR,\n  hideCloseButton = VqlParameterNames.HIDE_CLOSE_BUTTON,\n}\n","import * as guid from 'guid';\nimport { ExecuteParameters, INTERNAL_CONTRACT_VERSION, Model, NotificationId, VerbId, VersionNumber } from '../JsApiInternalContract';\nimport { InitializationOptions } from '../interface/InitializationOptions';\nimport { CrossFramePreparedMessage } from './CrossFramePreparedMessage';\nimport {\n  isCommandMessage,\n  isCommandResponseMessage,\n  isHandshakeMessage,\n  isInitMessage,\n  isMessage,\n  isNotificationMessage,\n} from './MessageTypeChecks';\nimport {\n  CommandMessageHandler,\n  CommandResponseMessageHandler,\n  HandshakeMessageHandler,\n  InitializeMessageHandler,\n  NotificationMessageHandler,\n} from './interface/MessageListener';\nimport {\n  CommandMessage,\n  CommandResponseMessage,\n  HandshakeMessage,\n  InitializeMessage,\n  Message,\n  MessageType,\n  NotificationMessage,\n} from './interface/MessageTypes';\nimport { Messenger } from './interface/Messenger';\nimport { PreparedMessage } from './interface/PreparedMessage';\n\n/**\n * The CrossFrameMessenger is the primary export from the api-messaging module. An instance of\n * this class can be instantiated on both sides of a frame boundary to facilitate communication\n * in both directions between the frames. This class implements both the dispatcher and the listener\n * portions, but doesn't require callers to care about both.\n */\nexport class CrossFrameMessenger implements Messenger {\n  private unregisterFunction?: () => void;\n  private initializeMessageHandler?: InitializeMessageHandler;\n  private commandResponseMessageHandler?: CommandResponseMessageHandler;\n  private commandMessageHandler?: CommandMessageHandler;\n  private notificationMessageHandler?: NotificationMessageHandler;\n  private handshakeMessageHandler?: HandshakeMessageHandler;\n\n  /**\n   * Creates an instance of CrossFrameMessenger. If you would like to use the CrossFrameMessenger as a MessageListener,\n   * be sure to call StartListening and register message handlers.\n   * @param thisWindow The window object which the CrossFrameMessenger lives. An onMessage listener will be added here.\n   * @param [otherWindow] Optional otherWindow which messages will be posted to.\n   *                      If defined, incoming messages must originate from otherWindow to be passed on\n   * @param [otherWindowOrigin] The target origin which otherWindow must have in order to receive dispatched messages.\n   *                            This value will be sent as the targetOrigin of a postMessage\n   *                            (https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage)\n   */\n  public constructor(private thisWindow: Window, private otherWindow?: Window, private otherWindowOrigin?: string) {\n    // Make sure to call StartListening\n  }\n\n  ///// MessageListener Implementation\n\n  public startListening(): void {\n    // Check if we already are listening, if not, hook up a message listener\n    if (!this.unregisterFunction) {\n      const boundHandler = this.onMessageReceived.bind(this);\n      this.thisWindow.addEventListener('message', boundHandler, true);\n      this.unregisterFunction = () => this.thisWindow.removeEventListener('message', boundHandler, true);\n    }\n  }\n\n  public stopListening(): void {\n    // Stop listening if we have started listening\n    if (this.unregisterFunction) {\n      this.unregisterFunction();\n      this.unregisterFunction = undefined;\n    }\n  }\n\n  public setInitializeMessageHandler(handler?: InitializeMessageHandler): void {\n    this.initializeMessageHandler = handler;\n  }\n\n  public setCommandResponseMessageHandler(handler?: CommandResponseMessageHandler): void {\n    this.commandResponseMessageHandler = handler;\n  }\n\n  public setCommandMessageHandler(handler?: CommandMessageHandler): void {\n    this.commandMessageHandler = handler;\n  }\n\n  public setNotificationMessageHandler(handler?: NotificationMessageHandler): void {\n    this.notificationMessageHandler = handler;\n  }\n\n  public setHandshakeMessageHandler(handler?: HandshakeMessageHandler): void {\n    this.handshakeMessageHandler = handler;\n  }\n\n  ///// MessageDispatcher Implementation\n\n  /**\n   * @param apiVersion api-internal-contract-js version (exported in JsApiInternalConntract)\n   * @param crossFrameVersion crossframe messaging version (exported in JsApiInternalConntract)\n   * @param options additional options that can be passed at initialization (information about the version of\n   *                external being used for example)\n   */\n  public prepareInitializationMessage(\n    apiVersion: VersionNumber,\n    crossFrameVersion: VersionNumber,\n    options?: InitializationOptions,\n  ): PreparedMessage {\n    const message: InitializeMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Initialize,\n      crossFrameVersion: crossFrameVersion,\n      apiVersion: apiVersion,\n      options: options,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareCommandMessage(verbId: VerbId, parameters: ExecuteParameters): PreparedMessage {\n    const message: CommandMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Command,\n      verbId: verbId,\n      parameters: parameters,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareCommandResponseMessage(commandGuid: string, data: Model | undefined, error: Model | undefined): PreparedMessage {\n    const message: CommandResponseMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.CommandResponse,\n      commandGuid: commandGuid,\n      data: data,\n      error: error,\n    };\n\n    if (error) {\n      // stringify error object to remove unserializable fields like functions and prevent serialization errors\n      message.error = JSON.parse(JSON.stringify(error));\n    }\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareNotificationMessage(notificationId: NotificationId, data: Model): PreparedMessage {\n    const message: NotificationMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Notification,\n      notificationId: notificationId,\n      data: data,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  public prepareAckMessage(): PreparedMessage {\n    const message: HandshakeMessage = {\n      msgGuid: guid.raw(),\n      msgType: MessageType.Ack,\n      platformVersion: INTERNAL_CONTRACT_VERSION,\n    };\n\n    return this.prepareMessage(message);\n  }\n\n  /**\n   * Prepares a pending message for sending and returns the prepared message\n   *\n   * @param msg The message to be sent to this.otherWindow\n   * @returns The prepared message\n   */\n  private prepareMessage(msg: Message): PreparedMessage {\n    if (!this.otherWindow || !this.otherWindowOrigin) {\n      throw 'Other window not initialized, cannot dispatch messages';\n    }\n\n    const preparedMessage = new CrossFramePreparedMessage(msg, this.otherWindow, this.otherWindowOrigin);\n    return preparedMessage;\n  }\n\n  /**\n   * Called when a message is received. Does some validation of the message, and then\n   * calls an appropriate message handler if one is defined\n   *\n   * @param event The incoming MessageEvent\n   */\n  private onMessageReceived(event: MessageEvent): void {\n    // If we have an otherWindow defined, make sure the message is coming from there\n    if (this.otherWindow && event.source !== this.otherWindow) {\n      return;\n    }\n\n    // Do some validation on event.data to make sure that we have received a real message\n    if (!event.data) {\n      return;\n    }\n\n    const message = event.data;\n    if (!isMessage(message)) {\n      return;\n    }\n\n    // Check the declared message type, validate the message, and call an appropriate hander if one exists\n    switch (message.msgType) {\n      case MessageType.Initialize: {\n        if (!isInitMessage(message) || !this.initializeMessageHandler) {\n          return;\n        }\n\n        this.initializeMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.CommandResponse: {\n        if (!isCommandResponseMessage(message) || !this.commandResponseMessageHandler) {\n          return;\n        }\n\n        this.commandResponseMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.Command: {\n        if (!isCommandMessage(message) || !this.commandMessageHandler) {\n          return;\n        }\n\n        this.commandMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.Notification: {\n        if (!isNotificationMessage(message) || !this.notificationMessageHandler) {\n          return;\n        }\n\n        this.notificationMessageHandler(message, event.source);\n        break;\n      }\n      case MessageType.Handshake: {\n        if (!isHandshakeMessage(message) || !this.handshakeMessageHandler) {\n          return;\n        }\n\n        this.handshakeMessageHandler(message, event.source);\n        break;\n      }\n      default:\n      // Just ignore this since we don't know how to handle the message type\n    }\n  }\n\n  public setOtherWindow(otherWindow: Window): void {\n    this.otherWindow = otherWindow;\n  }\n\n  public setOtherWindowOrigin(origin: string): void {\n    this.otherWindowOrigin = origin;\n  }\n}\n","import { Message } from './interface/MessageTypes';\nimport { PreparedMessage } from './interface/PreparedMessage';\n\n/**\n * Implementation of the PreparedMessage interface used to post messages between\n * two frames using window.postMessage\n */\nexport class CrossFramePreparedMessage implements PreparedMessage {\n  /**\n   * Creates an instance of CrossFramePreparedMessage.\n   * @param _message The message to be sent\n   * @param _target The target window where the message will be sent\n   * @param _origin The targetOrigin where this message can be received\n   */\n  public constructor(private _message: Message, private _target: Window, private _origin: string) {}\n\n  public get messageGuid(): string {\n    return this._message.msgGuid;\n  }\n\n  public send(): PreparedMessage {\n    this._target.postMessage(this._message, this._origin);\n    return this;\n  }\n}\n","import * as guid from 'guid';\nimport { NotificationId } from '../contract/Notifications';\nimport { VersionNumber } from '../interface/VersionNumber';\nimport {\n  CommandMessage,\n  CommandResponseMessage,\n  HandshakeMessage,\n  InitializeMessage,\n  Message,\n  MessageType,\n  NotificationMessage,\n} from './interface/MessageTypes';\n\nconst expectedEmptyNotifications = new Set([\n  NotificationId.EditButtonClicked,\n  NotificationId.EditInDesktopButtonClicked,\n  NotificationId.WorkbookPublished,\n  NotificationId.WorkbookReadyToClose,\n  NotificationId.ReadyToReceiveAuthToken,\n]);\n\n/* tslint:disable no-any */\nexport function isMessage(data: Message | any): data is Message {\n  if (!data) {\n    return false;\n  }\n\n  const message = data as Message;\n  if (!message || !message.msgGuid || !message.msgType) {\n    return false;\n  }\n\n  if (!guid.isGuid(message.msgGuid)) {\n    return false;\n  }\n\n  if (typeof message.msgType !== 'string') {\n    return false;\n  }\n\n  const messageTypes: Array<string> = [\n    MessageType.Command,\n    MessageType.CommandResponse,\n    MessageType.Initialize,\n    MessageType.Notification,\n    MessageType.Handshake,\n  ];\n\n  if (messageTypes.indexOf(message.msgType) < 0) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isVersion(versionNumber: VersionNumber | any): versionNumber is VersionNumber {\n  if (!versionNumber) {\n    return false;\n  }\n\n  const v = versionNumber as VersionNumber;\n\n  if (typeof v !== 'object') {\n    return false;\n  }\n\n  if (typeof v.fix !== 'number' || typeof v.minor !== 'number' || typeof v.major !== 'number') {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isInitMessage(message: InitializeMessage | any): message is InitializeMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const initMessage = message as InitializeMessage;\n  if (initMessage.msgType !== MessageType.Initialize) {\n    return false;\n  }\n\n  if (!initMessage.apiVersion || !isVersion(initMessage.apiVersion)) {\n    return false;\n  }\n\n  if (!initMessage.crossFrameVersion || !isVersion(initMessage.crossFrameVersion)) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isCommandResponseMessage(message: CommandResponseMessage | any): message is CommandResponseMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const crMessage = message as CommandResponseMessage;\n  if (crMessage.msgType !== MessageType.CommandResponse) {\n    return false;\n  }\n\n  if (!guid.isGuid(crMessage.commandGuid)) {\n    return false;\n  }\n\n  if (!crMessage.data && !crMessage.error) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isCommandMessage(message: CommandMessage | any): message is CommandMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const commandMessage = message as CommandMessage;\n  if (commandMessage.msgType !== MessageType.Command) {\n    return false;\n  }\n\n  if (!commandMessage.parameters || typeof commandMessage.parameters !== 'object') {\n    return false;\n  }\n\n  if (!commandMessage.verbId || typeof commandMessage.verbId !== 'string') {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isNotificationMessage(message: NotificationMessage | any): message is NotificationMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const notificationMessage = message as NotificationMessage;\n  if (notificationMessage.msgType !== MessageType.Notification) {\n    return false;\n  }\n\n  if (!notificationMessage.data && !expectedEmptyNotifications.has(notificationMessage.notificationId)) {\n    return false;\n  }\n\n  if (!notificationMessage.notificationId || typeof notificationMessage.notificationId !== 'string') {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isHandshakeMessage(message: HandshakeMessage | any): message is HandshakeMessage {\n  if (!isMessage(message)) {\n    return false;\n  }\n\n  const handshakeMessage = message as HandshakeMessage;\n  if (handshakeMessage.msgType !== MessageType.Handshake) {\n    return false;\n  }\n\n  return true;\n}\n","import { ExecuteParameters, Model, NotificationId, VerbId, VersionNumber } from '../../JsApiInternalContract';\nimport { InitializationOptions } from '../../interface/InitializationOptions';\n\n/**\n * Enum defining the 4 different types of messages we have defined\n */\nexport enum MessageType {\n  Initialize = 'initialize',\n  Notification = 'notification',\n  Command = 'command',\n  CommandResponse = 'command-response',\n  Handshake = 'v-handshake',\n  Ack = 'v-ack',\n}\n\n/**\n * The Message interface is the base interface for all the other\n * message type interfaces.\n */\nexport interface Message {\n  /**\n   * A unique id for this message\n   */\n  msgGuid: string;\n\n  /**\n   * The type of this message\n   */\n  msgType: MessageType;\n}\n\n/**\n * The initialize message is the first message which will be sent\n * from the javascript to set up communications\n */\nexport interface InitializeMessage extends Message {\n  /**\n   * The version of the api which the sender wants to use\n   */\n  apiVersion: VersionNumber;\n\n  /**\n   * The version of this messaging contract to be used. For now, there\n   * should only be a single version but sending this along should help\n   * if we need to add a new version in a future release\n   */\n  crossFrameVersion: VersionNumber;\n\n  /**\n   * Additional options that can be passed at the time of initialization\n   */\n  options?: InitializationOptions;\n}\n\n/**\n * This message is sent when a notification occurs from the preslayer\n */\nexport interface NotificationMessage extends Message {\n  /**\n   * The id for this type of notification\n   */\n  notificationId: NotificationId;\n\n  /**\n   * The data which came along with the notification\n   */\n  data: Model;\n}\n\n/**\n * Represents calling an internal contract command\n */\nexport interface CommandMessage extends Message {\n  /**\n   * The id of the command which should be executed\n   */\n  verbId: VerbId;\n\n  /**\n   * An object containing the parameters for the command\n   */\n  parameters: ExecuteParameters;\n}\n\n/**\n * This message is sent in response to a CommandMessage with the\n * result of that commands invocation\n */\nexport interface CommandResponseMessage extends Message {\n  /**\n   * Guid of the CommandMessage which this is in response to\n   */\n  commandGuid: string;\n\n  /**\n   * If there was an error returned from the command, this will be defined\n   * and contain the error\n   */\n  error?: Model;\n\n  /**\n   * If the command executed successfully, this will contain the command result\n   */\n  data?: Model;\n}\n\nexport interface HandshakeMessage extends Message {\n  /**\n   * Internal API contract version\n   */\n  platformVersion: VersionNumber;\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId } from '../JsApiInternalContract';\nimport { InternalContractVersionConverter } from './InternalContractVersionConverter';\n\n// tslint:disable:no-any\n\n/**\n * This version converter doesn't actually do anything but is useful for testing or when we have\n * a matching platform and internal version number\n */\nexport class IdentityVersionConverter implements InternalContractVersionConverter {\n  public upgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    return {\n      verb: verb as VerbId,\n      parameters: parameters as ExecuteParameters,\n    };\n  }\n\n  public downgradeExecuteReturn(executeResponse: ExecuteResponse): ExecuteResponse {\n    return executeResponse;\n  }\n\n  public downgradeNotification(notification: Notification): Notification {\n    return notification;\n  }\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId, VersionNumber } from '../JsApiInternalContract';\nimport { InternalContractVersionConverter } from './InternalContractVersionConverter';\nimport * as Translations from './VersionTranslations';\n\n// tslint:disable:no-any\n\n/**\n * The version converter is designed to allow the platform and external modules\n * to seemlessly communicate over two different versions of the internal API. The only\n * mode it supports is external's version <= platform's version. When executing\n * commands, it is used to upgrade the external representation to what platform knows on the way in\n * and downgrade the representations on the way out. Similarly for notifications, it can\n * downgrade those on the way from platform to external.\n */\nexport class StackingVersionConverter implements InternalContractVersionConverter {\n  /**\n   * Creates a new instance of the StackingVersionConverter\n   *\n   * @param _externalVersion The version of the internal contract api-external-js is using\n   * @param _platformVersion The version of the internal contract the api-platform-js is using\n   * @param _upgradeExecuteTranslations Ordered list of the translations to perform when upgrading cmd parameters\n   * @param _downgradeExecuteTranslations Ordered list of downgrade translations to perform after a cmd\n   * @param _downgradeNotificationTranslations Ordered list of downgrade translations to perform on a notification\n   */\n  public static fromData(\n    externalVersion: VersionNumber,\n    platformVersion: VersionNumber,\n    upgradeExecuteTranslations: Array<Translations.UpgradeExecuteCall>,\n    downgradeExecuteTranslations: Array<Translations.DowngradeExecuteReturn>,\n    downgradeNotificationTranslations: Array<Translations.DowngradeNotification>,\n  ): StackingVersionConverter {\n    return new this(\n      externalVersion.major,\n      platformVersion.major,\n      upgradeExecuteTranslations,\n      downgradeExecuteTranslations,\n      downgradeNotificationTranslations,\n    );\n  }\n\n  /**\n   * Creates a new instance of the StackingVersionConverter\n   *\n   * @param _externalMajorVersion The major version of the internal contract api-external-js is using\n   * @param _platformMajorVersion The major version of the internal contract the api-platform-js is using\n   * @param _upgradeExecuteTranslations Ordered list of the translations to perform when upgrading cmd parameters\n   * @param _downgradeExecuteTranslations Ordered list of downgrade translations to perform after a cmd\n   * @param _downgradeNotificationTranslations Ordered list of downgrade translations to perform on a notification\n   */\n  public constructor(\n    private _externalMajorVersion: number,\n    private _platformMajorVersion: number,\n    private _upgradeExecuteTranslations: Array<Translations.UpgradeExecuteCall>,\n    private _downgradeExecuteTranslations: Array<Translations.DowngradeExecuteReturn>,\n    private _downgradeNotificationTranslations: Array<Translations.DowngradeNotification>,\n  ) {\n    if (this._externalMajorVersion > this._platformMajorVersion) {\n      throw new Error(`Cannot convert between external version ${this._externalMajorVersion} and ${this._platformMajorVersion}`);\n    }\n  }\n\n  public upgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    // Perform the upgrade of the verb and parameters to the level that platform is using\n    let upgraded = { verb: verb, parameters: parameters };\n    for (const upgradeTranslation of this._upgradeExecuteTranslations) {\n      upgraded = upgradeTranslation(upgraded.verb, upgraded.parameters);\n    }\n\n    return upgraded;\n  }\n\n  public downgradeExecuteReturn(executeResponse: ExecuteResponse): ExecuteResponse {\n    // Downgrade the response to what the external module is expecting\n    let downgraded = executeResponse;\n    for (const downgradeTranslation of this._downgradeExecuteTranslations) {\n      downgraded = downgradeTranslation(downgraded);\n    }\n\n    return downgraded;\n  }\n\n  public downgradeNotification(notification: Notification): Notification {\n    // Downgrade the notification to what the external module is expecting\n    let downgraded = notification;\n    for (const downgradeTranslation of this._downgradeNotificationTranslations) {\n      downgraded = downgradeTranslation(downgraded);\n    }\n\n    return downgraded;\n  }\n}\n","import { VersionNumber } from '../JsApiInternalContract';\nimport { IdentityVersionConverter } from './IdentityVersionConverter';\nimport { InternalContractVersionConverter } from './InternalContractVersionConverter';\nimport { StackingVersionConverter } from './StackingVersionConverter';\nimport * as Translations from './VersionTranslations';\nimport { DowngradeFlipboardZoneID, DowngradeWorksheetNames } from './VersionTranslations';\n\n/**\n * @returns true if lhs < rhs (ignoring fix number)\n * @param lhs\n * @param rhs\n */\nexport function VersionLessThan(lhs: VersionNumber, rhs: VersionNumber): boolean {\n  if (lhs.major > rhs.major) {\n    return false;\n  }\n  if (lhs.major < rhs.major) {\n    return true;\n  }\n  return lhs.minor < rhs.minor;\n}\n\n/**\n * @returns true if lhs == rhs (ignoring fix number)\n * @param lhs\n * @param rhs\n */\nexport function VersionEqualTo(lhs: VersionNumber, rhs: VersionNumber): boolean {\n  return lhs.major === rhs.major && lhs.minor === rhs.minor;\n}\n\nexport interface MajorMinorTranslators<T> {\n  [major: number]: { [minor: number]: Array<T> };\n}\n\n// A mapping from an older client version of internal-contract to the current platform version of this contract.\n// Each version bump can have an array of translations to perform in order. Notice that this is\n// different than the major upgrades/downgrades above because it handles both major and minor version changes.\n// Also please note: downgradeExecuteCall is handled on the client/external side rather than platform side.\n// When updating the major or minor version of our internal-contract, you will need to update these data structures.\n// * If there are translations to add, add them to the version to \"upgrade from\" or \"downgrade to\".\nexport const ExecuteMinorUpgrades: MajorMinorTranslators<Translations.UpgradeExecuteCall> = {\n  1: {\n    9: [], // Note that we put upgrades from 1.9 to 1.10 in the [1][9] bucket\n  },\n};\n\nexport const ExecuteMinorDowngrades: MajorMinorTranslators<Translations.DowngradeExecuteReturn> = {\n  1: {\n    5: [DowngradeWorksheetNames],\n    9: [],\n  },\n};\n\nexport const NotificationMinorDowngrades: MajorMinorTranslators<Translations.DowngradeNotification> = {\n  1: {\n    9: [],\n    10: [DowngradeFlipboardZoneID],\n  },\n};\n\n/**\n * Creates a new InternalContractVersionConverter which has the ability to upgrade and downgrade the contract\n * between the two versions, which are specified. If externalMajorVersion is greater than platformMajorVersion,\n * an error will be thrown because we won't know how to do those conversions.\n * This converter can handle both major and minor updates when the platform version is greater than external version.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n */\nexport function CreateVersionConverter(externalVersion: VersionNumber, platformVersion: VersionNumber): InternalContractVersionConverter {\n  return CreateVersionConverterWithTranslators(\n    externalVersion,\n    platformVersion,\n    ExecuteMinorUpgrades,\n    ExecuteMinorDowngrades,\n    NotificationMinorDowngrades,\n  );\n}\n\n/**\n * Implementation of CreateVersionConverter. This function takes the upgrade, downgrade, and\n * notification arrays so that all the logic can be tested.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n * @param upgrades MajorMinorTranslators for upgrades\n * @param downgrades MajorMinorTranslators for downgrades\n * @param notificationDowngrades MajorMinorTranslators for notification downgrades\n */\nexport function CreateVersionConverterWithTranslators(\n  externalVersion: VersionNumber,\n  platformVersion: VersionNumber,\n  upgrades: MajorMinorTranslators<Translations.UpgradeExecuteCall>,\n  downgrades: MajorMinorTranslators<Translations.DowngradeExecuteReturn>,\n  notificationDowngrades: MajorMinorTranslators<Translations.DowngradeNotification>,\n): InternalContractVersionConverter {\n  const externalMajorVersion: number = externalVersion.major;\n  const externalMinorVersion: number = externalVersion.minor;\n  const platformMajorVersion: number = platformVersion.major;\n\n  if (externalMajorVersion > platformMajorVersion) {\n    throw new Error(`External version must be less than or equal to platform version.\n    externalMajorVersion=${externalMajorVersion} platformMajorVersion=${platformMajorVersion}`);\n  }\n\n  // If we are using the exact same versions (major.minor), just use the identity converter\n  if (VersionEqualTo(externalVersion, platformVersion)) {\n    return new IdentityVersionConverter();\n  }\n\n  // Walk the span between the versions we have here and collect the upgrade and downgrades necessary\n  const neededExecuteUpgrades: Array<Translations.UpgradeExecuteCall> = GetNeededTranslations(\n    externalMajorVersion,\n    platformMajorVersion,\n    externalMinorVersion,\n    upgrades,\n  );\n\n  const neededExecuteDowngrades: Array<Translations.DowngradeExecuteReturn> = GetNeededTranslations(\n    externalMajorVersion,\n    platformMajorVersion,\n    externalMinorVersion,\n    downgrades,\n  );\n\n  const neededNotificationDowngrades: Array<Translations.DowngradeNotification> = GetNeededTranslations(\n    externalMajorVersion,\n    platformMajorVersion,\n    externalMinorVersion,\n    notificationDowngrades,\n  );\n\n  // We want to apply the downgrades in reverse order in case of dependencies between them\n  neededExecuteDowngrades.reverse();\n  neededNotificationDowngrades.reverse();\n\n  return StackingVersionConverter.fromData(\n    externalVersion,\n    platformVersion,\n    neededExecuteUpgrades,\n    neededExecuteDowngrades,\n    neededNotificationDowngrades,\n  );\n}\n\nfunction GetNeededTranslations<T>(\n  externalMajorVersion: number,\n  platformMajorVersion: number,\n  externalMinorVersion: number,\n  majorMinorTranslators: MajorMinorTranslators<T>,\n): Array<T> {\n  const neededTranslations: Array<T> = [];\n\n  for (let major = externalMajorVersion; major <= platformMajorVersion; major++) {\n    if (major in majorMinorTranslators) {\n      const start = major === externalMajorVersion ? externalMinorVersion : 0;\n      const maximumMinorVersion = GetMaximumMinorIndex(Object.keys(majorMinorTranslators[major]));\n      for (let minor = start; minor <= maximumMinorVersion; minor++) {\n        if (minor in majorMinorTranslators[major]) {\n          neededTranslations.push(...majorMinorTranslators[major][minor]);\n        }\n      }\n    }\n  }\n\n  return neededTranslations;\n}\n\nexport function GetMaximumMinorIndex(minorVersions: Array<string>): number {\n  return minorVersions.map((a) => Number(a)).reduce((a, b) => (a > b ? a : b));\n}\n","import { ExecuteParameters, ExecuteResponse, ExtensionBootstrapInfo, Notification, VerbId } from '../JsApiInternalContract';\nimport { VisualId } from '../contract/Models';\nimport { NotificationId } from '../contract/Notifications';\n\n// tslint:disable:no-any\n\n/** This function is called when we receive old vers and parameters from the external before we send it to platform */\nexport type UpgradeExecuteCall = (verb: VerbId, parameters: ExecuteParameters) => { verb: VerbId; parameters: ExecuteParameters };\n\n/** This function is called when we received a response back from platform and we need to downgrade it to external's version */\nexport type DowngradeExecuteReturn = (executeResponse: ExecuteResponse) => ExecuteResponse;\n\n/** This function is called when we receive a notification from platform and we need to downgrade it to external's version */\nexport type DowngradeNotification = (notification: Notification) => Notification;\n\n// This is where we will start to define some of these translations.\n// When modifying existing models, add the requisite conversion functions here, then use them\n// in the VersionConverterFactory implementation. Import old versions as you would any other module\n\n// 0 <-> Translations\n// Uncomment this line to import from the V0 definition of the API\n// import * as V0 from '@tableau-api-internal-contract-js_v0';\n\n// 1 <-> 2 Translations\n// Uncomment this line to import from the V1 definition of the API\n// import * as V1 from '@tableau-api-internal-contract-js_v1';\n\nexport function DowngradeWorksheetNames(executeResponse: ExecuteResponse): ExecuteResponse {\n  // Fix the dashboard friendly name issue. The structures are compatible,\n  // so we still return the original reply, but we copy the SheetInfo.name\n  // into the DashboardZone.name, where v1 wants to find it.\n\n  const bootstrapInfo = executeResponse.result as ExtensionBootstrapInfo;\n  if (bootstrapInfo.extensionDashboardInfo !== undefined) {\n    bootstrapInfo.extensionDashboardInfo.zones.forEach((zone) => {\n      if (zone.sheetInfo) {\n        zone.name = zone.sheetInfo.name;\n      }\n    });\n  }\n\n  return executeResponse;\n}\n\nexport function DowngradeFlipboardZoneID(notification: Notification): Notification {\n  // Fix the FlipboardZoneId issue. Older external versions still check for flipboardZoneIDs.\n  // When running against a newer server, if flipboardZoneId is absent, set it to default(0).\n\n  if (notification.notificationId === NotificationId.SelectedMarksChanged) {\n    const visualModel = notification.data as VisualId;\n    if (visualModel.flipboardZoneID === undefined) {\n      visualModel.flipboardZoneID = 0;\n    }\n  }\n\n  return notification;\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId } from '../../JsApiInternalContract';\nimport { ExternalContractVersionConverter } from './ExternalContractVersionConverter';\n\n// tslint:disable:no-any\n\n/**\n * This version converter doesn't actually do anything but is useful for testing or when we have\n * a matching platform and external version number\n */\nexport class ExternalIdentityVersionConverter implements ExternalContractVersionConverter {\n  public downgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    return {\n      verb: verb as VerbId,\n      parameters: parameters as ExecuteParameters,\n    };\n  }\n\n  public upgradeExecuteReturn(executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters): ExecuteResponse {\n    return executeResponse;\n  }\n\n  public upgradeNotification(notification: Notification): Notification {\n    return notification;\n  }\n}\n","import { ExecuteParameters, ExecuteResponse, Notification, VerbId, VersionNumber } from '../../JsApiInternalContract';\nimport { ExternalContractVersionConverter } from './ExternalContractVersionConverter';\nimport * as Translations from './ExternalVersionTranslations';\n\n// tslint:disable:no-any\n/**\n * The version converter is designed to allow the platform and external modules\n * to seemlessly communicate over two different versions of the internal API. This converter\n * supports external's version(minor) >= platform's version(minor). When executing\n * commands, it is used to downgrade the external representation to what platform knows on the way in\n * and upgrade the representations on the way out.\n */\nexport class ExternalStackingVersionConverter implements ExternalContractVersionConverter {\n  /**\n   * Creates a new instance of the StackingVersionConverter\n   *\n   * @param _externalVersion The version of the internal contract api-external-js is using\n   * @param _platformVersion The version of the internal contract the api-platform-js is using\n   * @param _downgradeExecuteCallTranslations Ordered list of the translations to perform when downgrading cmd parameters\n   * @param _upgradeExecuteReturnTranslations Ordered list of upgrade translations to perform after a cmd is executed\n   * @param _upgradeNotificationTranslations Ordered list of upgrade notfications to perform on events\n   */\n  public constructor(\n    private _externalVersion: VersionNumber,\n    private _platformVersion: VersionNumber,\n    private _downgradeExecuteCallTranslations: Array<Translations.DowngradeExecuteCall>,\n    private _upgradeExecuteReturnTranslations: Array<Translations.UpgradeExecuteReturn>,\n    private _upgradeNotificationTranslations: Array<Translations.UpgradeNotification>,\n  ) {\n    if (this._externalVersion.major > this._platformVersion.major) {\n      throw new Error(`Cannot convert between external version ${this._externalVersion.major}\n      and ${this._platformVersion.major}`);\n    }\n  }\n\n  public downgradeExecuteCall(verb: any, parameters: any): { verb: VerbId; parameters: ExecuteParameters } {\n    // Perform the downgrade of the verb and parameters to the level that platform is using\n    let downgraded = { verb: verb, parameters: parameters };\n    for (const downgradeTranslation of this._downgradeExecuteCallTranslations) {\n      downgraded = downgradeTranslation(downgraded.verb, downgraded.parameters);\n    }\n\n    return downgraded;\n  }\n\n  public upgradeExecuteReturn(executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters): ExecuteResponse {\n    // Perform the upgrade of the response to what the external module is expecting\n    let upgraded = executeResponse;\n    for (const upgradeTranslation of this._upgradeExecuteReturnTranslations) {\n      upgraded = upgradeTranslation(upgraded, verb, parameters);\n    }\n\n    return upgraded;\n  }\n\n  public upgradeNotification(notification: Notification): Notification {\n    // Perform the upgrade of notification to what the external module is expecting\n    let upgraded = notification;\n    for (const upgradeNotification of this._upgradeNotificationTranslations) {\n      upgraded = upgradeNotification(upgraded);\n    }\n\n    return upgraded;\n  }\n}\n","import { VersionNumber } from '../../JsApiInternalContract';\nimport { GetMaximumMinorIndex, MajorMinorTranslators, VersionEqualTo } from '../VersionConverterFactory';\nimport { ExternalContractVersionConverter } from './ExternalContractVersionConverter';\nimport { ExternalIdentityVersionConverter } from './ExternalIdentityVersionConverter';\nimport { ExternalStackingVersionConverter } from './ExternalStackingVersionConverter';\nimport * as TranslationsExternal from './ExternalVersionTranslations';\nimport {\n  DowngradeLogicalTableDataAsync,\n  DowngradeUnderlyingTableDataAsync,\n  UpgradeDataTableRowsAndColumns,\n  UpgradeDataTableTypes,\n} from './ExternalVersionTranslations';\n\n// A mapping from the current client version of internal-contract to an older platform version of the contract.\n// Each version bump can have an array of translations to perform in order.\n// These translations handle downgradeExecuteCall and upgradeExecuteReturn and are meant to be called on the\n// client/external side.\n// When updating the major or minor version of our internal-contract, you will need to update these data structures.\n// * If there are translations to add, add them to the version to 'upgrade from' or 'downgrade to'.\nexport const ExecuteMinorDowngradeCallExternal: MajorMinorTranslators<TranslationsExternal.DowngradeExecuteCall> = {\n  1: {\n    9: [], // Note that we put downgrades from 1.10 to 1.9 in the [1][9] bucket\n    13: [DowngradeUnderlyingTableDataAsync, DowngradeLogicalTableDataAsync],\n  },\n};\n\nexport const ExecuteMinorUpgradeReturnExternal: MajorMinorTranslators<TranslationsExternal.UpgradeExecuteReturn> = {\n  1: {\n    9: [UpgradeDataTableTypes], // Note that we put upgrades from 1.9 to 1.10 in the [1][9] bucket\n    29: [UpgradeDataTableRowsAndColumns], // 2021.1 was released with 1.29. Upgrade from 1.29 in the [1][29] bucket\n  },\n};\n\nexport const ExecuteMinorUpgradeNotification: MajorMinorTranslators<TranslationsExternal.UpgradeNotification> = {\n  1: {\n    9: [], // Note that we put upgrades from 1.9 to 1.10 in the [1][9] bucket\n  },\n};\n\n/**\n * Creates a new ExternalContractVersionConverter which has the ability to upgrade and downgrade\n * the contract between the two versions which are specified. If externalMajorVersion is less than\n * platformMajorVersion, an ExternalIdentityVersionConverter will be returned.\n * Handles upgrade/downgrade for both major and minor updates.\n *\n * @param externalVersion VersionNumber of the internal api which the external module is using\n * @param platformVersion VersionNumber of the internal api which the platform is using\n */\nexport function CreateExternalCompatibleVersionConverter(\n  externalVersion: VersionNumber,\n  platformVersion: VersionNumber,\n): ExternalContractVersionConverter {\n  return CreateExternalCompatibleVersionConverterWithTranslators(\n    externalVersion,\n    platformVersion,\n    ExecuteMinorDowngradeCallExternal,\n    ExecuteMinorUpgradeReturnExternal,\n    ExecuteMinorUpgradeNotification,\n  );\n}\n\n/**\n * Implementation of CreateExternalCompatibleVersionConverterWithTranslators.\n * This function takes the upgrade, downgrade arrays so that all the logic can be tested.\n *\n * @param externalVersion VersionNumber of the internal contract which the external module is using\n * @param platformVersion VersionNumber of the internal contract which the platform is using\n * @param upgrades MajorMinorTranslators for response upgrades\n * @param downgrades MajorMinorTranslators for execute call downgrades\n */\nexport function CreateExternalCompatibleVersionConverterWithTranslators(\n  externalVersion: VersionNumber,\n  platformVersion: VersionNumber,\n  downgrades: MajorMinorTranslators<TranslationsExternal.DowngradeExecuteCall>,\n  upgrades: MajorMinorTranslators<TranslationsExternal.UpgradeExecuteReturn>,\n  upgradeNotifications: MajorMinorTranslators<TranslationsExternal.UpgradeNotification>,\n): ExternalContractVersionConverter {\n  const externalMajorVersion: number = externalVersion.major;\n  const platformMajorVersion: number = platformVersion.major;\n  const platformMinorVersion: number = platformVersion.minor;\n\n  // This check is present in VersionConverterFactory. We throw the same error here as well.\n  // Hence we only need to check the minor versions for translations.\n  if (externalMajorVersion > platformMajorVersion) {\n    throw new Error(`External version must be less than or equal to platform version.\n    externalMajorVersion=${externalMajorVersion} platformMajorVersion=${platformMajorVersion}`);\n  }\n\n  if (externalMajorVersion < platformMajorVersion || VersionEqualTo(externalVersion, platformVersion)) {\n    return new ExternalIdentityVersionConverter();\n  }\n\n  // Walk the span between the versions we have here and collect the upgrade and downgrades necessary\n  const neededExecuteCallDowngrade: Array<TranslationsExternal.DowngradeExecuteCall> = GetNeededExternalTranslations(\n    platformMajorVersion,\n    platformMinorVersion,\n    downgrades,\n  );\n\n  const neededExecuteReturnUpgrades: Array<TranslationsExternal.UpgradeExecuteReturn> = GetNeededExternalTranslations(\n    platformMajorVersion,\n    platformMinorVersion,\n    upgrades,\n  );\n\n  const neededNotificationUpgrades: Array<TranslationsExternal.UpgradeNotification> = GetNeededExternalTranslations(\n    platformMajorVersion,\n    platformMinorVersion,\n    upgradeNotifications,\n  );\n\n  // Reverse the downgrade calls, so that we start the downgrade from the external version to the platform version\n  neededExecuteCallDowngrade.reverse();\n  return new ExternalStackingVersionConverter(\n    externalVersion,\n    platformVersion,\n    neededExecuteCallDowngrade,\n    neededExecuteReturnUpgrades,\n    neededNotificationUpgrades,\n  );\n}\n\nfunction GetNeededExternalTranslations<T>(\n  platformMajorVersion: number,\n  platformMinorVersion: number,\n  majorMinorTranslators: MajorMinorTranslators<T>,\n): Array<T> {\n  const neededTranslations: Array<T> = [];\n\n  if (platformMajorVersion in majorMinorTranslators) {\n    const start = platformMinorVersion;\n    const maximumMinorVersion = GetMaximumMinorIndex(Object.keys(majorMinorTranslators[platformMajorVersion]));\n    for (let minor = start; minor <= maximumMinorVersion; minor++) {\n      if (minor in majorMinorTranslators[platformMajorVersion]) {\n        neededTranslations.push(...majorMinorTranslators[platformMajorVersion][minor]);\n      }\n    }\n  }\n\n  return neededTranslations;\n}\n","import {\n  ApiShowDataTableSentinel,\n  DataHeader,\n  DataTable,\n  DataTypeConverter,\n  ExecuteParameters,\n  ExecuteResponse,\n  InternalTableauError,\n  Notification,\n  ParameterId,\n  SelectedMarksTable,\n  UnderlyingDataTable,\n  VerbId,\n} from '../../JsApiInternalContract';\n\n// tslint:disable:no-any\n\n/** This function is called when we receive newer version and parameters from the external before we send it to platform */\nexport type DowngradeExecuteCall = (verb: VerbId, parameters: ExecuteParameters) => { verb: VerbId; parameters: ExecuteParameters };\n\n/** This function is called when we receive a response back from platform and we need to upgrade it to external's version\n *  The verb and parameters provide a context to decide how to handle the response.\n */\nexport type UpgradeExecuteReturn = (executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters) => ExecuteResponse;\n\n/** This function is called when we receive a notification from platform and we need to upgrade it to external's version */\nexport type UpgradeNotification = (notification: Notification) => Notification;\n\n// 1.2 -> 1.0 Translations\n// Uncomment this line to import from the V1 definition of the API\n// import * as V1 from '@tableau-api-internal-contract-js_v1';\n\n/**\n * Prior to 2019.2 (internal-contract v1.9), DataValue.value were all strings.\n * Go through all DataValue objects. If we have a string, but the type should not be a string,\n * convert it to the correct type. The type of DataValue.value is 'any' in the contract, so\n * this change doesn't need any updates to classes or types.\n */\nexport function UpgradeDataTableTypes(executeResponse: ExecuteResponse, verb: VerbId, parameters: ExecuteParameters): ExecuteResponse {\n  if (!executeResponse) {\n    return executeResponse;\n  }\n\n  const oldUnderlyingDataTable = executeResponse.result as UnderlyingDataTable;\n  if (oldUnderlyingDataTable.data !== undefined && oldUnderlyingDataTable.isSummary !== undefined) {\n    convertDataValues(oldUnderlyingDataTable.data);\n    return executeResponse;\n  }\n\n  const oldSelectedMarksTable = executeResponse.result as SelectedMarksTable;\n  if (oldSelectedMarksTable.data !== undefined && Array.isArray(oldSelectedMarksTable.data)) {\n    oldSelectedMarksTable.data.forEach((marksTable) => {\n      convertDataValues(marksTable);\n    });\n    return executeResponse;\n  }\n\n  return executeResponse;\n}\n\n/**\n * Prior to 2020.2 (internal-contract v1.13 and older), worksheet.getUnderlyingTableDataAsync doesn't exist.\n * Map it to the older GetUnderlyingData verb and validate the the logical table Id.\n **/\nexport function DowngradeUnderlyingTableDataAsync(\n  verb: VerbId,\n  parameters: ExecuteParameters,\n): {\n  verb: VerbId;\n  parameters: ExecuteParameters;\n} {\n  if (verb === VerbId.GetUnderlyingTableData) {\n    validateParametersForObjectModel(verb, parameters);\n    verb = VerbId.GetUnderlyingData;\n  }\n  return {\n    verb: verb,\n    parameters: parameters,\n  };\n}\n\n/**\n * Prior to 2020.2 (internal-contract v1.13 and older), datasource.getLogicalTableDataAsync doesn't exist.\n * Map it to the older GetDataSourceData verb and validate the the logical table Id.\n **/\nexport function DowngradeLogicalTableDataAsync(\n  verb: VerbId,\n  parameters: ExecuteParameters,\n): {\n  verb: VerbId;\n  parameters: ExecuteParameters;\n} {\n  if (verb === VerbId.GetLogicalTableData) {\n    validateParametersForObjectModel(verb, parameters);\n    verb = VerbId.GetDataSourceData;\n  }\n  return {\n    verb: verb,\n    parameters: parameters,\n  };\n}\n\nfunction convertDataValues(table: DataTable): void {\n  // dataTable is a two-dimensional array of data. First index is the row, second is the column.\n  if (table === undefined || table.dataTable === undefined || !Array.isArray(table.dataTable)) {\n    return;\n  }\n\n  table.dataTable.forEach((row) => {\n    row.forEach((dataValue, columnIndex) => {\n      const value = dataValue.value;\n      if (value !== null) {\n        dataValue.value = DataTypeConverter.convertValueAsStringToValue(value, table.headers[columnIndex].dataType);\n      }\n    });\n  });\n}\n\n// ToDo: TFS1069027 Refactor input verbs & parameters in api-internal-contract Upgrade/Downgrade framework\nfunction validateParametersForObjectModel(verb: VerbId, parameters: ExecuteParameters): void {\n  if (parameters[ParameterId.LogicalTableId] !== ApiShowDataTableSentinel.SingleTableId) {\n    throw new Error(`Invalid logical table id passed to ${verb}.`) as InternalTableauError;\n  }\n}\n\n/**\n * Prior to 2021.2 (internal-contract v1.29 and below), getSummaryDataAsync did not support maxRows,\n * and any get...DataAsync did not support columnsToIncludeById.\n * Trim result to maxRows if it is included in the parameters for getSummaryDataAsync\n * Trim columns to columnsToInclude if included in the parameters for any get...DataAsync\n */\nexport function UpgradeDataTableRowsAndColumns(\n  executeResponse: ExecuteResponse,\n  verb: VerbId,\n  parameters: ExecuteParameters,\n): ExecuteResponse {\n  if (isGetSummaryDataVerb(verb) && parameters[ParameterId.MaxRows]) {\n    executeResponse = adjustDataRowLength(executeResponse, parameters[ParameterId.MaxRows] as number);\n  }\n\n  if (isGetTableDataVerb(verb) && parameters[ParameterId.ColumnsToIncludeById]) {\n    executeResponse = adjustDataColumns(executeResponse, parameters[ParameterId.ColumnsToIncludeById] as string[]);\n  }\n\n  return executeResponse;\n}\n\nfunction isGetSummaryDataVerb(verb: VerbId): boolean {\n  return verb === VerbId.GetDataSummaryData;\n}\n\nfunction isGetTableDataVerb(verb: VerbId): boolean {\n  return (\n    verb === VerbId.GetDataSummaryData ||\n    verb === VerbId.GetUnderlyingTableData ||\n    verb === VerbId.GetLogicalTableData ||\n    verb === VerbId.GetDataSourceData ||\n    verb === VerbId.GetUnderlyingData\n  );\n}\n\nfunction adjustDataRowLength(executeResponse: ExecuteResponse, maxRows: number): ExecuteResponse {\n  const underlyingDataTable = executeResponse.result as UnderlyingDataTable;\n  if (!underlyingDataTable.data || !Array.isArray(underlyingDataTable.data.dataTable)) {\n    return executeResponse;\n  }\n\n  if (maxRows > 0 && maxRows < underlyingDataTable.data.dataTable.length) {\n    underlyingDataTable.data.dataTable.length = maxRows;\n  }\n  return executeResponse;\n}\n\nfunction adjustDataColumns(executeResponse: ExecuteResponse, columnsToInclude: string[]): ExecuteResponse {\n  if (columnsToInclude.length === 0) {\n    return executeResponse;\n  }\n\n  // verify that we have a valid UnderlyingDataTable\n  const underlyingDataTable = executeResponse.result as UnderlyingDataTable;\n  if (!underlyingDataTable.data || !Array.isArray(underlyingDataTable.data.dataTable) || !Array.isArray(underlyingDataTable.data.headers)) {\n    return executeResponse;\n  }\n\n  // 1. filter the headers to only columnsToInclude\n  // 2. use the new headers to filter all rows\n  // 3. update the indices in our new headers\n  const newHeaders: DataHeader[] = underlyingDataTable.data.headers.filter((header, index) =>\n    columnsToInclude.find((name) => name === header.fieldName),\n  );\n  underlyingDataTable.data.dataTable.forEach((row, index) => {\n    underlyingDataTable.data.dataTable[index] = row.filter(\n      (value, valueIndex) => newHeaders.findIndex((header) => header.index === valueIndex) !== -1,\n    );\n  });\n  let newIndex = 0;\n  underlyingDataTable.data.headers = newHeaders.map((header) => {\n    header.index = newIndex++;\n    return header;\n  });\n\n  return executeResponse;\n}\n","// Export everything which had been previously in the api-shared module\n\nexport { ApiVersion } from './ApiShared/ApiVersion';\nexport * from './ApiShared/CrossFrame/CrossFrameBootstrap';\nexport { CrossFrameDispatcher } from './ApiShared/CrossFrame/CrossFrameDispatcher';\nexport { DataSource } from './ApiShared/DataSource';\nexport { ExternalToInternalEnumMappings } from './ApiShared/EnumMappings/ExternalToInternalEnumMappings';\nexport { InternalToExternalEnumMappings } from './ApiShared/EnumMappings/InternalToExternalEnumMappings';\nexport { EventListenerManager } from './ApiShared/EventListenerManager';\nexport { Field } from './ApiShared/Field';\nexport { CustomViewImpl } from './ApiShared/Impl/CustomViewImpl';\nexport { DashboardImpl } from './ApiShared/Impl/DashboardImpl';\nexport { DashboardObjectImpl } from './ApiShared/Impl/DashboardObjectImpl';\nexport { DataSourceImpl } from './ApiShared/Impl/DataSourceImpl';\nexport { ParameterImpl } from './ApiShared/Impl/ParameterImpl';\nexport { SheetImpl } from './ApiShared/Impl/SheetImpl';\nexport { SheetInfoImpl } from './ApiShared/Impl/SheetInfoImpl';\nexport { SingleEventManagerImpl } from './ApiShared/Impl/SingleEventManagerImpl';\nexport { StoryImpl } from './ApiShared/Impl/StoryImpl';\nexport { StoryPointImpl } from './ApiShared/Impl/StoryPointImpl';\nexport { StoryPointInfoImpl } from './ApiShared/Impl/StoryPointInfoImpl';\nexport { WorkbookImpl } from './ApiShared/Impl/WorkbookImpl';\nexport { WorksheetImpl } from './ApiShared/Impl/WorksheetImpl';\nexport { Point } from './ApiShared/Point';\nexport { AnnotationService } from './ApiShared/Services/AnnotationService';\nexport { DataSourceService } from './ApiShared/Services/DataSourceService';\nexport { ExportService } from './ApiShared/Services/ExportService';\nexport { FilterService } from './ApiShared/Services/FilterService';\nexport { GetDataService } from './ApiShared/Services/GetDataService';\nexport { NotificationService, UnregisterFn } from './ApiShared/Services/NotificationService';\nexport { ParametersService } from './ApiShared/Services/ParametersService';\nexport * from './ApiShared/Services/RegisterAllSharedServices';\nexport { SelectionService } from './ApiShared/Services/SelectionService';\nexport * from './ApiShared/Services/ServiceRegistry';\nexport { SizeService } from './ApiShared/Services/SizeService';\nexport { StoryActivationService } from './ApiShared/Services/StoryActivationService';\nexport { VizService } from './ApiShared/Services/VizService';\nexport { ClientInfoServiceImpl } from './ApiShared/Services/impl/ClientInfoServiceImpl';\nexport { NotificationServiceImpl } from './ApiShared/Services/impl/NotificationServiceImpl';\nexport { NotificationServiceImplBase, Registration } from './ApiShared/Services/impl/NotificationServiceImplBase';\nexport { ServiceImplBase } from './ApiShared/Services/impl/ServiceImplBase';\nexport { SizeServiceImpl } from './ApiShared/Services/impl/SizeServiceImpl';\nexport { StoryActivationServiceImpl } from './ApiShared/Services/impl/StoryActivationServiceImpl';\nexport { SingleEventManager } from './ApiShared/SingleEventManager';\nexport { TableauError } from './ApiShared/TableauError';\nexport { Deferred } from './ApiShared/Utils/Deferred';\nexport { ErrorHelpers } from './ApiShared/Utils/ErrorHelpers';\nexport { ExportHelpers } from './ApiShared/Utils/ExportHelpers';\nexport { SheetUtils } from './ApiShared/Utils/SheetUtils';\nexport { VersionNumber } from './ApiShared/VersionNumber';\nexport { VersionedExternalApiDispatcher } from './VersionedExternalApiDispatcher';\n","import { VersionNumber } from './VersionNumber';\nimport { VersionNumberContract } from './VersionNumberContract';\n\n/**\n * This is the singleton wrapper of VersionNumber\n */\nexport class ApiVersion {\n  // Using some webpack tricks, we can inject this version into our code (kinda like c++ preprocessor stuff)\n  private static _instance: VersionNumberContract;\n\n  /**\n   * Gets the singleton instance of the version number.\n   */\n  public static get Instance(): VersionNumberContract {\n    return ApiVersion._instance;\n  }\n\n  public static SetVersionNumber(numString: string, isAlpha: boolean): void {\n    ApiVersion._instance = new VersionNumber(numString, isAlpha);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ConnectionDescriptionSummary } from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of a connection summary.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class ConnectionSummary implements Contract.ConnectionSummary {\n  public constructor(private _connectionInfo: ConnectionDescriptionSummary) {}\n\n  public get name(): string {\n    return this._connectionInfo.name;\n  }\n\n  public get id(): string {\n    return this._connectionInfo.id;\n  }\n\n  public get serverURI(): string {\n    return this._connectionInfo.serverURI;\n  }\n\n  public get type(): string {\n    return this._connectionInfo.type;\n  }\n}\n","import * as Contract from '@tableau/api-internal-contract-js';\nimport {\n  CommandResponseMessage,\n  CrossFrameMessenger,\n  InitializationOptions,\n  MESSAGING_VERSION as ApiMessagingVersion,\n} from '@tableau/api-internal-contract-js';\nimport { CrossFrameDispatcher } from './CrossFrameDispatcher';\n\n// Checks to see if we are running in an iframe currently: https://stackoverflow.com/a/326076/8821153\nfunction inIframe(thisWindow: Window): boolean {\n  try {\n    return thisWindow.self !== thisWindow.parent;\n  } catch (e) {\n    return true;\n  }\n}\n\n/**\n * Attempts to bootstrap the extension with a cross-frame parent where Tableau is running\n *\n * @param thisWindow The window which we are running in (injected for unit testing purposes)\n * @param internalContractVersion The version number of the internal contract we are using\n * @returns A promise which is doing the actual bootstrapping\n */\nexport function doCrossFrameBootstrap(\n  thisWindow: Window,\n  internalContractVersion: Contract.VersionNumber,\n  options: InitializationOptions,\n): Promise<Contract.InternalApiDispatcherFactory> {\n  return new Promise<Contract.InternalApiDispatcherFactory>((resolve, reject) => {\n    let parent: Window;\n\n    // Normally, we are running inside an iframe.  The exception to this is\n    // when we are running as an extension inside a dialog as part of the UINamespace\n    // functionality.  In that case, we want the opener of this window rather than the parent.\n    if (!inIframe(thisWindow)) {\n      parent = thisWindow.opener;\n    } else {\n      parent = thisWindow.parent;\n    }\n\n    if (!parent) {\n      reject('This extension is not running inside an iframe, desktop, or popup window. Initialization failed.');\n    }\n\n    // Create the messenger which will do he communication between this window and our parent\n    // Since we don't know where we are running yet, we have to make this initial origin '*'. Once\n    // we have successfully initialized our extension, we will limit where we send messages\n    const messenger = new CrossFrameMessenger(thisWindow, parent, '*');\n\n    // Prepare to send an initialization message to the parent frame\n    const initializationMessage = messenger.prepareInitializationMessage(internalContractVersion, ApiMessagingVersion, options);\n\n    // When we receive a response back from the parent, we check to make sure the guids match and then we know\n    // that the parent is aware of us and we can start communicating\n    messenger.setCommandResponseMessageHandler(function (msg: CommandResponseMessage): void {\n      // Verify we are getting a response from our initialize message\n      if (msg.commandGuid === initializationMessage.messageGuid) {\n        // The versioning of the dispatcher happens on the other side of our frame, and\n        // in a wrapper on this side. This one doesn't have any version knowledge.\n        const dispatcherFactory = () => new CrossFrameDispatcher(messenger);\n        resolve(dispatcherFactory);\n      }\n    });\n\n    // Now that our handlers are ready, start listening and send our initialization message\n    messenger.startListening();\n    initializationMessage.send();\n  });\n}\n","import { EmbeddingErrorCodes } from '@tableau/api-external-contract-js';\nimport {\n  CommandResponseMessage,\n  ExecuteParameters,\n  ExecuteResponse,\n  InternalApiDispatcher,\n  Messenger,\n  Model,\n  NotificationHandler,\n  NotificationMessage,\n  VerbId,\n} from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * This is an implementation of the InternalApiDispatcher interface which functions by passing messages\n * across a frame boundary. This is usually between the code where our javscript library has been included\n * by a 3rd party dev and another frame where Tableau server has content.\n */\nexport class CrossFrameDispatcher implements InternalApiDispatcher {\n  // Collection of pending promises which are waiting to be resolved. When we receive a response back from the other frame,\n  // these promises can be either resolved or rejected\n  private _pendingPromises: { [messageGuid: string]: { resolve: (response: ExecuteResponse) => void; reject: (error: Model) => void } } =\n    {};\n\n  // The collection of notification handlers which have been registered with this dispatcher\n  private _notificationHandlers: Array<NotificationHandler> = [];\n\n  /**\n   * Creates an instance of CrossFrameDispatcher which will use the given messenger to communicate\n   * @param _messenger an instantiated and listening messenger object\n   */\n  public constructor(private _messenger: Messenger) {\n    if (!this._messenger) {\n      throw 'Missing messenger object';\n    }\n\n    // Set up our message handlers. We only care about incoming notifications and command responses\n    this._messenger.setCommandResponseMessageHandler(this.onCommandResponse.bind(this));\n    this._messenger.setNotificationMessageHandler(this.onNotification.bind(this));\n  }\n\n  ////// Start InternalApiDispatcher implementation\n\n  public execute(verb: VerbId, parameters: ExecuteParameters): Promise<ExecuteResponse> {\n    // To execute a verb, we first prepare a command message and then define a promise.\n    const preparedMessage = this._messenger.prepareCommandMessage(verb, parameters);\n    const promise = new Promise<ExecuteResponse>((resolve, reject) => {\n      // Save off the pending promise by the messageGuid we are about to send. When a response is\n      // received, we'll be able to resolve this promise with the result\n      this._pendingPromises[preparedMessage.messageGuid] = { resolve: resolve, reject: reject };\n    });\n\n    // Actually send the message and return the promise\n    preparedMessage.send();\n    return promise;\n  }\n\n  public registerNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers.push(handler);\n  }\n\n  public unregisterNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers = this._notificationHandlers.filter((h) => h !== handler);\n  }\n\n  ////// End InternalApiDispatcher implementation\n\n  private onCommandResponse(response: CommandResponseMessage): void {\n    // We got a command response, look through the pending promises and resolve\n    if (Object.keys(this._pendingPromises).indexOf(response.commandGuid) < 0) {\n      return; // We don't have any reference to this command, just return\n    }\n\n    const pendingPromise = this._pendingPromises[response.commandGuid];\n\n    // If we have an error defined, reject the promise\n    if (response.error) {\n      pendingPromise.reject(response.error);\n    }\n\n    // If we have data defined, resolve the promise\n    if (response.data) {\n      pendingPromise.resolve({ result: response.data });\n    }\n\n    // Clean up our pending promises object\n    delete this._pendingPromises[response.commandGuid];\n  }\n\n  private onNotification(notificationMessage: NotificationMessage): void {\n    // Go through each notification handler we have registered and let them know a notification came in\n    for (const handler of this._notificationHandlers) {\n      try {\n        handler({ notificationId: notificationMessage.notificationId, data: notificationMessage.data });\n      } catch (e) {\n        // Incase of a IncompatibleVersionError, re-throw the error.\n        if ((e as TableauError).errorCode === EmbeddingErrorCodes.IncompatibleVersionError) {\n          throw e;\n        }\n        // Else Ignore  so if one handler errors, the other still get the message.\n      }\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataSourceImpl } from './Impl/DataSourceImpl';\n\nexport class DataSource implements Contract.DataSource {\n  public constructor(private _dataSourceImpl: DataSourceImpl) {}\n\n  public get name(): string {\n    return this._dataSourceImpl.name;\n  }\n\n  public get id(): string {\n    return this._dataSourceImpl.id;\n  }\n\n  public get fields(): Array<Contract.Field> {\n    return this._dataSourceImpl.fields;\n  }\n\n  public get extractUpdateTime(): string | undefined {\n    return this._dataSourceImpl.extractUpdateTime;\n  }\n\n  public get isExtract(): boolean {\n    return this._dataSourceImpl.isExtract;\n  }\n\n  public get isPublished(): boolean | undefined {\n    return this._dataSourceImpl.isPublished;\n  }\n\n  public publishedUrl(): string | undefined {\n    return this._dataSourceImpl.publishedUrl();\n  }\n\n  public refreshAsync(): Promise<void> {\n    return this._dataSourceImpl.refreshAsync();\n  }\n\n  public getActiveTablesAsync(): Promise<Array<Contract.TableSummary>> {\n    console.warn('DataSource.getActiveTablesAsync is deprecated. Please use DataSource.getLogicalTablesAsync.');\n    return this._dataSourceImpl.getActiveTablesAsync();\n  }\n\n  public getConnectionSummariesAsync(): Promise<Array<Contract.ConnectionSummary>> {\n    return this._dataSourceImpl.getConnectionSummariesAsync();\n  }\n\n  public getUnderlyingDataAsync(options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    console.warn(\n      'DataSource.getUnderlyingDataAsync is deprecated. Please use ' +\n        'DataSource.getLogicalTablesAsync and DataSource.getLogicalTableDataAsync.',\n    );\n    return this._dataSourceImpl.getUnderlyingDataAsync(options);\n  }\n\n  public getLogicalTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    return this._dataSourceImpl.getLogicalTablesAsync();\n  }\n\n  public getLogicalTableDataAsync(logicalTableId: string, options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    return this._dataSourceImpl.getLogicalTableDataAsync(logicalTableId, options);\n  }\n\n  public getLogicalTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount?: number,\n    options?: Contract.DataSourceUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    return this._dataSourceImpl.getLogicalTableDataReaderAsync(logicalTableId, pageRowCount, options);\n  }\n}\n","import {\n  DateRangeType as ExternalDateRangeType,\n  DialogStyle as ExternalDialogStyle,\n  FilterDomainType as ExternalDomainType,\n  FilterNullOption as ExternalNullOption,\n  FilterUpdateType as ExternalFilterUpdateType,\n  IncludeDataValuesOption,\n  PeriodType,\n  ReplaySpeedType,\n  SheetType as ExternalSheetType,\n  ZoneVisibilityType,\n} from '@tableau/api-external-contract-js';\nimport {\n  ApiShowDataTableFormat,\n  DateRangeType as InternalDateRangeType,\n  DateStepPeriod,\n  DialogStyle as InternalDialogStyle,\n  FilterDomainType as InternalDomainType,\n  FilterNullOption as InternalNullOption,\n  FilterUpdateType as InternalFilterUpdateType,\n  SheetType as InternalSheetType,\n} from '@tableau/api-internal-contract-js';\nimport { EnumConverter } from '../Utils/EnumConverter';\n\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\n/**\n * Maps enums used by the external-api-contract to the enums used\n * in the internal-api-contract, which developers code against.\n */\nexport class ExternalToInternalEnumMappings {\n  public static filterDomainType = new EnumConverter<ExternalDomainType, InternalDomainType>({\n    [ExternalDomainType.Relevant]: InternalDomainType.Relevant,\n    [ExternalDomainType.Database]: InternalDomainType.Database,\n  });\n\n  public static nullOptions = new EnumConverter<ExternalNullOption, InternalNullOption>({\n    [ExternalNullOption.AllValues]: InternalNullOption.AllValues,\n    [ExternalNullOption.NonNullValues]: InternalNullOption.NonNullValues,\n    [ExternalNullOption.NullValues]: InternalNullOption.NullValues,\n  });\n\n  public static filterUpdateType = new EnumConverter<ExternalFilterUpdateType, InternalFilterUpdateType>({\n    [ExternalFilterUpdateType.Add]: InternalFilterUpdateType.Add,\n    [ExternalFilterUpdateType.All]: InternalFilterUpdateType.All,\n    [ExternalFilterUpdateType.Remove]: InternalFilterUpdateType.Remove,\n    [ExternalFilterUpdateType.Replace]: InternalFilterUpdateType.Replace,\n  });\n\n  public static setVisibilityType = new EnumConverter<ZoneVisibilityType, boolean>({\n    [ZoneVisibilityType.Show]: true,\n    [ZoneVisibilityType.Hide]: false,\n  });\n\n  public static setReplaySpeedType = new EnumConverter<ReplaySpeedType, number>({\n    // these numbers are duration multipliers\n    // 2.0, for example, doubles the duration of the replay, slowing it down to 0.5x speed\n    [ReplaySpeedType.Slow]: 2.0,\n    [ReplaySpeedType.Normal]: 1.0,\n    [ReplaySpeedType.Fast]: 0.5,\n  });\n\n  public static sheetType = new EnumConverter<ExternalSheetType, InternalSheetType>({\n    [ExternalSheetType.Dashboard]: InternalSheetType.Dashboard,\n    [ExternalSheetType.Worksheet]: InternalSheetType.Worksheet,\n    [ExternalSheetType.Story]: InternalSheetType.Story,\n  });\n\n  public static showDataTableFormatType = new EnumConverter<IncludeDataValuesOption, ApiShowDataTableFormat>({\n    [IncludeDataValuesOption.AllValues]: ApiShowDataTableFormat.NativeAndFormattedValues,\n    [IncludeDataValuesOption.OnlyNativeValues]: ApiShowDataTableFormat.NativeValuesOnly,\n    [IncludeDataValuesOption.OnlyFormattedValues]: ApiShowDataTableFormat.FormattedValuesOnly,\n  });\n\n  public static periodType = new EnumConverter<PeriodType, DateStepPeriod>({\n    [PeriodType.Years]: DateStepPeriod.Years,\n    [PeriodType.Quarters]: DateStepPeriod.Quarters,\n    [PeriodType.Months]: DateStepPeriod.Months,\n    [PeriodType.Weeks]: DateStepPeriod.Weeks,\n    [PeriodType.Days]: DateStepPeriod.Days,\n    [PeriodType.Hours]: DateStepPeriod.Hours,\n    [PeriodType.Minutes]: DateStepPeriod.Minutes,\n    [PeriodType.Seconds]: DateStepPeriod.Seconds,\n  });\n\n  public static dateRangeType = new EnumConverter<ExternalDateRangeType, InternalDateRangeType>({\n    [ExternalDateRangeType.Last]: InternalDateRangeType.Last,\n    [ExternalDateRangeType.LastN]: InternalDateRangeType.LastN,\n    [ExternalDateRangeType.Next]: InternalDateRangeType.Next,\n    [ExternalDateRangeType.NextN]: InternalDateRangeType.NextN,\n    [ExternalDateRangeType.Current]: InternalDateRangeType.Current,\n    [ExternalDateRangeType.ToDate]: InternalDateRangeType.ToDate,\n  });\n\n  public static dialogStyles = new EnumConverter<ExternalDialogStyle, InternalDialogStyle>({\n    [ExternalDialogStyle.Window]: InternalDialogStyle.Window,\n    [ExternalDialogStyle.Modal]: InternalDialogStyle.Modal,\n    [ExternalDialogStyle.Modeless]: InternalDialogStyle.Modeless,\n  });\n}\n/* tslint:enable:typedef */\n","import {\n  AnnotationType as ExternalAnnotationType,\n  ClassNameKey as ExternalClassNameKey,\n  ColumnType as ExternalColumnType,\n  DashboardObjectType as ExternalDashboardObjectType,\n  DataType as ExternalDataType,\n  PeriodType as ExternalDatePeriod,\n  DateRangeType as ExternalDateRangeType,\n  ErrorCodes as ExternalErrorCodes,\n  ExtensionContext as ExternalExtensionsContext,\n  ExtensionMode as ExternalExtensionsMode,\n  FieldAggregationType as ExternalFieldAggregationType,\n  FieldRoleType as ExternalFieldRoleType,\n  FilterType as ExternalFilterType,\n  FilterUpdateType as ExternalFilterUpdateType,\n  HierarchicalLevelSelectionState as ExternalHierarchicalLevelSelectionState,\n  MarkType as ExternalMarkType,\n  ParameterValueType as ExternalParameterValueType,\n  SheetType as ExternalSheetType,\n} from '@tableau/api-external-contract-js';\nimport {\n  AnnotateEnum as InternalAnnotationType,\n  ClassNameKey as InternalClassNameKey,\n  ColumnType as InternalColumnType,\n  DashboardObjectType as InternalDashboardObjectType,\n  DataType as InternalDataType,\n  DateRangeType as InternalDateRangeType,\n  DateStepPeriod as InternalDateStepPeriod,\n  DomainRestrictionType as InternalDomainRestrictionType,\n  ErrorCodes as InternalErrorCodes,\n  ExtensionContext as InternalExtensionsContext,\n  ExtensionMode as InternalExtensionsMode,\n  FieldAggregationType as InternalFieldAggregationType,\n  FieldRoleType as InternalFieldRoleType,\n  FilterType as InternalFilterType,\n  FilterUpdateType as InternalFilterUpdateType,\n  HierarchicalLevelSelectionState as InternalHierarchicalLevelSelectionState,\n  MarkType as InternalMarkType,\n  SheetType as InternalSheetType,\n} from '@tableau/api-internal-contract-js';\nimport { EnumConverter } from '../Utils/EnumConverter';\n\n/* tslint:disable:typedef - Disable this to make declaring these classes a bit easier */\n/**\n * Maps enums used by the internal-api-contract to the enums used\n * in the external-api-contract, which developers code against.\n */\nexport class InternalToExternalEnumMappings {\n  public static extensionContext = new EnumConverter<InternalExtensionsContext, ExternalExtensionsContext>({\n    [InternalExtensionsContext.Desktop]: ExternalExtensionsContext.Desktop,\n    [InternalExtensionsContext.Server]: ExternalExtensionsContext.Server,\n  });\n\n  public static extensionMode = new EnumConverter<InternalExtensionsMode, ExternalExtensionsMode>({\n    [InternalExtensionsMode.Authoring]: ExternalExtensionsMode.Authoring,\n    [InternalExtensionsMode.Viewing]: ExternalExtensionsMode.Viewing,\n  });\n\n  public static columnType = new EnumConverter<InternalColumnType, ExternalColumnType>({\n    [InternalColumnType.Continuous]: ExternalColumnType.Continuous,\n    [InternalColumnType.Discrete]: ExternalColumnType.Discrete,\n    [InternalColumnType.Unknown]: ExternalColumnType.Unknown,\n  });\n\n  public static fieldAggregationType = new EnumConverter<InternalFieldAggregationType, ExternalFieldAggregationType>({\n    [InternalFieldAggregationType.Attr]: ExternalFieldAggregationType.Attr,\n    [InternalFieldAggregationType.Avg]: ExternalFieldAggregationType.Avg,\n    [InternalFieldAggregationType.Collect]: ExternalFieldAggregationType.Collect,\n    [InternalFieldAggregationType.Count]: ExternalFieldAggregationType.Count,\n    [InternalFieldAggregationType.Countd]: ExternalFieldAggregationType.Countd,\n    [InternalFieldAggregationType.Day]: ExternalFieldAggregationType.Day,\n    [InternalFieldAggregationType.End]: ExternalFieldAggregationType.End,\n    [InternalFieldAggregationType.Hour]: ExternalFieldAggregationType.Hour,\n    [InternalFieldAggregationType.InOut]: ExternalFieldAggregationType.InOut,\n    [InternalFieldAggregationType.Kurtosis]: ExternalFieldAggregationType.Kurtosis,\n    [InternalFieldAggregationType.Max]: ExternalFieldAggregationType.Max,\n    [InternalFieldAggregationType.Mdy]: ExternalFieldAggregationType.Mdy,\n    [InternalFieldAggregationType.Median]: ExternalFieldAggregationType.Median,\n    [InternalFieldAggregationType.Min]: ExternalFieldAggregationType.Min,\n    [InternalFieldAggregationType.Minute]: ExternalFieldAggregationType.Minute,\n    [InternalFieldAggregationType.MonthYear]: ExternalFieldAggregationType.MonthYear,\n    [InternalFieldAggregationType.None]: ExternalFieldAggregationType.None,\n    [InternalFieldAggregationType.Qtr]: ExternalFieldAggregationType.Qtr,\n    [InternalFieldAggregationType.Quart1]: ExternalFieldAggregationType.Quart1,\n    [InternalFieldAggregationType.Quart3]: ExternalFieldAggregationType.Quart3,\n    [InternalFieldAggregationType.Second]: ExternalFieldAggregationType.Second,\n    [InternalFieldAggregationType.Skewness]: ExternalFieldAggregationType.Skewness,\n    [InternalFieldAggregationType.Stdev]: ExternalFieldAggregationType.Stdev,\n    [InternalFieldAggregationType.Stdevp]: ExternalFieldAggregationType.Stdevp,\n    [InternalFieldAggregationType.Sum]: ExternalFieldAggregationType.Sum,\n    [InternalFieldAggregationType.TruncDay]: ExternalFieldAggregationType.TruncDay,\n    [InternalFieldAggregationType.TruncHour]: ExternalFieldAggregationType.TruncHour,\n    [InternalFieldAggregationType.TruncMinute]: ExternalFieldAggregationType.TruncMinute,\n    [InternalFieldAggregationType.TruncMonth]: ExternalFieldAggregationType.TruncMonth,\n    [InternalFieldAggregationType.TruncQtr]: ExternalFieldAggregationType.TruncQtr,\n    [InternalFieldAggregationType.TruncSecond]: ExternalFieldAggregationType.TruncSecond,\n    [InternalFieldAggregationType.TruncWeek]: ExternalFieldAggregationType.TruncWeek,\n    [InternalFieldAggregationType.TruncYear]: ExternalFieldAggregationType.TruncYear,\n    [InternalFieldAggregationType.User]: ExternalFieldAggregationType.User,\n    [InternalFieldAggregationType.Var]: ExternalFieldAggregationType.Var,\n    [InternalFieldAggregationType.Varp]: ExternalFieldAggregationType.Varp,\n    [InternalFieldAggregationType.Week]: ExternalFieldAggregationType.Week,\n    [InternalFieldAggregationType.Weekday]: ExternalFieldAggregationType.Weekday,\n    [InternalFieldAggregationType.Year]: ExternalFieldAggregationType.Year,\n  });\n\n  public static fieldRoleType = new EnumConverter<InternalFieldRoleType, ExternalFieldRoleType>({\n    [InternalFieldRoleType.Dimension]: ExternalFieldRoleType.Dimension,\n    [InternalFieldRoleType.Measure]: ExternalFieldRoleType.Measure,\n    [InternalFieldRoleType.Unknown]: ExternalFieldRoleType.Unknown,\n  });\n\n  public static sheetType = new EnumConverter<InternalSheetType, ExternalSheetType>({\n    [InternalSheetType.Dashboard]: ExternalSheetType.Dashboard,\n    [InternalSheetType.Story]: ExternalSheetType.Story,\n    [InternalSheetType.Worksheet]: ExternalSheetType.Worksheet,\n  });\n\n  public static dashboardObjectType = new EnumConverter<InternalDashboardObjectType, ExternalDashboardObjectType>({\n    [InternalDashboardObjectType.Extension]: ExternalDashboardObjectType.Extension,\n    [InternalDashboardObjectType.Blank]: ExternalDashboardObjectType.Blank,\n    [InternalDashboardObjectType.Image]: ExternalDashboardObjectType.Image,\n    [InternalDashboardObjectType.Legend]: ExternalDashboardObjectType.Legend,\n    [InternalDashboardObjectType.PageFilter]: ExternalDashboardObjectType.PageFilter,\n    [InternalDashboardObjectType.ParameterControl]: ExternalDashboardObjectType.ParameterControl,\n    [InternalDashboardObjectType.QuickFilter]: ExternalDashboardObjectType.QuickFilter,\n    [InternalDashboardObjectType.Text]: ExternalDashboardObjectType.Text,\n    [InternalDashboardObjectType.Title]: ExternalDashboardObjectType.Title,\n    [InternalDashboardObjectType.WebPage]: ExternalDashboardObjectType.WebPage,\n    [InternalDashboardObjectType.Worksheet]: ExternalDashboardObjectType.Worksheet,\n  });\n\n  public static dataType = new EnumConverter<InternalDataType, ExternalDataType>({\n    [InternalDataType.Bool]: ExternalDataType.Bool,\n    [InternalDataType.Date]: ExternalDataType.Date,\n    [InternalDataType.DateTime]: ExternalDataType.DateTime,\n    [InternalDataType.Float]: ExternalDataType.Float,\n    [InternalDataType.Int]: ExternalDataType.Int,\n    [InternalDataType.Spatial]: ExternalDataType.Spatial,\n    [InternalDataType.String]: ExternalDataType.String,\n  });\n\n  public static filterUpdateType = new EnumConverter<InternalFilterUpdateType, ExternalFilterUpdateType>({\n    [InternalFilterUpdateType.Add]: ExternalFilterUpdateType.Add,\n    [InternalFilterUpdateType.All]: ExternalFilterUpdateType.All,\n    [InternalFilterUpdateType.Remove]: ExternalFilterUpdateType.Remove,\n    [InternalFilterUpdateType.Replace]: ExternalFilterUpdateType.Replace,\n  });\n\n  public static allowableValues = new EnumConverter<InternalDomainRestrictionType, ExternalParameterValueType>({\n    [InternalDomainRestrictionType.All]: ExternalParameterValueType.All,\n    [InternalDomainRestrictionType.List]: ExternalParameterValueType.List,\n    [InternalDomainRestrictionType.Range]: ExternalParameterValueType.Range,\n  });\n\n  public static dateStepPeriod = new EnumConverter<InternalDateStepPeriod, ExternalDatePeriod>({\n    [InternalDateStepPeriod.Years]: ExternalDatePeriod.Years,\n    [InternalDateStepPeriod.Quarters]: ExternalDatePeriod.Quarters,\n    [InternalDateStepPeriod.Months]: ExternalDatePeriod.Months,\n    [InternalDateStepPeriod.Weeks]: ExternalDatePeriod.Weeks,\n    [InternalDateStepPeriod.Days]: ExternalDatePeriod.Days,\n    [InternalDateStepPeriod.Hours]: ExternalDatePeriod.Hours,\n    [InternalDateStepPeriod.Minutes]: ExternalDatePeriod.Minutes,\n    [InternalDateStepPeriod.Seconds]: ExternalDatePeriod.Seconds,\n  });\n\n  public static dateRangeType = new EnumConverter<InternalDateRangeType, ExternalDateRangeType>({\n    [InternalDateRangeType.Current]: ExternalDateRangeType.Current,\n    [InternalDateRangeType.Last]: ExternalDateRangeType.Last,\n    [InternalDateRangeType.LastN]: ExternalDateRangeType.LastN,\n    [InternalDateRangeType.Next]: ExternalDateRangeType.Next,\n    [InternalDateRangeType.NextN]: ExternalDateRangeType.NextN,\n    [InternalDateRangeType.ToDate]: ExternalDateRangeType.ToDate,\n  });\n\n  public static errorCode = new EnumConverter<InternalErrorCodes, ExternalErrorCodes>(\n    {\n      [InternalErrorCodes.INITIALIZATION_ERROR]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.INTERNAL_ERROR]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.MISSING_ENUM_MAPPING]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.MISSING_PARAMETER]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.PERMISSION_DENIED]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.PRES_MODEL_PARSING_ERROR]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.UNKNOWN_VERB_ID]: ExternalErrorCodes.InternalError,\n      [InternalErrorCodes.VERSION_NOT_CONFIGURED]: ExternalErrorCodes.APINotInitialized,\n      [InternalErrorCodes.VISIBILITY_ERROR]: ExternalErrorCodes.VisibilityError,\n    },\n    ExternalErrorCodes.InternalError,\n  );\n\n  public static filterType = new EnumConverter<InternalFilterType, ExternalFilterType>({\n    [InternalFilterType.Categorical]: ExternalFilterType.Categorical,\n    [InternalFilterType.Range]: ExternalFilterType.Range,\n    [InternalFilterType.RelativeDate]: ExternalFilterType.RelativeDate,\n    [InternalFilterType.Hierarchical]: ExternalFilterType.Hierarchical,\n  });\n\n  public static classNameKey = new EnumConverter<InternalClassNameKey, ExternalClassNameKey>({\n    [InternalClassNameKey.DashboardTitle]: ExternalClassNameKey.DashboardTitle,\n    [InternalClassNameKey.StoryTitle]: ExternalClassNameKey.StoryTitle,\n    [InternalClassNameKey.Tooltip]: ExternalClassNameKey.Tooltip,\n    [InternalClassNameKey.Worksheet]: ExternalClassNameKey.Worksheet,\n    [InternalClassNameKey.WorksheetTitle]: ExternalClassNameKey.WorksheetTitle,\n    // Temporary until we fix 1317266 - Platform hasn't been updated currently because near branch is closed\n    ['dashboard-title']: ExternalClassNameKey.DashboardTitle,\n    ['story-title']: ExternalClassNameKey.StoryTitle,\n    ['tooltip']: ExternalClassNameKey.Tooltip,\n    ['worksheet']: ExternalClassNameKey.Worksheet,\n    ['worksheet-title']: ExternalClassNameKey.WorksheetTitle,\n  });\n\n  public static hierarchicalLevelSelectionState = new EnumConverter<\n    InternalHierarchicalLevelSelectionState,\n    ExternalHierarchicalLevelSelectionState\n  >({\n    [InternalHierarchicalLevelSelectionState.AllSelected]: ExternalHierarchicalLevelSelectionState.AllSelected,\n    [InternalHierarchicalLevelSelectionState.NoneSelected]: ExternalHierarchicalLevelSelectionState.NoneSelected,\n    [InternalHierarchicalLevelSelectionState.SomeSelected]: ExternalHierarchicalLevelSelectionState.SomeSelected,\n    [InternalHierarchicalLevelSelectionState.UnknownSelected]: ExternalHierarchicalLevelSelectionState.UnknownSelected,\n  });\n\n  public static annotationType = new EnumConverter<InternalAnnotationType, ExternalAnnotationType>({\n    [InternalAnnotationType.Area]: ExternalAnnotationType.Area,\n    [InternalAnnotationType.Mark]: ExternalAnnotationType.Mark,\n    [InternalAnnotationType.Point]: ExternalAnnotationType.Point,\n  });\n\n  public static markType = new EnumConverter<InternalMarkType, ExternalMarkType>({\n    [InternalMarkType.Area]: ExternalMarkType.Area,\n    [InternalMarkType.Bar]: ExternalMarkType.Bar,\n    [InternalMarkType.Circle]: ExternalMarkType.Circle,\n    [InternalMarkType.GanttBar]: ExternalMarkType.GanttBar,\n    [InternalMarkType.Heatmap]: ExternalMarkType.Heatmap,\n    [InternalMarkType.Line]: ExternalMarkType.Line,\n    [InternalMarkType.Map]: ExternalMarkType.Map,\n    [InternalMarkType.Pie]: ExternalMarkType.Pie,\n    [InternalMarkType.Polygon]: ExternalMarkType.Polygon,\n    [InternalMarkType.Shape]: ExternalMarkType.Shape,\n    [InternalMarkType.Square]: ExternalMarkType.Square,\n    [InternalMarkType.Text]: ExternalMarkType.Text,\n    [InternalMarkType.VizExtension]: ExternalMarkType.VizExtension,\n  });\n}\n/* tslint:enable:typedef */\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, TableauEventType } from '@tableau/api-external-contract-js';\nimport { SingleEventManager } from './SingleEventManager';\nimport { TableauError } from './TableauError';\n\n/**\n * Class designed to register and unregister handlers from a user. Only those events\n * which are added via AddNewEventType will be supported by this instance\n */\nexport class EventListenerManager implements Contract.EventListenerManager {\n  private _eventListenerManagers: { [tableauEventType: string]: SingleEventManager };\n\n  public constructor() {\n    this._eventListenerManagers = {};\n  }\n\n  public addEventListener(eventType: TableauEventType, handler: Contract.TableauEventHandlerFn): Contract.TableauEventUnregisterFn {\n    if (!this._eventListenerManagers.hasOwnProperty(eventType)) {\n      throw new TableauError(ErrorCodes.UnsupportedEventName, `Cannot add event, unsupported event type: ${eventType}`);\n    }\n\n    return this._eventListenerManagers[eventType].addEventListener(handler);\n  }\n\n  public removeEventListener(eventType: TableauEventType, handler: Contract.TableauEventHandlerFn): boolean {\n    if (!this._eventListenerManagers.hasOwnProperty(eventType)) {\n      throw new TableauError(ErrorCodes.UnsupportedEventName, `Cannot remove event, unsupported event type: ${eventType}`);\n    }\n\n    return this._eventListenerManagers[eventType].removeEventListener(handler);\n  }\n\n  protected addNewEventType(eventManager: SingleEventManager): void {\n    this._eventListenerManagers[eventManager.eventType] = eventManager;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ColumnType, DataType, FieldAggregationType, FieldRoleType } from '@tableau/api-external-contract-js';\nimport { FieldImpl } from './Impl/FieldImpl';\n\nexport class Field implements Contract.Field {\n  public constructor(private _fieldImpl: FieldImpl) {}\n\n  public get name(): string {\n    return this._fieldImpl.name;\n  }\n\n  public get id(): string {\n    return this._fieldImpl.id;\n  }\n\n  public get description(): string | undefined {\n    return this._fieldImpl.description;\n  }\n\n  public get dataType(): DataType {\n    return this._fieldImpl.dataType;\n  }\n\n  public get aggregation(): FieldAggregationType {\n    return this._fieldImpl.aggregation;\n  }\n\n  public get dataSource(): Contract.DataSource {\n    return this._fieldImpl.dataSource;\n  }\n\n  public get role(): FieldRoleType {\n    return this._fieldImpl.role;\n  }\n\n  public get columnType(): ColumnType {\n    return this._fieldImpl.columnType;\n  }\n\n  public get isCalculatedField(): boolean {\n    return this._fieldImpl.isCalculatedField;\n  }\n\n  public get isCombinedField(): boolean {\n    return this._fieldImpl.isCombinedField;\n  }\n\n  public get isGenerated(): boolean {\n    return this._fieldImpl.isGenerated;\n  }\n\n  public get isGeospatial(): boolean {\n    return this._fieldImpl.isGeospatial;\n  }\n\n  public get isHidden(): boolean {\n    return this._fieldImpl.isHidden;\n  }\n\n  public get isPresentOnPublishedDatasource(): boolean {\n    return this._fieldImpl.isPresentOnPublishedDatasource;\n  }\n}\n","import { CustomViewModel } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, ServiceNames, VizService } from '../../ApiShared';\nexport class CustomViewImpl {\n  private _luid: string;\n  private _name: string;\n  private _shared: boolean;\n  private _isDefault: boolean;\n  private _ownerName: string;\n  private _url: string;\n  public constructor(customViewModel: CustomViewModel, private _registryId: number) {\n    this._luid = customViewModel.luid;\n    this._name = customViewModel.name;\n    this._shared = customViewModel.shared;\n    this._isDefault = customViewModel.isDefault;\n    this._ownerName = customViewModel.owner.userFriendlyName;\n    this._url = customViewModel.url;\n  }\n\n  public get luid() {\n    return this._luid;\n  }\n\n  public get name() {\n    return this._name;\n  }\n\n  public set name(name: string) {\n    this._name = name;\n  }\n\n  public get shared() {\n    return this._shared;\n  }\n\n  public set shared(shared: boolean) {\n    this._shared = shared;\n  }\n\n  public get isDefault() {\n    return this._isDefault;\n  }\n\n  public set isDefault(isDefault: boolean) {\n    this._isDefault = isDefault;\n  }\n\n  public get ownerName() {\n    return this._ownerName;\n  }\n\n  public get url() {\n    return this._url;\n  }\n\n  public saveAsync(): Promise<CustomViewImpl> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<VizService>(ServiceNames.Viz);\n    return service.saveAsync(this);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  DashboardLayoutChange,\n  DashboardLayoutChangeDetails,\n  ErrorCodes,\n  SharedErrorCodes,\n  SheetType,\n} from '@tableau/api-external-contract-js';\nimport { DashboardObjectType, DashboardZone, SheetPath, VisualId } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\nimport { Point } from '../Point';\nimport { AnimationService } from '../Services/AnimationService';\nimport { FilterService } from '../Services/FilterService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { ZoneService } from '../Services/ZoneService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { DashboardObjectImpl } from './DashboardObjectImpl';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryPointImpl } from './StoryPointImpl';\nimport { WorksheetImpl } from './WorksheetImpl';\n\nexport class DashboardImpl extends SheetImpl {\n  private _worksheetsImpl: Array<WorksheetImpl>;\n  private _objects: Array<DashboardObjectImpl>;\n  private zoneMap: Map<number, DashboardObjectImpl>;\n\n  public constructor(\n    _sheetInfo: SheetInfoImpl,\n    private _zones: Array<DashboardZone>,\n    private _sheetPath: SheetPath,\n    _registryId: number,\n    private _parentStoryPointImpl: StoryPointImpl | null,\n    private _activeDashboardObjectId: number = 0,\n  ) {\n    super(_sheetInfo, _registryId);\n  }\n\n  public get worksheetsImpl(): Array<WorksheetImpl> {\n    return this._worksheetsImpl;\n  }\n\n  public get objects(): Array<DashboardObjectImpl> {\n    return this._objects;\n  }\n\n  public get parentStoryPoint(): StoryPointImpl | null {\n    return this._parentStoryPointImpl;\n  }\n\n  public get activeDashboardObjectId(): number {\n    return this._activeDashboardObjectId;\n  }\n\n  public get activeDashboardName(): string {\n    return this._sheetPath.sheetName;\n  }\n\n  public initializeWithPublicInterfaces(): void {\n    this._worksheetsImpl = new Array<WorksheetImpl>();\n    this._objects = new Array<DashboardObjectImpl>();\n    this.zoneMap = new Map<number, DashboardObjectImpl>();\n\n    // Process all the zones which are contained in this dashboard\n    for (const zone of this._zones) {\n      let worksheetImpl: WorksheetImpl | undefined = undefined;\n\n      const zoneSize: Contract.Size = { width: zone.width, height: zone.height };\n      // As the dashboard is active, all other zones in the dashboard are inactive.\n      const isActive = false;\n\n      if (zone.zoneType === DashboardObjectType.Worksheet || zone.zoneType === DashboardObjectType.QuickFilter) {\n        let worksheetName = '';\n        let worksheetUrl = '';\n        let isHidden = false;\n        if (zone.sheetInfo) {\n          // zone.sheetInfo was not initialized prior to internal-contract 1.6.0\n          worksheetName = zone.sheetInfo.name;\n\n          // worksheetUrl & isHidden is for Embedding only\n          worksheetUrl = zone.sheetInfo.url || '';\n          // If there's a url, then it's not hidden\n          isHidden = worksheetUrl === '';\n        } else {\n          worksheetName = zone.name;\n        }\n        // Indexes, isActive and some more properties in sheetInfoImpl are embedding specific.\n        // But we init them for both extensions and embedding as the Models will only use what is relevant.\n        const sheetInfoImpl = new SheetInfoImpl(\n          worksheetName,\n          SheetType.Worksheet,\n          zoneSize,\n          this._worksheetsImpl.length,\n          isActive,\n          isHidden,\n          worksheetUrl,\n        );\n\n        const vizId: VisualId = {\n          worksheet: worksheetName,\n          dashboard: this._sheetInfoImpl.name,\n          storyboard: this._sheetPath.storyboard,\n          flipboardZoneID: this._sheetPath.flipboardZoneID,\n          storyPointID: this._sheetPath.storyPointID,\n        };\n\n        worksheetImpl = new WorksheetImpl(sheetInfoImpl, this._registryId, vizId, this, this._parentStoryPointImpl);\n        if (zone.zoneType === DashboardObjectType.Worksheet) {\n          this._worksheetsImpl.push(worksheetImpl);\n        }\n      }\n\n      const zonePoint = new Point(zone.x, zone.y);\n\n      const dashboardObjectImpl = new DashboardObjectImpl(\n        this,\n        InternalToExternalEnumMappings.dashboardObjectType.convert(zone.zoneType),\n        zonePoint,\n        zoneSize,\n        worksheetImpl,\n        zone.name,\n        zone.isFloating !== undefined ? zone.isFloating : false, // before 1.6.0 we didn't have isFloating, so we assume false\n        zone.isVisible !== undefined ? zone.isVisible : true, // before 1.6.0 we didn't have isVisible, so we assume true\n        zone.zoneId,\n        zone.fieldId,\n      );\n\n      this._objects.push(dashboardObjectImpl);\n      this.zoneMap.set(zone.zoneId, dashboardObjectImpl);\n    }\n  }\n\n  public setDashboardObjectVisibilityAsync(dashboardObjectVisibilityMap: Contract.DashboardObjectVisibilityMap | object): Promise<void> {\n    const zoneService = ApiServiceRegistry.get(this._registryId).getService<ZoneService>(ServiceNames.Zone);\n\n    return zoneService.setVisibilityAsync(/*Dashboard Name*/ this.name, this.zoneMap, dashboardObjectVisibilityMap);\n  }\n\n  public getDashboardObjectById(dashboardObjectId: number): DashboardObjectImpl | undefined {\n    return this.zoneMap.get(dashboardObjectId);\n  }\n\n  public updateZones(newZones: Array<DashboardZone>, newActiveZoneId = 0, newActiveDashboardName = ''): DashboardLayoutChangeDetails {\n    // getting previous dashboard objects, active zone ID and active dashboard name\n    const oldDashboardObjects = this._objects;\n    const oldZoneMap = this.zoneMap;\n    const oldActiveZoneId = this._activeDashboardObjectId;\n    const oldActiveDashboardName = this._sheetPath.sheetName;\n    // updating zones and reinitializing instance variables\n    this._zones = newZones;\n    this._activeDashboardObjectId = newActiveZoneId;\n    this._sheetPath.sheetName = newActiveDashboardName;\n    this._sheetInfoImpl.name = newActiveDashboardName;\n    this.initializeWithPublicInterfaces();\n    // getting new dashboard objects\n    const newDashboardObjects = this._objects;\n    const newZoneMap = this.zoneMap;\n    // initializing map for changes\n    const zoneChanges: DashboardLayoutChangeDetails = new Map();\n\n    // comparing old dashboard objects with new ones\n    oldDashboardObjects.forEach((oldObject) => {\n      const oldId: number = oldObject.id;\n\n      // checking if zone was removed\n      if (!newZoneMap.has(oldId)) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.Removed);\n        return;\n      }\n\n      const newObject = newZoneMap.get(oldId);\n      if (oldObject.isFloating !== newObject!.isFloating) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.IsFloatingChanged);\n      }\n\n      if (oldObject.isVisible !== newObject!.isVisible) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.IsVisibleChanged);\n      }\n\n      if (oldObject.name !== newObject!.name) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.NameChanged);\n      }\n\n      if (oldObject.position.x !== newObject!.position.x || oldObject.position.y !== newObject!.position.y) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.PositionChanged);\n      }\n\n      if (oldObject.size.width !== newObject!.size.width || oldObject.size.height !== newObject!.size.height) {\n        this.addChange(oldId, zoneChanges, DashboardLayoutChange.SizeChanged);\n      }\n    });\n\n    // Checking for any added zones\n    newDashboardObjects.forEach((newObject) => {\n      if (!oldZoneMap.has(newObject.id)) {\n        this.addChange(newObject.id, zoneChanges, DashboardLayoutChange.Added);\n      }\n    });\n\n    // Checking if zone selection has changed\n    if (oldActiveZoneId !== newActiveZoneId) {\n      if (newActiveZoneId !== 0) {\n        this.addChange(newActiveZoneId, zoneChanges, DashboardLayoutChange.Selected);\n      }\n      if (oldActiveZoneId !== 0) {\n        this.addChange(oldActiveZoneId, zoneChanges, DashboardLayoutChange.Deselected);\n      }\n    }\n\n    // Checking if switched to another dashboard\n    if (oldActiveDashboardName !== newActiveDashboardName) {\n      this.addChange(0, zoneChanges, DashboardLayoutChange.DashboardChanged);\n    }\n\n    return zoneChanges;\n  }\n\n  private addChange(zoneId: number, zoneChanges: DashboardLayoutChangeDetails, change: DashboardLayoutChange): void {\n    if (!zoneChanges.has(zoneId)) {\n      zoneChanges.set(zoneId, []);\n    }\n\n    zoneChanges.get(zoneId)!.push(change);\n  }\n\n  public moveAndResizeDashboardObjectsAsync(\n    dashboardObjectPositionAndSizeUpdateArray: Contract.DashboardObjectPositionAndSizeUpdateArray,\n  ): Promise<void> {\n    const zoneService = ApiServiceRegistry.get(this._registryId).getService<ZoneService>(ServiceNames.Zone);\n\n    return zoneService.moveAndResizeAsync(/*Dashboard Name*/ this.name, this.zoneMap, dashboardObjectPositionAndSizeUpdateArray);\n  }\n\n  public replayAnimationAsync(replaySpeed: Contract.ReplaySpeedType): Promise<void> {\n    const animationService = ApiServiceRegistry.get(this._registryId).getService<AnimationService>(ServiceNames.Animation);\n\n    return animationService.replayAsync(replaySpeed);\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    this.verifyActiveSheetOrEmbeddedInActiveStoryPoint();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getDashboardFiltersAsync();\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    ErrorHelpers.verifyEnumValue<Contract.FilterUpdateType>(updateType, Contract.FilterUpdateType, 'FilterUpdateType');\n    ErrorHelpers.verifyStringParameter(fieldName, 'fieldName');\n    if (!Array.isArray(values)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'values parameter for applyDashboardFilterAsync must be an array');\n    }\n    this.verifyActiveSheetOrEmbeddedInActiveStoryPoint();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyDashboardFilterAsync(fieldName, values, updateType, options);\n  }\n\n  // @W-12986439: remove once initializeWithPublicInterfaces is moved to the constructor for this class\n  // This method only exists since worksheetsImpl can be undefined, but we need the worksheet names in the Export APIs\n  public getWorksheetNamesFromZones(): Array<string> {\n    const worksheetNames: string[] = [];\n    for (const zone of this._zones) {\n      if (zone.zoneType !== DashboardObjectType.Worksheet) {\n        continue;\n      }\n      // zone.sheetInfo was not initialized prior to internal-contract 1.6.0\n      const worksheetName = zone.sheetInfo ? zone.sheetInfo.name : zone.name;\n      worksheetNames.push(worksheetName);\n    }\n\n    return worksheetNames;\n  }\n\n  private verifyActiveSheetOrEmbeddedInActiveStoryPoint() {\n    const isRootAndActiveDashboard = this.active;\n    const isWithinActiveStoryPoint = this.parentStoryPoint != null && this.parentStoryPoint.active;\n    if (!isRootAndActiveDashboard && !isWithinActiveStoryPoint) {\n      throw new TableauError(SharedErrorCodes.NotActiveSheet, 'Operation not allowed on non-active sheet');\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardObjectType } from '@tableau/api-external-contract-js';\nimport { DashboardImpl } from './DashboardImpl';\nimport { WorksheetImpl } from './WorksheetImpl';\n\n/**\n * Implementation of the dashboard objects - the zones in a dashboard.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class DashboardObjectImpl {\n  public constructor(\n    private _dashboardImpl: DashboardImpl,\n    private _type: DashboardObjectType,\n    private _position: Contract.Point,\n    private _size: Contract.Size,\n    private _worksheetImpl: WorksheetImpl | undefined,\n    private _name: string,\n    private _isFloating: boolean,\n    private _isVisible: boolean,\n    private _id: number,\n    private _fieldId: string | undefined,\n  ) {}\n\n  public get dashboardImpl(): DashboardImpl {\n    return this._dashboardImpl;\n  }\n\n  public get type(): DashboardObjectType {\n    return this._type;\n  }\n\n  public get position(): Contract.Point {\n    return this._position;\n  }\n\n  public get size(): Contract.Size {\n    return this._size;\n  }\n\n  public get worksheetImpl(): WorksheetImpl | undefined {\n    return this._worksheetImpl;\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get isFloating(): boolean {\n    return this._isFloating;\n  }\n\n  public get isVisible(): boolean {\n    return this._isVisible;\n  }\n\n  public get id(): number {\n    return this._id;\n  }\n\n  public get fieldId(): string | undefined {\n    return this._fieldId;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { IncludeDataValuesOption } from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport { ConnectionSummary } from '../ConnectionSummary';\nimport { Field } from '../Field';\nimport { LogicalTable } from '../LogicalTable';\nimport { DataSourceService } from '../Services/DataSourceService';\nimport { GetDataService } from '../Services/GetDataService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { TableSummary } from '../TableSummary';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { FieldImpl } from './FieldImpl';\n\nexport class DataSourceImpl {\n  private _fields: Array<Field>;\n\n  public constructor(private _dataSourceInfo: InternalContract.DataSource, private _registryId: number) {\n    this._fields = _dataSourceInfo.fields.map((fieldModel) => {\n      const fieldImpl = new FieldImpl(fieldModel, this);\n      return new Field(fieldImpl);\n    });\n  }\n\n  public get name(): string {\n    return this._dataSourceInfo.name;\n  }\n\n  public get id(): string {\n    return this._dataSourceInfo.id;\n  }\n\n  public get extractUpdateTime(): string | undefined {\n    return this._dataSourceInfo.extractUpdateTime;\n  }\n\n  public get fields(): Array<Contract.Field> {\n    return this._fields;\n  }\n\n  public get isExtract(): boolean {\n    return this._dataSourceInfo.isExtract;\n  }\n\n  public get isPublished(): boolean | undefined {\n    return this._dataSourceInfo.isPublished;\n  }\n\n  public publishedUrl(): string | undefined {\n    return this._dataSourceInfo.publishedUrl;\n  }\n\n  public getMaxPageRowLimit(): number {\n    return 10000;\n  }\n\n  public refreshAsync(): Promise<void> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.refreshAsync(this._dataSourceInfo.id);\n  }\n\n  public getConnectionSummariesAsync(): Promise<Contract.ConnectionSummary[]> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.getConnectionSummariesAsync(this._dataSourceInfo.id).then<Contract.ConnectionSummary[]>((summaries) => {\n      return summaries.map((summary) => new ConnectionSummary(summary));\n    });\n  }\n\n  public getActiveTablesAsync(): Promise<Array<Contract.TableSummary>> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.getActiveTablesAsync(this._dataSourceInfo.id).then<Array<Contract.TableSummary>>((tableInfos) => {\n      return tableInfos.map((tableInfo) => new TableSummary(tableInfo));\n    });\n  }\n\n  public getUnderlyingDataAsync(options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    const getDataService = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return getDataService.getDataSourceDataAsync(\n      this.id,\n      !!options.ignoreAliases,\n      options.maxRows || 0, // 0 and [] are defaults\n      options.columnsToInclude || [],\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getLogicalTableDataAsync(logicalTableId: string, options?: Contract.DataSourceUnderlyingDataOptions): Promise<Contract.DataTable> {\n    const getDataService = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return getDataService.getLogicalTableDataAsync(\n      this.id,\n      logicalTableId,\n      !!options.ignoreAliases,\n      options.maxRows || 0, // 0 and [] are defaults\n      options.columnsToInclude || [],\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getLogicalTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount?: number,\n    options?: Contract.DataSourceUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    const getDataService = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return getDataService.getLogicalTableDataReaderAsync(\n      this.id,\n      logicalTableId,\n      pageRowCount || this.getMaxPageRowLimit(),\n      !!options.ignoreAliases,\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public initializeWithPublicInterfaces(dataSource: Contract.DataSource): void {\n    ErrorHelpers.verifyInternalValue(dataSource, 'dataSource');\n\n    this._fields = this._dataSourceInfo.fields.map((fieldModel) => {\n      const fieldImpl = new FieldImpl(fieldModel, dataSource);\n      return new Field(fieldImpl);\n    });\n  }\n\n  public getLogicalTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    const dataSourceService = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n\n    return dataSourceService.getLogicalTablesAsync(this.id).then<Array<Contract.LogicalTable>>((logicalTableInfos) => {\n      return logicalTableInfos.map((logicalTableInfo) => new LogicalTable(logicalTableInfo));\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\n\nexport class FieldImpl {\n  public constructor(private _fieldInfo: InternalContract.Field, private _parentDataSource?: Contract.DataSource) {}\n\n  public get name(): string {\n    return this._fieldInfo.name;\n  }\n\n  public get id(): string {\n    return this._fieldInfo.id;\n  }\n\n  public get description(): string | undefined {\n    return this._fieldInfo.description;\n  }\n\n  public get dataType(): Contract.DataType {\n    return this._fieldInfo.dataType ?? Contract.DataType.Unknown;\n  }\n\n  public get aggregation(): Contract.FieldAggregationType {\n    return InternalToExternalEnumMappings.fieldAggregationType.convert(this._fieldInfo.aggregation);\n  }\n\n  public get dataSource(): Contract.DataSource {\n    if (!this._parentDataSource)\n      throw new Error(\n        `Data source information is not available for this field. Please use getFieldAsync method to get field's data source information`,\n      );\n    return this._parentDataSource;\n  }\n\n  public get role(): Contract.FieldRoleType {\n    return InternalToExternalEnumMappings.fieldRoleType.convert(this._fieldInfo.role);\n  }\n\n  public get columnType(): Contract.ColumnType {\n    let definedValue: InternalContract.ColumnType = this._fieldInfo.columnType || InternalContract.ColumnType.Unknown;\n    return InternalToExternalEnumMappings.columnType.convert(definedValue);\n  }\n\n  public get isCalculatedField(): boolean {\n    return this._fieldInfo.isCalculatedField;\n  }\n\n  public get isCombinedField(): boolean {\n    return this._fieldInfo.isCombinedField;\n  }\n\n  public get isGenerated(): boolean {\n    return this._fieldInfo.isGenerated;\n  }\n\n  public get isGeospatial(): boolean {\n    return this._fieldInfo.isGeospatial;\n  }\n\n  public get isHidden(): boolean {\n    return this._fieldInfo.isHidden;\n  }\n\n  public get isPresentOnPublishedDatasource(): boolean {\n    return this._fieldInfo.isPresentOnPublishedDatasource;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataType, ParameterValueType, PeriodType } from '@tableau/api-external-contract-js';\nimport { ParameterInfo } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../EnumMappings/InternalToExternalEnumMappings';\nimport { DataValue } from '../Models/GetDataModels';\nimport { ParametersService } from '../Services/ParametersService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { DataValueFactory } from '../Utils/DataValueFactory';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { Param } from '../Utils/Param';\n\nexport class ParameterImpl {\n  private _allowableValues: Contract.ParameterDomainRestriction;\n  private _globalFieldName: string;\n  private _parameterInfo: ParameterInfo;\n\n  public constructor(parameterInfo: ParameterInfo, private _registryId: number) {\n    this.setParameterInfo(parameterInfo);\n  }\n\n  public get name(): string {\n    return this._parameterInfo.name;\n  }\n\n  public get currentValue(): DataValue {\n    return DataValueFactory.MakeParameterDataValue(this._parameterInfo.currentValue, this._parameterInfo.dataType);\n  }\n\n  public get dataType(): DataType {\n    return InternalToExternalEnumMappings.dataType.convert(this._parameterInfo.dataType);\n  }\n\n  public get id(): string {\n    return this._globalFieldName;\n  }\n\n  public get allowableValues(): Contract.ParameterDomainRestriction {\n    return this._allowableValues;\n  }\n\n  public changeValueAsync(newValue: string | number | boolean | Date): Promise<DataValue> {\n    ErrorHelpers.verifyParameter(newValue, 'newValue');\n\n    const coercedValue = Param.serializeParameterValue(newValue);\n    const parametersService = ApiServiceRegistry.get(this._registryId).getService<ParametersService>(ServiceNames.Parameters);\n    return parametersService.changeParameterValueAsync(this._globalFieldName, coercedValue).then((parameterInfo) => {\n      this.setParameterInfo(parameterInfo);\n      return this.currentValue;\n    });\n  }\n\n  private setParameterInfo(parameterInfo: ParameterInfo): void {\n    this._parameterInfo = parameterInfo;\n    this._globalFieldName = parameterInfo.fieldName;\n\n    const type = InternalToExternalEnumMappings.allowableValues.convert(parameterInfo.allowableValuesType);\n    let listValues: Array<DataValue> | undefined;\n    let minValue: DataValue | undefined;\n    let maxValue: DataValue | undefined;\n    let stepSize: number | undefined;\n    let dateStepPeriod: PeriodType | undefined;\n\n    if (type === ParameterValueType.List) {\n      const values = parameterInfo.allowableValues || [];\n      listValues = values.map((val) => DataValueFactory.MakeParameterDataValue(val, parameterInfo.dataType));\n    } else if (type === ParameterValueType.Range) {\n      minValue = parameterInfo.minValue && DataValueFactory.MakeParameterDataValue(parameterInfo.minValue, parameterInfo.dataType);\n      maxValue = parameterInfo.maxValue && DataValueFactory.MakeParameterDataValue(parameterInfo.maxValue, parameterInfo.dataType);\n      stepSize = parameterInfo.stepSize;\n      dateStepPeriod = parameterInfo.dateStepPeriod && InternalToExternalEnumMappings.dateStepPeriod.convert(parameterInfo.dateStepPeriod);\n    }\n\n    this._allowableValues = {\n      type: type,\n      allowableValues: listValues,\n      minValue: minValue,\n      maxValue: maxValue,\n      stepSize: stepSize,\n      dateStepPeriod: dateStepPeriod,\n    };\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { SheetPath } from '@tableau/api-internal-contract-js';\nimport { ClientInfoService } from '../Services/ClientInfoService';\nimport { ParametersService } from '../Services/ParametersService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { SizeService } from '../Services/SizeService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { Param } from '../Utils/Param';\nimport { SheetUtils } from '../Utils/SheetUtils';\nimport { ParameterImpl } from './ParameterImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\n\ninterface PartialSheetSize {\n  /**\n   * Contains an enumeration value of one of the following: AUTOMATIC, EXACTLY, RANGE, ATLEAST, and ATMOST.\n   */\n  readonly behavior: Contract.SheetSizeBehavior;\n\n  /**\n   *  This is only defined when behavior is EXACTLY, RANGE, or ATLEAST.\n   */\n  readonly minSize?: Partial<Contract.Size>;\n\n  /**\n   *  This is only defined when behavior is EXACTLY, RANGE or ATMOST.\n   */\n  readonly maxSize?: Partial<Contract.Size>;\n}\n\nexport class SheetImpl {\n  public constructor(protected _sheetInfoImpl: SheetInfoImpl, protected _registryId: number) {}\n\n  public get name(): string {\n    return this._sheetInfoImpl.name;\n  }\n\n  public get sheetType(): Contract.SheetType {\n    return this._sheetInfoImpl.sheetType;\n  }\n\n  public get sheetPath(): SheetPath {\n    return this._sheetInfoImpl.sheetPath;\n  }\n\n  public get size(): Contract.Size | Contract.SheetSize {\n    return this._sheetInfoImpl.sheetSize;\n  }\n\n  public get hidden(): boolean {\n    if (this._sheetInfoImpl.isHidden !== undefined) {\n      return this._sheetInfoImpl.isHidden;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `isHidden not implemented`);\n  }\n\n  public get active(): boolean {\n    if (this._sheetInfoImpl.isActive !== undefined) {\n      return this._sheetInfoImpl.isActive;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `active not implemented`);\n  }\n\n  public set active(active: boolean) {\n    if (this._sheetInfoImpl.isActive !== undefined) {\n      this._sheetInfoImpl.active = active;\n    }\n  }\n\n  public get index(): number {\n    if (this._sheetInfoImpl.index !== undefined) {\n      return this._sheetInfoImpl.index;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `index not implemented`);\n  }\n\n  public get url(): string {\n    if (this._sheetInfoImpl.url !== undefined) {\n      return this._sheetInfoImpl.url;\n    }\n    throw new TableauError(Contract.EmbeddingErrorCodes.ImplementationError, `url not implemented`);\n  }\n\n  private getSheetSize(): Contract.SheetSize {\n    if (!SheetUtils.isValidSheetSize(this.size)) {\n      throw new TableauError(Contract.EmbeddingErrorCodes.InternalError, 'size is not of type SheetSize');\n    }\n\n    return this.size;\n  }\n\n  public findParameterAsync(parameterName: string): Promise<ParameterImpl | undefined> {\n    ErrorHelpers.verifyParameter(parameterName, 'parameterName');\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ParametersService>(ServiceNames.Parameters);\n    return service.findParameterByNameAsync(parameterName);\n  }\n\n  public getParametersAsync(): Promise<Array<ParameterImpl>> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<ParametersService>(ServiceNames.Parameters);\n    return service.getParametersForSheetAsync(this.sheetPath);\n  }\n\n  public changeSizeAsync(newSize: Contract.SheetSize): Promise<Contract.SheetSize> {\n    const invalidSizeError = new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Invalid sheet size parameter');\n    if (!newSize || !newSize.behavior) {\n      throw invalidSizeError;\n    }\n\n    const partialSheetSize = this.normalizeSheetSize(newSize);\n\n    const isAutomatic = partialSheetSize.behavior === Contract.SheetSizeBehavior.Automatic;\n    if (!isAutomatic && !partialSheetSize.minSize && !partialSheetSize.maxSize) {\n      throw invalidSizeError;\n    }\n\n    if (!isAutomatic && this.sheetType === Contract.SheetType.Worksheet) {\n      throw new TableauError(\n        Contract.EmbeddingErrorCodes.InvalidSizeBehaviorOnWorksheet,\n        'Only SheetSizeBehavior.Automatic is allowed on Worksheets',\n      );\n    }\n\n    if (isAutomatic && this.getSheetSize().behavior === partialSheetSize.behavior) {\n      return Promise.resolve(newSize);\n    }\n\n    const processedNewSize = this.processNewSize(partialSheetSize);\n\n    const sizeService = ApiServiceRegistry.get(this._registryId).getService<SizeService>(ServiceNames.Size);\n    return sizeService.changeSizeAsync(this.name, processedNewSize).then(() => {\n      const clientInfoService = ApiServiceRegistry.get(this._registryId).getService<ClientInfoService>(ServiceNames.ClientInfo);\n\n      return clientInfoService.getClientInfoAsync().then((bootstrapInfo) => {\n        const sheet = bootstrapInfo.publishedSheets.find((s) => s.name === this.name);\n        if (!sheet) {\n          throw new TableauError(Contract.SharedErrorCodes.InternalError, `Can't find sheet with name ${this.name}`);\n        }\n\n        const sheetSize = SheetUtils.getSheetSizeFromSizeConstraints(sheet.sizeConstraint);\n        this._sheetInfoImpl.sheetSize = sheetSize;\n\n        return sheetSize;\n      });\n    });\n  }\n\n  private normalizeSheetSize(newSize: Contract.SheetSize): PartialSheetSize {\n    const { behavior } = newSize;\n\n    ErrorHelpers.verifyEnumValue<Contract.SheetSizeBehavior>(behavior, Contract.SheetSizeBehavior, 'SheetSizeBehavior');\n\n    const minSize = SheetImpl.parseDimensions(newSize.minSize);\n    const maxSize = SheetImpl.parseDimensions(newSize.maxSize);\n\n    return { behavior, minSize, maxSize };\n  }\n\n  private processNewSize(newSize: PartialSheetSize): Contract.SheetSize {\n    const { behavior, minSize: minSizeMaybe, maxSize: maxSizeMaybe } = newSize;\n\n    const hasMinWidth = !Param.isNullOrUndefined(minSizeMaybe?.width);\n    const hasMinHeight = !Param.isNullOrUndefined(minSizeMaybe?.height);\n    const hasMaxWidth = !Param.isNullOrUndefined(maxSizeMaybe?.width);\n    const hasMaxHeight = !Param.isNullOrUndefined(maxSizeMaybe?.height);\n    const hasValidMinSize = hasMinWidth && hasMinHeight;\n    const hasValidMaxSize = hasMaxWidth && hasMaxHeight;\n\n    switch (behavior) {\n      case Contract.SheetSizeBehavior.Automatic: {\n        return { behavior };\n      }\n\n      case Contract.SheetSizeBehavior.AtMost: {\n        if (!maxSizeMaybe || !hasValidMaxSize) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.MissingMaxSize, 'Missing maxSize for SheetSizeBehavior.AtMost');\n        }\n\n        const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n        if (maxSize.width < 0 || maxSize.height < 0) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Size value cannot be less than zero');\n        }\n\n        return { behavior, maxSize };\n      }\n\n      case Contract.SheetSizeBehavior.AtLeast: {\n        if (!minSizeMaybe || !hasValidMinSize) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.MissingMinSize, 'Missing minSize for SheetSizeBehavior.AtLeast');\n        }\n\n        const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n        if (minSize.width < 0 || minSize.height < 0) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Size value cannot be less than zero');\n        }\n\n        return { behavior, minSize };\n      }\n\n      case Contract.SheetSizeBehavior.Range: {\n        if (!minSizeMaybe || !maxSizeMaybe || !hasValidMinSize || !hasValidMaxSize) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.MissingMinMaxSize, 'Missing minSize or maxSize for SheetSizeBehavior.Range');\n        }\n\n        const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n        const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n\n        if (\n          minSize.width < 0 ||\n          minSize.height < 0 ||\n          maxSize.width < 0 ||\n          maxSize.height < 0 ||\n          minSize.width > maxSize.width ||\n          minSize.height > maxSize.height\n        ) {\n          throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Missing minSize or maxSize for SheetSizeBehavior.Range');\n        }\n\n        return { behavior, minSize, maxSize };\n      }\n\n      case Contract.SheetSizeBehavior.Exactly: {\n        if (minSizeMaybe && maxSizeMaybe) {\n          if (hasValidMinSize && hasValidMaxSize) {\n            const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n            const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n\n            if (minSize.width !== maxSize.width || minSize.height !== maxSize.height) {\n              throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Conflicting size values for SheetSizeBehavior.Exactly');\n            }\n\n            return { behavior, minSize, maxSize };\n          }\n\n          if (hasValidMinSize) {\n            const minSize = { width: minSizeMaybe.width!, height: minSizeMaybe.height! };\n            return { behavior, minSize, maxSize: minSize };\n          }\n\n          if (hasValidMaxSize) {\n            const maxSize = { width: maxSizeMaybe.width!, height: maxSizeMaybe.height! };\n            return { behavior, minSize: maxSize, maxSize };\n          }\n        }\n\n        throw new TableauError(Contract.EmbeddingErrorCodes.InvalidSize, 'Invalid sheet size parameter');\n      }\n\n      default: {\n        throw new TableauError(Contract.SharedErrorCodes.InternalError, `Unsupported sheet size behavior: ${behavior}`);\n      }\n    }\n  }\n\n  private static parseDimensions = (size: Contract.Size | undefined): Partial<Contract.Size> => {\n    const empty = { width: undefined, height: undefined };\n\n    if (!size) {\n      return empty;\n    }\n\n    const { success: widthParsed, parsed: parsedWidth } = Param.tryParseNumber(size.width);\n    const { success: heightParsed, parsed: parsedHeight } = Param.tryParseNumber(size.height);\n\n    if (widthParsed && heightParsed) {\n      return { width: parsedWidth!, height: parsedHeight! };\n    }\n\n    if (widthParsed) {\n      return { width: parsedWidth! };\n    }\n\n    if (heightParsed) {\n      return { height: parsedHeight! };\n    }\n\n    return empty;\n  };\n}\n","import { SheetSize as EmbeddingSheetSize, Size as ExtensionSheetSize, SheetType } from '@tableau/api-external-contract-js';\nimport { SheetPath } from '@tableau/api-internal-contract-js';\n\nexport class SheetInfoImpl {\n  public constructor(\n    private _name: string,\n    private _sheetType: SheetType,\n    private _sheetSize: ExtensionSheetSize | EmbeddingSheetSize,\n    private _index?: number,\n    private _isActive?: boolean,\n    private _isHidden?: boolean,\n    private _url?: string,\n  ) {}\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public set name(sheetName: string) {\n    this._name = sheetName;\n  }\n\n  public get sheetSize(): ExtensionSheetSize | EmbeddingSheetSize {\n    return this._sheetSize;\n  }\n\n  public set sheetSize(value: ExtensionSheetSize | EmbeddingSheetSize) {\n    this._sheetSize = value;\n  }\n\n  public get sheetType(): SheetType {\n    return this._sheetType;\n  }\n\n  public get sheetPath(): SheetPath {\n    return {\n      sheetName: this.name,\n      isDashboard: this.sheetType === SheetType.Dashboard,\n      // TODO - Stories\n    };\n  }\n\n  public get index(): number | undefined {\n    return this._index;\n  }\n\n  public get isActive(): boolean | undefined {\n    return this._isActive;\n  }\n\n  public set active(active: boolean) {\n    this._isActive = active;\n  }\n\n  public get isHidden(): boolean | undefined {\n    return this._isHidden;\n  }\n\n  public get url(): string | undefined {\n    return this._url;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauEventType } from '@tableau/api-external-contract-js';\nimport { SingleEventManager } from '../SingleEventManager';\n\n/**\n * This class implements the SingleEventManager interface for a single type of Tableau event\n *\n * @template TEventType The Tableau event type this class specializes\n */\nexport class SingleEventManagerImpl<TEventType extends Contract.TableauEvent> implements SingleEventManager {\n  private _eventType: TableauEventType;\n  private _handlers: Array<(eventObj: TEventType) => void>;\n\n  public constructor(eventType: TableauEventType) {\n    this._eventType = eventType;\n    this._handlers = [];\n  }\n\n  public get eventType(): TableauEventType {\n    return this._eventType;\n  }\n\n  public addEventListener(handler: (eventObj: TEventType) => void): Contract.TableauEventUnregisterFn {\n    this._handlers.push(handler);\n    return () => this.removeEventListener(handler);\n  }\n\n  public removeEventListener(handler: (eventObj: TEventType) => void): boolean {\n    const beforeCount = this._handlers.length;\n    this._handlers = this._handlers.filter((h) => h !== handler);\n    return beforeCount > this._handlers.length;\n  }\n\n  public triggerEvent(eventGenerator: () => TEventType): void {\n    for (const handler of this._handlers) {\n      try {\n        const eventModel = eventGenerator();\n        handler(eventModel);\n      } catch (e) {\n        // Since this handler could be outside our control, just catch anything it throws and continue on\n        continue;\n      }\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { SheetInfo, StoryModel, StoryPointModel } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { StoryActivationService } from '../Services/StoryActivationService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { ShortLivedDeferred } from '../Utils/ShortLivedDeferred';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryPointImpl } from './StoryPointImpl';\nimport { StoryPointInfoImpl } from './StoryPointInfoImpl';\n\nexport class StoryImpl extends SheetImpl {\n  private _activeStoryPointImpl: StoryPointImpl;\n  private _storyPointInfoImpls: Array<StoryPointInfoImpl> = [];\n  private _deferred: ShortLivedDeferred<StoryPointImpl>;\n\n  public constructor(\n    protected _sheetInfoImpl: SheetInfoImpl,\n    storyModel: StoryModel,\n    private _publishedSheetInfos: Array<SheetInfo>,\n    protected _registryId: number,\n  ) {\n    super(_sheetInfoImpl, _registryId);\n    this._deferred = new ShortLivedDeferred<StoryPointImpl>();\n    this.initializeStory(storyModel);\n  }\n\n  private initializeStory(storyModel: StoryModel) {\n    storyModel.storyPoints.forEach((storyPointModel) => {\n      const isActive = storyPointModel.index === storyModel.activeStoryPointIndex;\n      const storyPointInfoImpl = new StoryPointInfoImpl(\n        storyPointModel.caption,\n        storyPointModel.index,\n        storyPointModel.storyPointId,\n        isActive,\n        storyPointModel.updated,\n        this,\n      );\n      this._storyPointInfoImpls.push(storyPointInfoImpl);\n\n      if (isActive) {\n        this._activeStoryPointImpl = new StoryPointImpl(\n          storyPointInfoImpl,\n          this._publishedSheetInfos,\n          this._registryId,\n          storyPointModel.containedSheetInfo,\n        );\n      }\n    });\n  }\n\n  private updateStoryInfo(index: number, storyPointModel: StoryPointModel) {\n    if (!this._storyPointInfoImpls) {\n      return;\n    }\n\n    let storyInfoImpl = this._storyPointInfoImpls[index];\n    if (storyInfoImpl.storyPointId !== storyPointModel.storyPointId) {\n      throw new TableauError(\n        Contract.EmbeddingErrorCodes.StoryPointIdMismatch,\n        `We should not be updating a story point when the IDs don't match. Existing storyPointID=${storyInfoImpl.storyPointId}, newStoryPointID=${storyPointModel.storyPointId}`,\n      );\n    }\n    storyInfoImpl.caption = storyPointModel.caption;\n    storyInfoImpl.updated = storyPointModel.updated;\n\n    if (this._activeStoryPointImpl.storyPointId === storyPointModel.storyPointId) {\n      this._activeStoryPointImpl.updated = storyInfoImpl.updated;\n    }\n  }\n\n  public updateStory(storyPointModel: StoryPointModel) {\n    if (!this._storyPointInfoImpls) {\n      return;\n    }\n\n    this._storyPointInfoImpls.forEach((storyPointInfoImpl) => {\n      const isActive = storyPointInfoImpl.storyPointId === storyPointModel.storyPointId;\n      if (isActive) {\n        // update the state\n        storyPointInfoImpl.caption = storyPointModel.caption;\n        storyPointInfoImpl.index = storyPointModel.index;\n        storyPointInfoImpl.active = true;\n        storyPointInfoImpl.updated = storyPointModel.updated;\n\n        // re-initialize activeStoryPointImpl\n        this._activeStoryPointImpl = new StoryPointImpl(\n          storyPointInfoImpl,\n          this._publishedSheetInfos,\n          this._registryId,\n          storyPointModel.containedSheetInfo,\n        );\n      } else {\n        // set old ones to false\n        storyPointInfoImpl.active = false;\n      }\n    });\n\n    if (this.activeStoryPoint) {\n      this._deferred.resolve(this.activeStoryPoint);\n    }\n  }\n\n  public get activeStoryPoint(): StoryPointImpl | undefined {\n    return this._activeStoryPointImpl;\n  }\n\n  public get storyPointsInfo(): Array<StoryPointInfoImpl> {\n    return this._storyPointInfoImpls;\n  }\n\n  public get isActive(): boolean {\n    return this._sheetInfoImpl.active;\n  }\n\n  public get isHidden(): boolean {\n    return !!this._sheetInfoImpl.isHidden;\n  }\n\n  public activateNextStoryPointAsync(): Promise<StoryPointImpl> {\n    if (this._activeStoryPointImpl.index === this._storyPointInfoImpls.length - 1) {\n      return Promise.resolve(this._activeStoryPointImpl);\n    }\n\n    let promise = this._deferred.getNewPromiseOrThrowIfBusy();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n    service.activateNextStoryPointAsync();\n    return promise;\n  }\n\n  public activatePreviousStoryPointAsync(): Promise<StoryPointImpl> {\n    if (this._activeStoryPointImpl.index === 0) {\n      return Promise.resolve(this._activeStoryPointImpl);\n    }\n\n    let promise = this._deferred.getNewPromiseOrThrowIfBusy();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n    service.activatePreviousStoryPointAsync();\n    return promise;\n  }\n\n  public activateStoryPointAsync(index: number): Promise<StoryPointImpl> {\n    ErrorHelpers.verifyParameter(index, 'index');\n    ErrorHelpers.verifyParameterType(index, 'number', 'index');\n\n    if (index < 0 || index >= this._storyPointInfoImpls.length) {\n      throw new TableauError(Contract.EmbeddingErrorCodes.IndexOutOfRange, 'The index passed to this command is out of range.');\n    }\n\n    if (index === this._activeStoryPointImpl.index) {\n      return Promise.resolve(this._activeStoryPointImpl);\n    }\n\n    let promise = this._deferred.getNewPromiseOrThrowIfBusy();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n    service.activateStoryPointAsync(index);\n    return promise;\n  }\n\n  public revertStoryPointAsync(index: number): Promise<StoryPointInfoImpl> {\n    ErrorHelpers.verifyParameter(index, 'index');\n    ErrorHelpers.verifyParameterType(index, 'number', 'index');\n\n    if (index < 0 || index >= this._storyPointInfoImpls.length) {\n      throw new TableauError(Contract.EmbeddingErrorCodes.IndexOutOfRange, 'The index passed to this command is out of range.');\n    }\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<StoryActivationService>(ServiceNames.StoryActivation);\n\n    return service.revertStoryPointAsync(index).then<StoryPointInfoImpl>((response) => {\n      this.updateStoryInfo(response.index, response);\n      const storyPointInfoImpl = new StoryPointInfoImpl(\n        response.caption,\n        response.index,\n        response.storyPointId,\n        false,\n        response.updated,\n        this,\n      );\n      return storyPointInfoImpl;\n    });\n  }\n\n  public clearPendingPromises(): void {\n    if (this._deferred) {\n      this._deferred.reject('All pending promises cleared');\n    }\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ContainedSheetInfoModel, SheetInfo, SheetPath, VisualId } from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../TableauError';\nimport { SheetUtils } from '../Utils/SheetUtils';\nimport { DashboardImpl } from './DashboardImpl';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryImpl } from './StoryImpl';\nimport { StoryPointInfoImpl } from './StoryPointInfoImpl';\nimport { WorksheetImpl } from './WorksheetImpl';\n\nexport class StoryPointImpl {\n  private _containedSheetImpl: SheetImpl;\n  constructor(\n    private _storyPointInfoImpl: StoryPointInfoImpl,\n    sheetInfos: Array<SheetInfo>,\n    registryId: number,\n    containedSheetInfo?: ContainedSheetInfoModel,\n  ) {\n    if (containedSheetInfo) {\n      this._containedSheetImpl = this.createContainedSheet(containedSheetInfo, sheetInfos, registryId);\n    }\n  }\n\n  public get index(): number {\n    return this._storyPointInfoImpl.index;\n  }\n\n  public get caption(): string {\n    return this._storyPointInfoImpl.caption;\n  }\n\n  public get active(): boolean {\n    return this._storyPointInfoImpl.active;\n  }\n\n  public get updated(): boolean {\n    return this._storyPointInfoImpl.updated;\n  }\n\n  public set updated(updated: boolean) {\n    this._storyPointInfoImpl.updated = updated;\n  }\n\n  public get parentStory(): StoryImpl {\n    return this._storyPointInfoImpl.parentStory;\n  }\n\n  public get containedSheet(): SheetImpl | undefined {\n    return this._containedSheetImpl;\n  }\n\n  public get storyPointId(): number {\n    return this._storyPointInfoImpl.storyPointId;\n  }\n\n  private createContainedSheet(containedSheetInfo: ContainedSheetInfoModel, sheetInfos: Array<SheetInfo>, registryId: number): SheetImpl {\n    const containedSheetIdx = -1;\n\n    const publishedSheetInfo = SheetUtils.getPublishedSheetInfoByName(containedSheetInfo.name, sheetInfos);\n    const containedSheetSize = SheetUtils.createAutomaticSize();\n    const isContainedSheetHidden = publishedSheetInfo === undefined;\n    const containedSheetUrl = publishedSheetInfo ? publishedSheetInfo.url : '';\n    // Contained sheets aren't active - the containing sheet is active.\n    const containedSheetActive = false;\n\n    const containedSheetInfoImpl = new SheetInfoImpl(\n      containedSheetInfo.name,\n      SheetUtils.getSheetTypeEnum(containedSheetInfo.sheetType),\n      containedSheetSize,\n      containedSheetIdx,\n      containedSheetActive,\n      isContainedSheetHidden,\n      containedSheetUrl,\n    );\n\n    let sheetImpl: SheetImpl;\n    switch (containedSheetInfoImpl.sheetType) {\n      case Contract.SheetType.Worksheet: {\n        const vizId: VisualId = {\n          worksheet: containedSheetInfoImpl.name,\n        };\n\n        sheetImpl = new WorksheetImpl(containedSheetInfoImpl, registryId, vizId, null, this);\n        break;\n      }\n      case Contract.SheetType.Dashboard: {\n        const sheetPath: SheetPath = {\n          sheetName: containedSheetInfoImpl.name,\n          isDashboard: true,\n        };\n\n        sheetImpl = new DashboardImpl(containedSheetInfoImpl, containedSheetInfo.dashboardZones, sheetPath, registryId, this);\n        break;\n      }\n      default: {\n        throw new TableauError(Contract.SharedErrorCodes.ServerError, 'Invalid SheetType');\n      }\n    }\n\n    return sheetImpl;\n  }\n}\n","import { StoryImpl } from './StoryImpl';\n\nexport class StoryPointInfoImpl {\n  public constructor(\n    private _caption: string,\n    private _index: number,\n    private _storyPointId: number,\n    private _active: boolean,\n    private _updated: boolean,\n    private _parentStoryImpl: StoryImpl,\n  ) {}\n\n  public get caption() {\n    return this._caption;\n  }\n\n  public set caption(caption: string) {\n    this._caption = caption;\n  }\n\n  public get index() {\n    return this._index;\n  }\n\n  public set index(index: number) {\n    this._index = index;\n  }\n\n  public get storyPointId() {\n    return this._storyPointId;\n  }\n\n  public get active() {\n    return this._active;\n  }\n\n  public set active(isActive: boolean) {\n    this._active = isActive;\n  }\n\n  public get updated() {\n    return this._updated;\n  }\n\n  public set updated(isUpdated: boolean) {\n    this._updated = isUpdated;\n  }\n\n  public get parentStory() {\n    return this._parentStoryImpl;\n  }\n}\n","export class WorkbookImpl {}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  ApiMenuType,\n  ContextMenuOptions,\n  DateRangeType,\n  ErrorCodes,\n  FilterNullOption,\n  IncludeDataValuesOption,\n  PeriodType,\n  SelectionUpdateType,\n  SharedErrorCodes,\n  TooltipContext,\n} from '@tableau/api-external-contract-js';\nimport { DataSchema, DataSource as DataSourceInfo, VisualId, WorksheetDataSourceInfo } from '@tableau/api-internal-contract-js';\nimport { DataSource } from '../DataSource';\nimport { LogicalTable } from '../LogicalTable';\nimport { AccessibilityService } from '../Services/AccessibilityService';\nimport { AnnotationService } from '../Services/AnnotationService';\nimport { DataSourceService } from '../Services/DataSourceService';\nimport { ExternalContextMenuService } from '../Services/ExternalContextMenuService';\nimport { FilterService } from '../Services/FilterService';\nimport { GetDataService, GetDataType } from '../Services/GetDataService';\nimport { SelectionService } from '../Services/SelectionService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { VisualModelService } from '../Services/VisualModelService';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\nimport { DashboardImpl } from './DashboardImpl';\nimport { DataSourceImpl } from './DataSourceImpl';\nimport { SheetImpl } from './SheetImpl';\nimport { SheetInfoImpl } from './SheetInfoImpl';\nimport { StoryPointImpl } from './StoryPointImpl';\n\nexport class WorksheetImpl extends SheetImpl {\n  public constructor(\n    sheetInfoImpl: SheetInfoImpl,\n    _registryId: number,\n    private _visualId: VisualId,\n    private _parentDashboardImpl: DashboardImpl | null,\n    private _parentStoryPointImpl: StoryPointImpl | null,\n  ) {\n    super(sheetInfoImpl, _registryId);\n  }\n\n  public get parentDashboard(): DashboardImpl | null {\n    return this._parentDashboardImpl;\n  }\n\n  public get parentStoryPoint(): StoryPointImpl | null {\n    return this._parentStoryPointImpl;\n  }\n\n  public get visualId(): VisualId {\n    return this._visualId;\n  }\n\n  public getMaxPageRowLimit(): number {\n    return 10000;\n  }\n\n  public applyFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    ErrorHelpers.verifyEnumValue<Contract.FilterUpdateType>(updateType, Contract.FilterUpdateType, 'Contract.FilterUpdateType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyFilterAsync(this.visualId, fieldName, values, updateType, options);\n  }\n\n  public applyRangeFilterAsync(fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\n    ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n    ErrorHelpers.verifyParameter(filterOptions, 'filterOptions');\n    if (filterOptions.nullOption) {\n      ErrorHelpers.verifyEnumValue<FilterNullOption>(filterOptions.nullOption, FilterNullOption, 'FilterNullOption');\n    } else {\n      ErrorHelpers.verifyRangeParamType(filterOptions.min, filterOptions.max);\n    }\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyRangeFilterAsync(this.visualId, fieldName, filterOptions);\n  }\n\n  public applyHierarchicalFilterAsync(\n    fieldName: string,\n    values: Array<string> | Contract.HierarchicalLevels,\n    updateType: Contract.FilterUpdateType,\n    options: Contract.FilterOptions,\n  ): Promise<string> {\n    ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n    ErrorHelpers.verifyParameter(values, 'values');\n    ErrorHelpers.verifyEnumValue<Contract.FilterUpdateType>(updateType, Contract.FilterUpdateType, 'Contract.FilterUpdateType');\n    if (!Array.isArray(values) && !values.levels) {\n      throw new TableauError(\n        ErrorCodes.InvalidParameter,\n        'values parameter for applyHierarchicalFilterAsync must be an array or contain a levels key',\n      );\n    }\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyHierarchicalFilterAsync(this.visualId, fieldName, values, updateType, options);\n  }\n\n  public clearFilterAsync(fieldName: string): Promise<string> {\n    ErrorHelpers.verifyParameter(fieldName, 'fieldName');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.clearFilterAsync(this.visualId, fieldName);\n  }\n\n  public applyRelativeDateFilterAsync(fieldName: string, options: Contract.RelativeDateFilterOptions): Promise<string> {\n    ErrorHelpers.verifyStringParameter(fieldName, 'fieldName');\n    ErrorHelpers.verifyParameter(options, 'options');\n    ErrorHelpers.verifyEnumValue<PeriodType>(options.periodType, PeriodType, 'PeriodType');\n    ErrorHelpers.verifyEnumValue<DateRangeType>(options.rangeType, DateRangeType, 'DateRangeType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.applyRelativeDateFilterAsync(this.visualId, fieldName, options);\n  }\n\n  public getDataSourcesAsync(): Promise<Array<Contract.DataSource>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n    return service.getDataSourcesAsync(this.visualId).then<Array<Contract.DataSource>>((result) => {\n      const dataSchema: DataSchema = result;\n      const worksheetDataSourceInfo: WorksheetDataSourceInfo = dataSchema.worksheetDataSchemaMap[this.name];\n\n      const dataSources: Array<Contract.DataSource> = [];\n\n      // First, add the primary datasource.  By convention, it comes first in the returned array.\n      const primaryId: string = worksheetDataSourceInfo.primaryDataSource;\n      dataSources.push(this.createDataSourceFromInfo(dataSchema.dataSources[primaryId]));\n\n      // Then, loop through any secondary data sources and add them.\n      for (const secondaryId of worksheetDataSourceInfo.referencedDataSourceList) {\n        if (secondaryId !== primaryId) {\n          dataSources.push(this.createDataSourceFromInfo(dataSchema.dataSources[secondaryId]));\n        }\n      }\n\n      return dataSources;\n    });\n  }\n\n  public getFiltersAsync(): Promise<Array<Contract.Filter>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getFiltersAsync(this.visualId);\n  }\n\n  public getSelectedMarksAsync(): Promise<Contract.MarksCollection> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getSelectedMarksAsync(this.visualId);\n  }\n\n  public getHighlightedMarksAsync(): Promise<Contract.MarksCollection> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getHighlightedMarksAsync(this.visualId);\n  }\n\n  public getSummaryDataAsync(options: Contract.GetSummaryDataOptions): Promise<Contract.DataTable> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return service.getUnderlyingDataAsync(\n      this.visualId,\n      GetDataType.Summary,\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      true,\n      options.columnsToIncludeById || [],\n      options.maxRows || 0,\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getSummaryDataReaderAsync(pageRowCount: number, options: Contract.GetSummaryDataOptions): Promise<Contract.DataTableReader> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n\n    return service.getSummaryDataReaderAsync(\n      this.visualId,\n      pageRowCount || this.getMaxPageRowLimit(),\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      true, // includeAllColumns (can be overridden by columnsToIncludeById)\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getVisualSpecificationAsync(): Promise<Contract.VisualSpecification> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<VisualModelService>(ServiceNames.VisualModel);\n\n    return service.getVisualSpecificationAsync(this.visualId);\n  }\n\n  public getSummaryColumnsInfoAsync(): Promise<Array<Contract.Column>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getSummaryColumnsInfoAsync(this.visualId);\n  }\n\n  public getUnderlyingDataAsync(options: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n    return service.getUnderlyingDataAsync(\n      this.visualId,\n      GetDataType.Underlying,\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      !!options.includeAllColumns,\n      options.columnsToIncludeById || [],\n      options.maxRows || 0,\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getUnderlyingTablesAsync(): Promise<Array<Contract.LogicalTable>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n    return service.getUnderlyingTablesAsync(this.visualId).then<Array<Contract.LogicalTable>>((logicalTableInfos) => {\n      return logicalTableInfos.map((logicalTableInfo) => new LogicalTable(logicalTableInfo));\n    });\n  }\n\n  public getUnderlyingTableDataAsync(logicalTableId: string, options?: Contract.GetUnderlyingDataOptions): Promise<Contract.DataTable> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n    return service.getUnderlyingTableDataAsync(\n      this.visualId,\n      logicalTableId,\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      !!options.includeAllColumns,\n      options.columnsToIncludeById || [],\n      options.maxRows || 0,\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public getUnderlyingTableDataReaderAsync(\n    logicalTableId: string,\n    pageRowCount?: number,\n    options?: Contract.GetUnderlyingDataOptions,\n  ): Promise<Contract.DataTableReader> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    options = options || {};\n    return service.getUnderlyingTableDataReaderAsync(\n      this.visualId,\n      logicalTableId,\n      pageRowCount || this.getMaxPageRowLimit(),\n      !!options.ignoreAliases,\n      !!options.ignoreSelection,\n      !!options.includeAllColumns,\n      options.columnsToIncludeById || [],\n      options.includeDataValuesOption || IncludeDataValuesOption.AllValues,\n    );\n  }\n\n  public clearSelectedMarksAsync(): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.clearSelectedMarksAsync(this.visualId);\n  }\n\n  public selectMarksByValueAsync(selections: Array<Contract.SelectionCriteria>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    ErrorHelpers.verifyParameter(selections, 'fieldName');\n    ErrorHelpers.verifyEnumValue<SelectionUpdateType>(selectionUpdateType, SelectionUpdateType, 'SelectionUpdateType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.selectMarksByValueAsync(this.visualId, selections, selectionUpdateType);\n  }\n\n  public selectMarksByIdAsync(selections: Array<Contract.MarkInfo>, selectionUpdateType: SelectionUpdateType): Promise<void> {\n    ErrorHelpers.verifyParameter(selections, 'fieldName');\n    ErrorHelpers.verifyEnumValue<SelectionUpdateType>(selectionUpdateType, SelectionUpdateType, 'SelectionUpdateType');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.selectMarksByIdAsync(this.visualId, selections, selectionUpdateType);\n  }\n\n  public annotateMarkAsync(mark: Contract.MarkInfo, annotationText: string): Promise<void> {\n    ErrorHelpers.verifyParameter(mark, 'mark');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<AnnotationService>(ServiceNames.Annotation);\n    return service.annotateMarkAsync(this.visualId, mark, annotationText);\n  }\n\n  public getAnnotationsAsync(): Promise<Array<Contract.Annotation>> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<AnnotationService>(ServiceNames.Annotation);\n    return service.getAnnotationsAsync(this.visualId);\n  }\n\n  public removeAnnotationAsync(annotation: Contract.Annotation) {\n    ErrorHelpers.verifyParameter(annotation, 'annotation');\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<AnnotationService>(ServiceNames.Annotation);\n    return service.removeAnnotationAsync(this.visualId, annotation);\n  }\n\n  public appendContextMenuAsync(targetMenu: ApiMenuType, config: ContextMenuOptions): Promise<string> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.appendContextMenuAsync(this.visualId.worksheet, targetMenu, config);\n  }\n\n  public removeContextMenuAsync(targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.removeContextMenuAsync(this.visualId.worksheet, targetMenu, menuItemId);\n  }\n\n  public executeContextMenuAsync(targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.executeContextMenuAsync(this.visualId.worksheet, targetMenu, menuItemId);\n  }\n\n  public renameContextMenuAsync(targetMenu: ApiMenuType, menuHeader: string, menuDescription: string): Promise<void> {\n    this.verifyActiveSheet();\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<ExternalContextMenuService>(ServiceNames.ExternalContextMenu);\n    return service.renameContextMenuAsync(this.visualId.worksheet, targetMenu, menuHeader, menuDescription);\n  }\n\n  public hoverTupleAsync(hoveredTuple?: number, tooltip?: TooltipContext | null, allowHoverActions?: boolean): Promise<void> {\n    if (this.isInsideDashboardExtension()) {\n      return Promise.reject(\n        new TableauError(Contract.SharedErrorCodes.ImplementationError, `hoverTupleAsync is not supported in dashboard extensions`),\n      );\n    }\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.hoverTupleAsync(this.visualId, hoveredTuple, tooltip, allowHoverActions);\n  }\n\n  public selectTuplesAsync(selectedTuples: Array<number>, selectOption: Contract.SelectOptions, tooltip?: TooltipContext): Promise<void> {\n    if (this.isInsideDashboardExtension()) {\n      return Promise.reject(\n        new TableauError(Contract.SharedErrorCodes.ImplementationError, `selectTuplesAsync is not supported in dashboard extensions`),\n      );\n    }\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<SelectionService>(ServiceNames.Selection);\n    return service.selectTuplesAsync(this.visualId, selectedTuples, selectOption, tooltip);\n  }\n\n  public getTooltipTextAsync(tupleId: number): Promise<String> {\n    if (this.isInsideDashboardExtension()) {\n      return Promise.reject(\n        new TableauError(Contract.SharedErrorCodes.ImplementationError, `getTooltipTextAsync is not supported in dashboard extensions`),\n      );\n    }\n    const service = ApiServiceRegistry.get(this._registryId).getService<AccessibilityService>(ServiceNames.Accessibility);\n    return service.getTooltipTextAsync(this.visualId, tupleId);\n  }\n\n  public leaveMarkNavigationAsync(): Promise<void> {\n    if (this.isInsideDashboardExtension()) {\n      return Promise.reject(\n        new TableauError(\n          Contract.SharedErrorCodes.ImplementationError,\n          `leaveMarkNavigationAsync is not supported in dashboard extensions`,\n        ),\n      );\n    }\n    const service = ApiServiceRegistry.get(this._registryId).getService<AccessibilityService>(ServiceNames.Accessibility);\n    return service.leaveMarkNavigationAsync(this.visualId);\n  }\n\n  private createDataSourceFromInfo(dataSourceInfo: DataSourceInfo): Contract.DataSource {\n    const dataSourceImpl = new DataSourceImpl(dataSourceInfo, this._registryId);\n    const dataSource = new DataSource(dataSourceImpl);\n    dataSourceImpl.initializeWithPublicInterfaces(dataSource);\n    return dataSource;\n  }\n\n  private verifyActiveSheet() {\n    const isRootAndActiveWorksheet = this.active;\n    const isInsideActiveDashboard = this.isInsideActiveDashboard();\n    const isInsideActiveStoryPoint = this.isInsideActiveStoryPoint();\n\n    if (!isRootAndActiveWorksheet && !isInsideActiveDashboard && !isInsideActiveStoryPoint) {\n      throw new TableauError(SharedErrorCodes.NotActiveSheet, 'Operation not allowed on non-active sheet');\n    }\n  }\n\n  private isInsideActiveStoryPoint() {\n    return this._parentStoryPointImpl && this._parentStoryPointImpl.active;\n  }\n\n  private isInsideActiveDashboard() {\n    return this._parentDashboardImpl && this._parentDashboardImpl.active;\n  }\n\n  private isInsideDashboardExtension() {\n    return this._parentDashboardImpl !== null;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { LogicalTableInfo } from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of a logical table.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class LogicalTable implements Contract.LogicalTable {\n  public constructor(private _logicalTable: LogicalTableInfo) {}\n\n  public get id(): string {\n    return this._logicalTable.id;\n  }\n\n  public get caption(): string {\n    return this._logicalTable.caption;\n  }\n}\n","import { TooltipTextRequest, VisualId } from '@tableau/api-internal-contract-js';\n\nexport class TooltipTextRequestModel implements TooltipTextRequest {\n  public constructor(public visualIdPresModel: VisualId, public tupleId: number) {}\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DateRangeType, FilterDomainType, FilterType, PeriodType } from '@tableau/api-external-contract-js';\nimport { HierarchicalLevelSelectionState } from '@tableau/api-external-contract-js/lib/src/ExternalContract/Shared/Namespaces/Tableau';\nimport { DataSourceService } from '../Services/DataSourceService';\nimport { FilterService } from '../Services/FilterService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\n\nexport class Filter implements Contract.Filter {\n  public constructor(\n    protected _worksheetName: string,\n    protected _fieldName: string,\n    protected _filterType: FilterType,\n    protected _fieldId: string,\n    protected _registryId: number,\n  ) {}\n\n  public get worksheetName(): string {\n    return this._worksheetName;\n  }\n\n  public get fieldName(): string {\n    return this._fieldName;\n  }\n\n  public get fieldId(): string {\n    return this._fieldId;\n  }\n\n  public get filterType(): FilterType {\n    return this._filterType;\n  }\n\n  public getFieldAsync(): Promise<Contract.Field> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<DataSourceService>(ServiceNames.DataSourceService);\n    return service.getFieldAsync(this._fieldId);\n  }\n\n  public getAppliedWorksheetsAsync(): Promise<Array<string>> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getAppliedWorksheetsAsync(this._worksheetName, this._fieldId);\n  }\n\n  public setAppliedWorksheetsAsync(applyToWorksheets: Array<string>): Promise<Array<string>> {\n    ErrorHelpers.verifyParameter(applyToWorksheets, 'applyToWorksheets');\n    const uniqueWorksheets = new Set(applyToWorksheets);\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.setAppliedWorksheetsAsync(this._worksheetName, this._fieldName, this._fieldId, Array.from(uniqueWorksheets));\n  }\n}\n\nexport class CategoricalFilter extends Filter implements Contract.CategoricalFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _appliedValues: Array<Contract.DataValue>,\n    private _isExcludeMode: boolean,\n    private _isAllSelected?: boolean,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n\n  public get isAllSelected(): boolean | undefined {\n    return this._isAllSelected;\n  }\n\n  public get appliedValues(): Array<Contract.DataValue> {\n    return this._appliedValues;\n  }\n\n  public get isExcludeMode(): boolean {\n    return this._isExcludeMode;\n  }\n\n  public getDomainAsync(domainType?: FilterDomainType): Promise<Contract.CategoricalDomain> {\n    if (!domainType) {\n      domainType = FilterDomainType.Relevant;\n    }\n\n    ErrorHelpers.verifyEnumValue<FilterDomainType>(domainType, FilterDomainType, 'FilterDomainType');\n\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    return service.getCategoricalDomainAsync(this._worksheetName, this._fieldId, domainType);\n  }\n}\n\nexport class HierarchicalDataValue implements Contract.HierarchicalFilterDataValue {\n  public constructor(private _value: Contract.DataValue, private _hierarchicalPath: string, private _level: number) {}\n\n  public get value(): Contract.DataValue {\n    return this._value;\n  }\n\n  public get hierarchicalPath(): string {\n    return this._hierarchicalPath;\n  }\n\n  public get level(): number {\n    return this._level;\n  }\n}\n\nexport class HierarchicalLevelDetail implements Contract.HierarchicalLevelDetail {\n  public constructor(private _name: string, private _levelSelectionState: HierarchicalLevelSelectionState) {}\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get levelSelectionState(): HierarchicalLevelSelectionState {\n    return this._levelSelectionState;\n  }\n}\n\nexport class HierarchicalFilter extends Filter implements Contract.HierarchicalFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _dimensionName: string,\n    private _hierarchyCaption: string,\n    private _numberOfLevels: number,\n    private _levelDetails: Array<Contract.HierarchicalLevelDetail>,\n    private _appliedValues: Array<Contract.HierarchicalFilterDataValue>,\n    private _isAllSelected: boolean,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n  getDomainAsync(domainType?: Contract.FilterDomainType): Promise<Contract.CategoricalDomain> {\n    throw new Error('Method not implemented.');\n  }\n\n  public get dimensionName(): string {\n    return this._dimensionName;\n  }\n\n  public get hierarchyCaption(): string {\n    return this._hierarchyCaption;\n  }\n\n  public get numberOfLevels(): number {\n    return this._numberOfLevels;\n  }\n\n  public get levelDetails(): Contract.HierarchicalLevelDetail[] {\n    return this._levelDetails;\n  }\n\n  public get isAllSelected(): boolean {\n    return this._isAllSelected;\n  }\n\n  public get appliedValues(): Array<Contract.HierarchicalFilterDataValue> {\n    return this._appliedValues;\n  }\n}\n\nexport class RangeFilter extends Filter implements Contract.RangeFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _min: Contract.DataValue,\n    private _max: Contract.DataValue,\n    private _includeNullValues: boolean,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n\n  public get minValue(): Contract.DataValue {\n    return this._min;\n  }\n\n  public get maxValue(): Contract.DataValue {\n    return this._max;\n  }\n\n  public get includeNullValues(): boolean {\n    return this._includeNullValues;\n  }\n\n  public getDomainAsync(domainType?: FilterDomainType): Promise<Contract.RangeDomain> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<FilterService>(ServiceNames.Filter);\n    if (!domainType) {\n      domainType = FilterDomainType.Relevant;\n    }\n\n    ErrorHelpers.verifyEnumValue<FilterDomainType>(domainType, FilterDomainType, 'FilterDomainType');\n\n    return service.getRangeDomainAsync(this._worksheetName, this._fieldId, domainType);\n  }\n}\n\nexport class RelativeDateFilter extends Filter implements Contract.RelativeDateFilter {\n  public constructor(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    filterType: FilterType,\n    registryId: number,\n    private _anchorDate: Contract.DataValue,\n    private _periodType: PeriodType,\n    private _rangeType: DateRangeType,\n    private _rangeN: number,\n  ) {\n    super(worksheetName, fieldName, filterType, fieldId, registryId);\n  }\n\n  public get anchorDate(): Contract.DataValue {\n    return this._anchorDate;\n  }\n\n  public get periodType(): PeriodType {\n    return this._periodType;\n  }\n\n  public get rangeType(): DateRangeType {\n    return this._rangeType;\n  }\n\n  public get rangeN(): number {\n    return this._rangeN;\n  }\n}\n\nexport class CategoricalDomain implements Contract.CategoricalDomain {\n  public constructor(private _values: Array<Contract.DataValue>, private _domainType: FilterDomainType) {}\n\n  public get values(): Array<Contract.DataValue> {\n    return this._values;\n  }\n\n  public get type(): FilterDomainType {\n    return this._domainType;\n  }\n}\n\nexport class RangeDomain implements Contract.RangeDomain {\n  public constructor(private _min: Contract.DataValue, private _max: Contract.DataValue, private _domainType: FilterDomainType) {}\n\n  public get type(): FilterDomainType {\n    return this._domainType;\n  }\n\n  public get min(): Contract.DataValue {\n    return this._min;\n  }\n\n  public get max(): Contract.DataValue {\n    return this._max;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DataType, MarkType } from '@tableau/api-external-contract-js';\n\nexport class DataTable implements Contract.DataTable {\n  private _name: string;\n\n  public constructor(\n    private _data: Array<Array<Contract.DataValue>>,\n    private _columns: Array<Contract.Column>,\n    private _totalRowCount: number,\n    private _isTotalRowCountLimited: boolean,\n    private _isSummaryData: boolean,\n    private _marksInfo?: Array<MarkInfo>,\n  ) {\n    this._name = _isSummaryData ? 'Summary Data Table' : 'Underlying Data Table';\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  public get data(): Array<Array<Contract.DataValue>> {\n    return this._data;\n  }\n\n  public get columns(): Array<Contract.Column> {\n    return this._columns;\n  }\n\n  public get marksInfo(): Array<Contract.MarkInfo> | undefined {\n    return this._marksInfo;\n  }\n\n  public get totalRowCount(): number {\n    return this._totalRowCount;\n  }\n\n  public get isTotalRowCountLimited(): boolean | undefined {\n    return this._isTotalRowCountLimited;\n  }\n\n  public get isSummaryData(): boolean | undefined {\n    return this._isSummaryData;\n  }\n}\n\nexport class MarkInfo implements Contract.MarkInfo {\n  public constructor(private _type: MarkType, private _color: string, private _tupleId?: number) {}\n\n  public get type(): MarkType {\n    return this._type;\n  }\n\n  public get color(): string {\n    return this._color;\n  }\n\n  public get tupleId(): number | undefined {\n    return this._tupleId;\n  }\n}\n\nexport class Column implements Contract.Column {\n  public constructor(\n    private _fieldName: string,\n    private _fieldId: string,\n    private _dataType: DataType,\n    private _isReferenced: boolean,\n    private _index: number,\n  ) {}\n\n  public get fieldName(): string {\n    return this._fieldName;\n  }\n\n  public get fieldId(): string {\n    return this._fieldId;\n  }\n\n  public get dataType(): DataType {\n    return this._dataType;\n  }\n\n  public get isReferenced(): boolean {\n    return this._isReferenced;\n  }\n\n  public get index(): number {\n    return this._index;\n  }\n}\n\nexport class DataValue implements Contract.DataValue {\n  /* tslint:disable:no-any */\n  public constructor(private _value: any, private _nativeValue: any, private _formattedValue?: string) {}\n\n  public get value(): any {\n    return this._value;\n  }\n\n  public get nativeValue(): any {\n    return this._nativeValue;\n  }\n\n  public get formattedValue(): string | undefined {\n    return this._formattedValue;\n  }\n  /* tslint:enable:no-any */\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { GetDataService } from '../Services/GetDataService';\nimport { ApiServiceRegistry, ServiceNames } from '../Services/ServiceRegistry';\nimport { ErrorHelpers } from '../Utils/ErrorHelpers';\n\nexport class DataTableReader implements Contract.DataTableReader {\n  public constructor(protected _id: string, protected _totalRowCount: number, protected _pageRowCount, private _registryId: number) {\n    this._pageCount = Math.ceil(_totalRowCount / _pageRowCount);\n  }\n  protected _pageCount: number;\n\n  public get totalRowCount(): number {\n    return this._totalRowCount;\n  }\n\n  public get pageCount(): number {\n    return this._pageCount;\n  }\n\n  public getPageAsync(pageNumber: number): Promise<Contract.DataTable> {\n    ErrorHelpers.verifyRange(pageNumber, 0, this._pageCount);\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.getPageAsync(this._id, pageNumber, this._pageRowCount);\n  }\n\n  public async getAllPagesAsync(maxRows?: number): Promise<Contract.DataTable> {\n    const firstPage: Contract.DataTable = await this.getPageAsync(0);\n    maxRows = maxRows || this.totalRowCount;\n    const rowsRequested = Math.min(maxRows, this.totalRowCount);\n    const pagesRequested = Math.ceil(rowsRequested / this._pageRowCount);\n\n    // Fetch up to 400 pages, with a default of 10,000 pageRowCount that gives us 4,000,000 rows\n    const pagesToFetch = Math.min(pagesRequested, 400);\n    const isDataLimited = pagesToFetch < pagesRequested;\n    let remainingData: Array<Array<Array<Contract.DataValue>>> = [];\n    for (let i = 1; i < pagesToFetch; i++) {\n      const page = await this.getPageAsync(i);\n      remainingData.push(page.data);\n    }\n\n    let fullData = firstPage.data.concat(...remainingData);\n    // This slices the array only if maxRows has been set and is less than totalRowCount\n    fullData.length = rowsRequested;\n\n    return {\n      name: firstPage.name,\n      data: fullData,\n      columns: firstPage.columns,\n      totalRowCount: isDataLimited ? pagesToFetch * this._pageRowCount : rowsRequested,\n      isTotalRowCountLimited: isDataLimited,\n      isSummaryData: firstPage.isSummaryData,\n    };\n  }\n\n  public releaseAsync(): Promise<void> {\n    const service = ApiServiceRegistry.get(this._registryId).getService<GetDataService>(ServiceNames.GetData);\n    return service.releaseAsync(this._id);\n  }\n}\n","import { TooltipContext } from '@tableau/api-external-contract-js';\nimport { HoverTupleInteraction, SelectOptions, SelectTuplesInteraction, VisualId } from '@tableau/api-internal-contract-js';\n\n/**\n * Selection Model.\n */\nexport class SelectionModel {\n  public qualifiedFieldCaption: string;\n}\n\n/**\n * Value based selection model. Meant for hierarchical, range and categorical selections.\n */\nexport class ValueSelectionModel extends SelectionModel {\n  public selectValues: Array<string> = [];\n}\n\n/**\n * Hierarchical value selection model\n */\nexport class HierarchicalSelectionModel extends ValueSelectionModel {}\n\n/**\n * Range based value selection model\n */\nexport class RangeSelectionModel extends SelectionModel {\n  public minValue: string;\n  public maxValue: string;\n  public included: string;\n}\n\n/**\n * Dimension value selection model\n */\nexport class DimensionSelectionModel extends ValueSelectionModel {}\n/**\n * Tuple based selection model\n */\nexport class TupleSelectionModel {\n  public selectionType: string;\n  public objectIds: Array<string> = [];\n}\n\n/**\n * Container class to populate all the selection models when parsing input\n */\nexport class SelectionModelsContainer {\n  public hierModelArr: Array<HierarchicalSelectionModel> = [];\n  public dimModelArr: Array<DimensionSelectionModel> = [];\n  public quantModelArr: Array<RangeSelectionModel> = [];\n  public selection: TupleSelectionModel;\n}\n\nexport class SelectTuplesInteractionModel implements SelectTuplesInteraction {\n  public constructor(\n    public visualIdPresModel: VisualId,\n    public tupleIds: Array<number> = [],\n    public selectOptions: SelectOptions,\n    public tooltipContext?: TooltipContext,\n  ) {}\n}\n\nexport class HoverTupleInteractionModel implements HoverTupleInteraction {\n  public constructor(\n    public visualIdPresModel: VisualId,\n    public tupleId: number,\n    public tooltipContext?: TooltipContext | null,\n    public allowHoverActions?: boolean,\n  ) {}\n}\n","import * as Contract from '@tableau/api-external-contract-js';\n\nexport class Point implements Contract.Point {\n  public constructor(private _x: number, private _y: number) {}\n\n  public get x(): number {\n    return this._x;\n  }\n\n  public get y(): number {\n    return this._y;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { IncludeDataValuesOption } from '@tableau/api-external-contract-js';\nimport { VisualId } from '@tableau/api-internal-contract-js';\nimport { ApiService } from './ServiceRegistry';\n\n/**\n * Defines which type of getData call to make.\n */\nexport enum GetDataType {\n  Summary = 'summary',\n  Underlying = 'underlying',\n}\n\n/**\n * Service for implementing the logic for various getData calls\n *\n * @interface GetDataService\n * @extends {ApiService}\n */\nexport interface GetDataService extends ApiService {\n  /**\n   * Gets the limit of rows for getUnderlyingDataAsync\n   */\n  getMaxRowLimit(): number;\n\n  /**\n   * Gets the underlying data for a particular visual\n   *\n   * @param {VisualId} visualId  The visual id\n   * @param {GetDataType} getType  The type of getData call to make\n   * @param {boolean} ignoreAliases  Whether or not aliases should be ignored\n   * @param {boolean} ignoreSelection  Whether or not selection should be ignored\n   * @param {boolean} includeAllColumns  Should all columns be included\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns.\n   * @param {number} maxRows  Maximum number of rows to return\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getUnderlyingDataAsync(\n    visualId: VisualId,\n    getType: GetDataType,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   * @param {number} pageRowCount The number of rows per page. The default and maximum is 10,000 rows.\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {boolean} ignoreSelection  Whether selections in this viz should be ignored in the returned data\n   * @param {boolean} includeAllColumns  Should all columns be included\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns\n   * @returns {Promise<Contract.DataTableReader>}  Data table reader to access the underlying data\n   */\n  getSummaryDataReaderAsync(\n    visualId: VisualId,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader>;\n\n  /**\n   * Gets the currently selected marks for a given visual\n   *\n   * @param {VisualId} visualId  The visual id\n   * @returns {Promise<ActiveMarks>}  Collection of data tables with the active marks\n   */\n  getSelectedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection>;\n\n  /**\n   * Gets the currently highlighted marks for a given visual\n   *\n   * @param {VisualId} visualId  The visual id\n   * @returns {Promise<ActiveMarks>}  Collection of data tables with the active marks\n   */\n  getHighlightedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection>;\n\n  /**\n   * @param {string} datasourceId  The id of the datasource\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {number} maxRows The maximum number of rows to retrieve\n   * @param {Array<string>} columnsToInclude Columns which should be returned specified by caption. Empty means all columns\n   * @param {Array<string>} columnsToIncludeById Columns which should be returned specified by name. Empty means all columns\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getDataSourceDataAsync(\n    datasourceId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {string} datasourceId  The id of the datasource\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {number} maxRows The maximum number of rows to retrieve\n   * @param {Array<string>} columnsToInclude Columns which should be returned specified by caption. Empty means all columns\n   * @param {Array<string>} columnsToIncludeById Columns which should be returned specified by name. Empty means all columns\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getLogicalTableDataAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {string} datasourceId  The id of the datasource\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {number} pageRowCount The number of rows per page. The default and maximum is 10,000 rows.\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {Array<string>} columnsToIncludeById Columns which should be returned specified by name. Empty means all columns\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getLogicalTableDataReaderAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {boolean} ignoreSelection  Whether selections in this viz should be ignored in the returned data\n   * @param {boolean} includeAllColumns  Whether to include all columns or only the referenced columns\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns.\n   * @param {number} maxRows The maximum number of rows to retrieve\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getUnderlyingTableDataAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   * @param {string} logicalTableId  The id of the logcial table\n   * @param {number} pageRowCount The number of rows per page. The default and maximum is 10,000 rows.\n   * @param {boolean} ignoreAliases  Whether alias values should be ignored in the returned data\n   * @param {boolean} ignoreSelection  Whether selections in this viz should be ignored in the returned data\n   * @param {boolean} includeAllColumns  Whether to include all columns or only the referenced columns\n   * @param {Array} columnsToIncludeById Overrides includeAllColumns, lists the columns to include. Empty means all columns.\n   * @returns {Promise<Contract.DataTable>}  Data table with the requested data\n   */\n  getUnderlyingTableDataReaderAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader>;\n\n  /**\n   * @param {VisualId} visualId  The visual id\n   */\n  getSummaryColumnsInfoAsync(visualId: VisualId): Promise<Array<Contract.Column>>;\n\n  /**\n   * @param tableId     The table id used to fetch data.\n   * @param pageNumber  The page number (zero-based).\n   * @param pageSize    The page size of the owning DataTableReader\n   * @returns           A DataTable containing the requested page. The number of rows returned\n   *                    can be less than requested at the end of the data.\n   */\n  getPageAsync(tableId: string, pageNumber: number, pageSize: number): Promise<Contract.DataTable>;\n\n  /**\n   * @param tableId     The table id used to fetch data.\n   */\n  releaseAsync(tableId: string): Promise<void>;\n}\n","import { InternalApiDispatcher, VersionNumber } from '@tableau/api-internal-contract-js';\nimport { ApiServiceRegistry } from './ServiceRegistry';\nimport { AccessibilityServiceImpl } from './impl/AccessibilityServiceImpl';\nimport { AnimationServiceImpl } from './impl/AnimationServiceImpl';\nimport { AnnotationServiceImpl } from './impl/AnnotationServiceImpl';\nimport { DataSourceServiceImpl } from './impl/DataSourceServiceImpl';\nimport { ExportServiceImpl } from './impl/ExportServiceImpl';\nimport { ExternalContextMenuServiceImpl } from './impl/ExternalContextMenuServiceImpl';\nimport { FilterServiceImpl } from './impl/FilterServiceImpl';\nimport { GetDataServiceImpl } from './impl/GetDataServiceImpl';\nimport { NotificationServiceImpl } from './impl/NotificationServiceImpl';\nimport { ParametersServiceImpl } from './impl/ParametersServiceImpl';\nimport { SelectionServiceImpl } from './impl/SelectionServiceImpl';\nimport { SizeServiceImpl } from './impl/SizeServiceImpl';\nimport { VisualModelServiceImpl } from './impl/VisualModelServiceImpl';\nimport { VizServiceImpl } from './impl/VizServiceImpl';\nimport { ZoneServiceImpl } from './impl/ZoneServiceImpl';\n\nexport function registerAllSharedServices(dispatcher: InternalApiDispatcher, registryId: number, platformVersion?: VersionNumber): void {\n  ApiServiceRegistry.get(registryId).registerService(new AnimationServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new DataSourceServiceImpl(dispatcher, registryId, platformVersion));\n  ApiServiceRegistry.get(registryId).registerService(new ExportServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new GetDataServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new FilterServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new NotificationServiceImpl(dispatcher));\n  ApiServiceRegistry.get(registryId).registerService(new ParametersServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new SelectionServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new AnnotationServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new ZoneServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new SizeServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new VisualModelServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new VizServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new ExternalContextMenuServiceImpl(dispatcher, registryId));\n  ApiServiceRegistry.get(registryId).registerService(new AccessibilityServiceImpl(dispatcher, registryId));\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * Base interface for an api service\n */\nexport interface ApiService {\n  /**\n   * Gets the name for this service.\n   */\n  readonly serviceName: string;\n}\n\n/**\n * Collection of service name which will be registered in the api-shared project\n */\nexport const enum ServiceNames {\n  Accessibility = 'accessibility',\n  Authentication = 'authentication',\n  ClientInfo = 'client-info-service',\n  DataSourceService = 'data-source-service',\n  GetData = 'get-data-service',\n  Filter = 'filter-service',\n  Notification = 'notification-service',\n  Parameters = 'parameters-service',\n  Selection = 'selection-service',\n  Annotation = 'annotation-service',\n  Zone = 'zone-service',\n  Animation = 'animation-service',\n  Viz = 'viz-service',\n  ExternalContextMenu = 'external-context-menu-service',\n  Initialization = 'initialization-service',\n  StoryActivation = 'story-activation-service',\n  Size = 'size-service',\n  Export = 'export-service',\n  VisualModel = 'visual-model-service',\n}\n\n/**\n * Do some global declarations so we can create a singleton on the window object\n */\ndeclare global {\n  interface Window {\n    __tableauApiServiceRegistry: { [registryId: number]: ServiceRegistry };\n  }\n}\n\nwindow.__tableauApiServiceRegistry = window.__tableauApiServiceRegistry || {};\n\nexport interface ServiceRegistry {\n  /**\n   * Registers a new service into the service registry. Any existing one will\n   * be overwritten. the service is registered under service.serviceName\n   *\n   * @param {ApiService} service The servive to register\n   */\n  registerService(service: ApiService): void;\n\n  /**\n   * Retrieves the given service from the registry. If there is not a\n   * service registered under that name, throws and error\n   *\n   * @template T The type of the service\n   * @param {string} serviceName The name of the service.\n   * @returns {T} The requested service\n   */\n  getService<T extends ApiService>(serviceName: string): T;\n}\n\nclass ServiceRegistryImpl implements ServiceRegistry {\n  private _services: { [serviceName: string]: ApiService };\n\n  public constructor() {\n    this._services = {};\n  }\n\n  public registerService(service: ApiService): void {\n    this._services[service.serviceName] = service;\n  }\n\n  public getService<T extends ApiService>(serviceName: string): T {\n    if (!this._services.hasOwnProperty(serviceName)) {\n      throw new TableauError(ErrorCodes.InternalError, `Service not registered: ${serviceName}`);\n    }\n\n    return this._services[serviceName] as T;\n  }\n}\n\n/**\n * Static class used for getting access to the single instance\n * of the ApiServiceRegistry associated with the registryId.\n *\n * Extensions by design don't need to store/access multiple service registries. Their single instance of ServiceRegistry is\n * stored/access with registryId = 0.\n *\n * Whereas Embedding needs to be aware of which ServiceRegistry to use when there are multiple vizzes embedded.\n * An example of how window.__tableauApiServiceRegistry will look when there are two vizzes: { 0 : ServiceRegistry, 1 : ServiceRegistry}\n * where registry ID of 0 & 1 refers to viz's internal identifier (which is generated by VizManager).\n */\nexport class ApiServiceRegistry {\n  /**\n   * Gets the singleton instance of the ServiceRegistry\n   */\n  public static get(registryId: number): ServiceRegistry {\n    if (!window.__tableauApiServiceRegistry || !window.__tableauApiServiceRegistry[registryId]) {\n      ApiServiceRegistry.setInstance(registryId, new ServiceRegistryImpl());\n    }\n\n    if (!window.__tableauApiServiceRegistry[registryId]) {\n      throw new TableauError(ErrorCodes.InternalError, 'Service registry failed');\n    }\n\n    return window.__tableauApiServiceRegistry[registryId];\n  }\n\n  /**\n   * Helper method that sets the service registry instance for the corresponding registryId. Can be used by unit tests\n   *\n   * @param {ServiceRegistry} serviceRegistry The new registry\n   */\n  public static setInstance(registryId: number, serviceRegistry: ServiceRegistry): void {\n    if (!window.__tableauApiServiceRegistry) {\n      window.__tableauApiServiceRegistry = {};\n    }\n    window.__tableauApiServiceRegistry[registryId] = serviceRegistry;\n  }\n\n  /**\n   * Only used by unit tests\n   */\n  public static clearRegistry(): void {\n    window.__tableauApiServiceRegistry = {};\n  }\n\n  // Private to avoid anyone constructing this\n  private constructor() {}\n}\n","import { ExecuteParameters, ParameterId, VerbId, VisualId } from '@tableau/api-internal-contract-js';\nimport { TooltipTextRequestModel } from '../../Models/AccessibilityModels';\nimport { AccessibilityService } from '../AccessibilityService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class AccessibilityServiceImpl extends ServiceImplBase implements AccessibilityService {\n  public get serviceName(): string {\n    return ServiceNames.Accessibility;\n  }\n\n  public getTooltipTextAsync(visualId: VisualId, tupleId: number): Promise<String> {\n    let tooltipTextRequest = new TooltipTextRequestModel(visualId, tupleId);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getTooltipTextAsync',\n      [ParameterId.TooltipTextRequest]: tooltipTextRequest,\n    };\n\n    return this.execute(VerbId.GetTooltipText, parameters).then<String>((response) => {\n      return response.result as String;\n    });\n  }\n\n  public leaveMarkNavigationAsync(visualId: VisualId): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'leaveMarkNavigationAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n\n    return this.execute(VerbId.RaiseLeaveMarkNavNotification, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import { ReplaySpeedType } from '@tableau/api-external-contract-js';\nimport { ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ExternalToInternalEnumMappings as ExternalEnumConverter } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { ErrorHelpers } from '../../Utils/ErrorHelpers';\nimport { AnimationService } from '../AnimationService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class AnimationServiceImpl extends ServiceImplBase implements AnimationService {\n  public get serviceName(): string {\n    return ServiceNames.Animation;\n  }\n\n  public replayAsync(replaySpeed: ReplaySpeedType): Promise<void> {\n    const parameters = {\n      [ParameterId.ReplaySpeed]: 1.0,\n    };\n\n    ErrorHelpers.verifyEnumValue<ReplaySpeedType>(replaySpeed, ReplaySpeedType, 'ReplaySpeedType');\n    parameters[ParameterId.ReplaySpeed] = ExternalEnumConverter.setReplaySpeedType.convert(replaySpeed);\n\n    return this.execute(VerbId.ReplayAnimation, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { AnnotateEnum, Annotation, ExecuteParameters, ParameterId, VerbId, VisualId } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../../EnumMappings/InternalToExternalEnumMappings';\nimport { SelectionModelsContainer, TupleSelectionModel } from '../../Models/SelectionModels';\nimport { TableauError } from '../../TableauError';\nimport { AnnotationService } from '../AnnotationService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class AnnotationServiceImpl extends ServiceImplBase implements AnnotationService {\n  public get serviceName(): string {\n    return ServiceNames.Annotation;\n  }\n\n  /**\n   * Method to annotate a mark on the given worksheet.\n   *\n   * @param visualId\n   * @param mark\n   * @param annotationText\n   */\n  public annotateMarkAsync(visualId: VisualId, mark: Contract.MarkInfo, annotationText: string): Promise<void> {\n    const selectionModelContainer: SelectionModelsContainer = this.parseMarkSelectionIds([mark]);\n    const dummyTargetPoint = { x: 0, y: 0 };\n    const formattedText = `<formatted-text><run>${annotationText}</run></formatted-text>`;\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'annotateMarkAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.AnnotateEnum]: AnnotateEnum.Mark,\n      [ParameterId.TargetPoint]: dummyTargetPoint,\n      [ParameterId.SelectionList]: [selectionModelContainer.selection],\n      [ParameterId.FormattedText]: formattedText,\n    };\n    return this.execute(VerbId.CreateAnnotation, parameters).then<void>((response) => {\n      // Expecting an empty model and hence the void response.\n      return;\n    });\n  }\n\n  /**\n   * Method to retrieve annotations for the given worksheet.\n   *\n   * @param visualId\n   * @returns {Promise<Array<Annotation>>}\n   */\n  public getAnnotationsAsync(visualId: VisualId): Promise<Array<Contract.Annotation>> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getAnnotationsAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetAnnotations, parameters).then<Array<Contract.Annotation>>((response) => {\n      const annotationsList = response.result as Array<Annotation>;\n      return this.annotationFilterMap(annotationsList);\n    });\n  }\n\n  /**\n   * Method to remove an annotation from a given worksheet.\n   *\n   * @param visualId\n   * @param annotation\n   */\n  public removeAnnotationAsync(visualId: VisualId, annotation: Contract.Annotation): Promise<void> {\n    const selectionModelContainer: SelectionModelsContainer = this.parseAnnotationSelectionIds([annotation]);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'removeAnnotationAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.SelectionList]: [selectionModelContainer.selection],\n    };\n    return this.execute(VerbId.RemoveAnnotation, parameters).then<void>((response) => {\n      // Expecting an empty model and hence the void response.\n      return;\n    });\n  }\n\n  /**\n   * Method to prepare the pres models for selection by MarksInfo\n   * @param marks\n   */\n  private parseMarkSelectionIds(marks: Array<Contract.MarkInfo>): SelectionModelsContainer {\n    const ids: Array<string> = [];\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n    marks.forEach((mark) => {\n      const tupleId: number | undefined = mark.tupleId;\n      if (tupleId !== undefined && tupleId !== null && tupleId > 0) {\n        ids.push(tupleId.toString()); // collect the tuple ids\n      } else {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'invalid tupleId');\n      }\n    });\n    if (ids.length !== 0) {\n      // tuple ids based selection\n      const tupleSelectionModel: TupleSelectionModel = new TupleSelectionModel();\n      tupleSelectionModel.selectionType = 'tuples';\n      tupleSelectionModel.objectIds = ids;\n      selectionModelContainer.selection = tupleSelectionModel;\n    }\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to prepare the pres models for selection by MarkAnnotationInfo\n   * @param marks\n   */\n  private parseAnnotationSelectionIds(annotations: Array<Contract.Annotation>): SelectionModelsContainer {\n    const ids: Array<string> = [];\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n    annotations.forEach((annotation) => {\n      const annotationId: number | undefined = annotation.annotationId;\n      if (annotationId !== undefined && annotationId !== null && annotationId >= 0) {\n        ids.push(annotationId.toString()); // collect the annotation ids\n      } else {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'invalid annotationId');\n      }\n    });\n    if (ids.length !== 0) {\n      // annotation ids based selection\n      const tupleSelectionModel: TupleSelectionModel = new TupleSelectionModel();\n      tupleSelectionModel.selectionType = 'annotations';\n      tupleSelectionModel.objectIds = ids;\n      selectionModelContainer.selection = tupleSelectionModel;\n    }\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to map Annotation to MarkAnnotationInfo\n   * @param annotation\n   * @returns {Annotation}\n   */\n  private mapAnnotation(annotation: Annotation): Contract.Annotation {\n    return {\n      annotationHTML: annotation.annotationText,\n      annotationId: annotation.annotationId,\n      annotationText: annotation.annotationPlainText,\n      annotationType: InternalToExternalEnumMappings.annotationType.convert(annotation.annotateEnum),\n      tupleId: annotation.tupleId!,\n    };\n  }\n\n  /**\n   * Filter the Annotations to Mark Annotations, and map them to MarkAnnotationInfo\n   * @param annotations\n   * @returns {Array<Annotation>}\n   */\n  private annotationFilterMap(annotations: Array<Annotation>): Array<Contract.Annotation> {\n    const annotationInfos = annotations.map((annotation) => this.mapAnnotation(annotation));\n\n    return annotationInfos;\n  }\n}\n","import { EmbeddingBootstrapInfo, ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ClientInfoService } from '../ClientInfoService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ClientInfoServiceImpl extends ServiceImplBase implements ClientInfoService {\n  public get serviceName(): string {\n    return ServiceNames.ClientInfo;\n  }\n\n  public getClientInfoAsync(): Promise<EmbeddingBootstrapInfo> {\n    const verb = VerbId.GetEmbeddingClientInfo;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getClientInfoAsync',\n    };\n\n    return this.execute(verb, parameters).then<EmbeddingBootstrapInfo>((response) => {\n      const clientInfo = response.result as EmbeddingBootstrapInfo;\n      return clientInfo;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes } from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport {\n  ConnectionDescriptionSummary,\n  DataSchema,\n  ExecuteParameters,\n  InternalApiDispatcher,\n  LogicalTableInfo,\n  ParameterId,\n  TableInfo,\n  TableInfos,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport { DataSource } from '../../DataSource';\nimport { Field } from '../../Field';\nimport { DataSourceImpl } from '../../Impl/DataSourceImpl';\nimport { FieldImpl } from '../../Impl/FieldImpl';\nimport { TableauError } from '../../TableauError';\nimport { DataSourceService } from '../DataSourceService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport const SENTINEL_LOGICAL_TABLE_INFO: LogicalTableInfo = {\n  id: InternalContract.ApiShowDataTableSentinel.SingleTableId,\n  caption: InternalContract.ApiShowDataTableSentinel.SingleTableCaption,\n};\n\n// The minimum platform version when Object Model was supported\nconst platformVersionObjectModelSupport = { major: 1, minor: 20, fix: 1 };\n\nexport class DataSourceServiceImpl extends ServiceImplBase implements DataSourceService {\n  // Since Object Model is supported since Tableau 2020.2, DataSourceServiceImpl can be initialized with the\n  // platform version when OM was supported. Once we drop support for Tableau versions <= 2020.1, all additional\n  // code in here for Object Model can be removed.\n  public constructor(\n    dispatcher: InternalApiDispatcher,\n    registryId: number,\n    private _platformVersion: InternalContract.VersionNumber = platformVersionObjectModelSupport,\n  ) {\n    super(dispatcher, registryId);\n  }\n  public get serviceName(): string {\n    return ServiceNames.DataSourceService;\n  }\n\n  public refreshAsync(dataSourceId?: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'refreshAsync',\n      [ParameterId.DeltaTimeMs]: 0,\n      [ParameterId.ShouldRefreshDS]: true,\n    };\n\n    // On server: Not passing the datasource id will refresh all datasources.\n    if (dataSourceId) {\n      parameters[ParameterId.DataSourceId] = dataSourceId;\n    }\n\n    return this.execute(VerbId.RefreshDataSource, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public getActiveTablesAsync(dataSourceId: string): Promise<Array<TableInfo>> {\n    const joinParameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getActiveTablesAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n    };\n\n    // Get the description of the tables used by this connection\n    return this.execute(VerbId.GetActiveTables, joinParameters).then<Array<TableInfo>>((joinResponse) => {\n      const tableInfos = joinResponse.result as TableInfos;\n\n      // getActiveTables is unsupported for cubes and GA. We do not have a connection type property\n      // available from the platform (intentionally, to reduce code churn as new connections are added).\n      // Instead,just check if any tables are returned. This array will be empty for any non-table based datasource.\n      if (tableInfos.tables.length === 0) {\n        throw new TableauError(ErrorCodes.UnsupportedMethodForDataSourceType, `getActiveTables is not supported for: ${dataSourceId}`);\n      }\n\n      return tableInfos.tables;\n    });\n  }\n\n  public getDataSourcesAsync(visualId: VisualId): Promise<DataSchema> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getDataSourcesAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetDataSources, parameters).then<DataSchema>((response) => {\n      const dataSchema = response.result as DataSchema;\n      return dataSchema;\n    });\n  }\n\n  public getAllDataSourcesAsync(): Promise<DataSchema> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getAllDataSourcesAsync',\n    };\n    return this.execute(VerbId.GetAllDataSources, parameters).then<DataSchema>((response) => {\n      const dataSchema = response.result as DataSchema;\n      return dataSchema;\n    });\n  }\n\n  public getConnectionSummariesAsync(dataSourceId: string): Promise<ConnectionDescriptionSummary[]> {\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getConnectionSummariesAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n    };\n\n    // Get the description of the tables used by this connection\n    return this.execute(VerbId.GetConnectionDescriptionSummaries, params).then<ConnectionDescriptionSummary[]>((response) => {\n      const descriptionSummaries = response.result as ConnectionDescriptionSummary[];\n      return descriptionSummaries;\n    });\n  }\n\n  public getFieldAsync(globalfieldName: string): Promise<Contract.Field> {\n    const verb = VerbId.GetFieldAndDataSource;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getFieldAsync',\n      [ParameterId.FieldId]: globalfieldName,\n    };\n\n    return this.execute(verb, parameters).then<Contract.Field>((response) => {\n      const dataSource = response.result[ParameterId.DataSource] as InternalContract.DataSource;\n      const field = response.result[ParameterId.Field] as Field;\n      return this.convertField(field, this.convertDataSource(dataSource));\n    });\n  }\n\n  public getLogicalTablesAsync(dataSourceId: string): Promise<Array<LogicalTableInfo>> {\n    if (!this.isObjectModelSupportedByPlatform()) {\n      /**\n       * This sentinel ID can be passed to datasource.getLogicalTableData.\n       * Once the desktop is upgraded to a version that supports object model,\n       * the sentinel ID will automatically fetch the upgraded table.\n       * */\n      return new Promise<Array<LogicalTableInfo>>((resolve) => resolve([SENTINEL_LOGICAL_TABLE_INFO]));\n    }\n\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getLogicalTablesAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n    };\n    return this.execute(VerbId.GetLogicalTables, params).then<Array<LogicalTableInfo>>((response) => {\n      return response.result as Array<LogicalTableInfo>;\n    });\n  }\n\n  public getUnderlyingTablesAsync(visualId: VisualId): Promise<Array<LogicalTableInfo>> {\n    if (!this.isObjectModelSupportedByPlatform()) {\n      /**\n       * This sentinel ID can be passed to worksheet.getUnderlyingTableData.\n       * Once the desktop is upgraded to a version that supports object model,\n       * the sentinel ID will automatically fetch the upgraded table.\n       * */\n      return new Promise<Array<LogicalTableInfo>>((resolve) => resolve([SENTINEL_LOGICAL_TABLE_INFO]));\n    }\n\n    const params: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getUnderlyingTablesAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetUnderlyingTables, params).then<Array<LogicalTableInfo>>((response) => {\n      return response.result as Array<LogicalTableInfo>;\n    });\n  }\n\n  private convertField(field: InternalContract.Field, dataSource: Contract.DataSource): Contract.Field {\n    return new Field(new FieldImpl(field, dataSource));\n  }\n\n  private convertDataSource(dataSource: InternalContract.DataSource): Contract.DataSource {\n    return new DataSource(new DataSourceImpl(dataSource, this._registryId));\n  }\n\n  private isObjectModelSupportedByPlatform(): boolean {\n    const platformVersionNoObjectModelSupport = { major: 1, minor: 13, fix: 0 };\n    return InternalContract.VersionLessThan(platformVersionNoObjectModelSupport, this._platformVersion);\n  }\n}\n","import {\n  ExecuteParameters,\n  ExportCrosstabSheetMap,\n  ExportFile,\n  ExportPDFOptions as InternalExportPDFOptions,\n  ParameterId,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport {\n  CrosstabFileFormat,\n  ExportDataOptions,\n  ExportPDFOptions as ExternalExportPDFOptions,\n  ExportScenariosForPDFAndPowerPoint,\n  SharedErrorCodes,\n  SheetType as ExternalSheetType,\n} from '@tableau/api-external-contract-js';\nimport { ExternalToInternalEnumMappings } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { ExportHelpers } from '../../Utils/ExportHelpers';\nimport { ExportService } from '../ExportService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ErrorHelpers } from '../../Utils/ErrorHelpers';\nimport { TableauError } from '../../TableauError';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ExportServiceImpl extends ServiceImplBase implements ExportService {\n  public get serviceName(): string {\n    return ServiceNames.Export;\n  }\n\n  public getExportCrosstabSheetMapAsync(currentSheetType: ExternalSheetType): Promise<ExportCrosstabSheetMap> {\n    const verb = VerbId.GetExportCrosstabSheetMap;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getExportCrosstabSheetMapAsync',\n      [ParameterId.CurrentSheetType]: ExternalToInternalEnumMappings.sheetType.convert(currentSheetType),\n    };\n    return this.execute(verb, parameters).then<ExportCrosstabSheetMap>((response) => {\n      const result = response.result as ExportCrosstabSheetMap;\n      return result;\n    });\n  }\n\n  public async exportCrosstabAsync(\n    sheetName: string,\n    format: CrosstabFileFormat,\n    exportableWorksheetNames: Array<string>,\n    currentSheetType: ExternalSheetType,\n  ): Promise<ExportFile> {\n    ErrorHelpers.verifySheetName(exportableWorksheetNames, sheetName);\n    ErrorHelpers.verifyEnumValue<CrosstabFileFormat>(format, CrosstabFileFormat, 'CrosstabFileFormat');\n\n    // The pres layer command for exporting Crosstab uses SimpleSheetIdentifiers instead of sheet names.\n    // The extensions-and-embedding-api current does not store references to the SimpleSheetIdentifiers of its sheets\n    // so we call a pres layer command that gives us the SimpleSheetIdentifier for each sheet name that appears in the\n    // export Crosstab dialog popup.\n    const sheetNameToIdMap = await this.getExportCrosstabSheetMapAsync(currentSheetType);\n    if (!sheetNameToIdMap[sheetName]) {\n      throw new TableauError(SharedErrorCodes.InternalError, 'missing sheet doc id from sheetMap');\n    }\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportCrosstabAsync',\n      [ParameterId.SheetIdentifier]: sheetNameToIdMap[sheetName],\n      [ParameterId.SendNotifications]: true, // send notification on pres layer that triggers file download\n    };\n\n    // pres layer command invoked depends on the crosstab file format\n    let verb;\n    switch (format) {\n      case CrosstabFileFormat.CSV:\n        verb = VerbId.ExportCrosstabCsvDownload;\n        // CSV only parameter: see browser-clients/export-crosstab-options-dialog repo\n        parameters[ParameterId.UseTabDelimiters] = true;\n        break;\n      case CrosstabFileFormat.Excel:\n        verb = VerbId.ExportCrosstabExcelDownload;\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'unsupported Crosstab file format.');\n    }\n\n    return this.execute(verb, parameters)\n      .then<ExportFile>((response) => {\n        const result = response.result as ExportFile;\n        return result;\n      })\n      .catch(() => {\n        throw new TableauError(SharedErrorCodes.CrosstabCreationError, 'An unexpected error occurred while generating the document.');\n      });\n  }\n\n  public exportDataAsync(visualId: VisualId, options: ExportDataOptions): Promise<void> {\n    ErrorHelpers.verifyExportDataOptions(options);\n\n    // Remove any duplicates from the input array\n    const columnsAsSet: Set<string> = new Set(options.columnsToIncludeById);\n    const columnsToIncludeById = Array.from(columnsAsSet);\n\n    const verb = VerbId.ExportDataDownload;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportDataAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.IgnoreAliases]: options.ignoreAliases ?? false,\n      [ParameterId.ColumnsToIncludeById]: columnsToIncludeById,\n    };\n\n    return this.execute(verb, parameters)\n      .then<void>(() => {})\n      .catch(() => {\n        throw new TableauError(SharedErrorCodes.DataCreationError, 'An unexpected error occurred while generating the document.');\n      });\n  }\n\n  public exportPowerPointAsync(sheetNames: Array<string>, exportScenarios: ExportScenariosForPDFAndPowerPoint): Promise<ExportFile> {\n    ErrorHelpers.verifySheetNamesForPDFAndPPT(sheetNames, exportScenarios);\n\n    // Note: the ExportOriginUrl param is listed as optional for the pres layer command we are invoking; however,\n    // recent changes were made that enforced the use of the empty string when invoking this command with no ExportOriginUrl.\n    // see browser-clients/export-powerpoint-options-dialog repo.\n    const verb = VerbId.ExportPowerpointDownload;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportPowerPointAsync',\n      [ParameterId.ExportOriginUrl]: '',\n      [ParameterId.SelectedSheetNames]: sheetNames,\n    };\n\n    return this.execute(verb, parameters)\n      .then<ExportFile>((response) => {\n        const result = response.result as ExportFile;\n        return result;\n      })\n      .catch(() => {\n        throw new TableauError(\n          SharedErrorCodes.PowerPointCreationError,\n          'An error occured while attempting to generate the PowerPoint file.',\n        );\n      });\n  }\n\n  public async exportPDFAsync(\n    sheetNames: Array<string>,\n    externalExportPdfOptions: ExternalExportPDFOptions,\n    exportScenarios: ExportScenariosForPDFAndPowerPoint,\n  ): Promise<ExportFile> {\n    ErrorHelpers.verifyExportPDFOptions(externalExportPdfOptions);\n    ErrorHelpers.verifySheetNamesForPDFAndPPT(sheetNames, exportScenarios);\n\n    const internalExportPdfOptions: InternalExportPDFOptions = await this.getExportPDFOptionsAsync();\n    ExportHelpers.updateInternalExportPDFOptions(internalExportPdfOptions, externalExportPdfOptions, sheetNames);\n\n    const verb = VerbId.ExportPdfDownload;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'exportPDFAsync',\n      [ParameterId.ExportPdfOptions]: internalExportPdfOptions,\n    };\n\n    return this.execute(verb, parameters)\n      .then<ExportFile>((response) => {\n        const result = response.result as ExportFile;\n        return result;\n      })\n      .catch(() => {\n        throw new TableauError(SharedErrorCodes.PDFCreationError, 'Unable to create PDF because something went wrong. Try again.');\n      });\n  }\n\n  public getExportPDFOptionsAsync(): Promise<InternalExportPDFOptions> {\n    const verb = VerbId.GetExportPdfOptions;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getExportPdfOptionsAsync',\n    };\n    return this.execute(verb, parameters).then<InternalExportPDFOptions>((response) => {\n      const result = response.result as InternalExportPDFOptions;\n      return result;\n    });\n  }\n}\n","import { ApiMenuType, ContextMenuOptions } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ExternalContextMenuService } from '../ExternalContextMenuService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ExternalContextMenuServiceImpl extends ServiceImplBase implements ExternalContextMenuService {\n  public get serviceName(): string {\n    return ServiceNames.ExternalContextMenu;\n  }\n\n  public appendContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, config: ContextMenuOptions): Promise<string> {\n    const verb = VerbId.AppendExternalMenuItem;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'appendContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuItemDisplayName]: config.displayName,\n    };\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      const newMenuItemId = response.result as string;\n      return newMenuItemId;\n    });\n  }\n\n  public removeContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    const verb = VerbId.RemoveExternalMenuItem;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'removeContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuItemId]: menuItemId,\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public executeContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, menuItemId: string): Promise<void> {\n    const verb = VerbId.ExecuteExternalMenuItem;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'executeContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuItemId]: menuItemId,\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public renameContextMenuAsync(sheetName: string, targetMenu: ApiMenuType, menuHeader: string, menuDescription: string): Promise<void> {\n    const verb = VerbId.RenameExternalMenu;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'renameContextMenuAsync',\n      [ParameterId.WorksheetName]: sheetName,\n      [ParameterId.ExternalMenuHeader]: menuHeader,\n      [ParameterId.ExternalMenuDescription]: menuDescription,\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  DateRangeType,\n  EmbeddingErrorCodes,\n  ErrorCodes,\n  FilterDomainType,\n  FilterType as ExternalFilterType,\n  SharedErrorCodes,\n} from '@tableau/api-external-contract-js';\nimport * as InternalContract from '@tableau/api-internal-contract-js';\nimport { ExecuteParameters, FilterType, ParameterId, VerbId, VisualId } from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../../../ApiShared';\nimport { ExternalToInternalEnumMappings as ExternalEnumConverter } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { InternalToExternalEnumMappings as InternalEnumConverter } from '../../EnumMappings/InternalToExternalEnumMappings';\nimport {\n  CategoricalDomain,\n  CategoricalFilter,\n  HierarchicalDataValue,\n  HierarchicalFilter,\n  HierarchicalLevelDetail,\n  RangeDomain,\n  RangeFilter,\n  RelativeDateFilter,\n} from '../../Models/FilterModels';\nimport { DataValue } from '../../Models/GetDataModels';\nimport { DataValueFactory } from '../../Utils/DataValueFactory';\nimport { Param } from '../../Utils/Param';\nimport { FilterService } from '../FilterService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class FilterServiceImpl extends ServiceImplBase implements FilterService {\n  public get serviceName(): string {\n    return ServiceNames.Filter;\n  }\n\n  public applyFilterAsync(\n    visualId: VisualId,\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    filterOptions: Contract.FilterOptions,\n  ): Promise<string> {\n    const verb = VerbId.ApplyCategoricalFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n    if (!Array.isArray(values)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'values parameter for applyFilterAsync must be an array');\n    }\n    parameters[ParameterId.FilterValues] = values;\n    parameters[ParameterId.FilterUpdateType] = ExternalEnumConverter.filterUpdateType.convert(updateType);\n    parameters[ParameterId.IsExcludeMode] =\n      filterOptions === undefined || filterOptions.isExcludeMode === undefined ? false : filterOptions.isExcludeMode;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return fieldName;\n    });\n  }\n\n  public applyRangeFilterAsync(visualId: VisualId, fieldName: string, filterOptions: Contract.RangeFilterOptions): Promise<string> {\n    const verb = VerbId.ApplyRangeFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyRangeFilterAsync',\n    };\n\n    if (filterOptions.min !== undefined && filterOptions.min !== null) {\n      let min: string | number;\n      if (filterOptions.min instanceof Date) {\n        min = Param.serializeDateForPlatform(filterOptions.min);\n      } else {\n        min = filterOptions.min;\n      }\n      parameters[ParameterId.FilterRangeMin] = min;\n    }\n\n    if (filterOptions.max !== undefined && filterOptions.max !== null) {\n      let max: string | number;\n      if (filterOptions.max instanceof Date) {\n        max = Param.serializeDateForPlatform(filterOptions.max);\n      } else {\n        max = filterOptions.max;\n      }\n      parameters[ParameterId.FilterRangeMax] = max;\n    }\n\n    // The null option is used with min+max for 'include-range' or 'include-range-or-null'\n    if (filterOptions.nullOption) {\n      parameters[ParameterId.FilterRangeNullOption] = ExternalEnumConverter.nullOptions.convert(filterOptions.nullOption);\n    }\n\n    parameters[ParameterId.FieldName] = fieldName;\n    parameters[ParameterId.VisualId] = visualId;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      this.apiFilterHandlerCheckForCommandError(response.result as { [key: string]: string });\n      return fieldName;\n    });\n  }\n\n  public applyHierarchicalFilterAsync(\n    visualId: VisualId,\n    fieldName: string,\n    values: Array<string> | Contract.HierarchicalLevels,\n    updateType: Contract.FilterUpdateType,\n    filterOptions: Contract.FilterOptions,\n  ): Promise<string> {\n    const verb = VerbId.HierarchicalFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyHierarchicalFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n\n    const hierarchicalLevels = (values as Contract.HierarchicalLevels).levels;\n\n    if (Array.isArray(hierarchicalLevels) && hierarchicalLevels.length > 0) {\n      parameters[ParameterId.FilterLevels] = hierarchicalLevels;\n    } else if ((values as Array<String>).length > 0) {\n      parameters[ParameterId.FilterValues] = values;\n    } else {\n      // the server command expects empty list for clearing the filter\n      // it also expects eithers FilterLevels or FilterValues to be set\n      parameters[ParameterId.FilterLevels] = [];\n    }\n\n    parameters[ParameterId.FilterUpdateType] = ExternalEnumConverter.filterUpdateType.convert(updateType);\n    parameters[ParameterId.IsExcludeMode] = filterOptions && !!filterOptions.isExcludeMode;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return fieldName;\n    });\n  }\n\n  public clearFilterAsync(visualId: VisualId, fieldName: string): Promise<string> {\n    const verb = VerbId.ClearFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'clearFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n    return this.execute(verb, parameters).then<string>((resposne) => {\n      return fieldName;\n    });\n  }\n\n  public applyRelativeDateFilterAsync(visualId: VisualId, fieldName: string, options: Contract.RelativeDateFilterOptions) {\n    const verb = VerbId.ApplyRelativeDateFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyRelativeDateFilterAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.FieldName] = fieldName;\n    parameters[ParameterId.PeriodType] = ExternalEnumConverter.periodType.convert(options.periodType);\n    parameters[ParameterId.DateRangeType] = ExternalEnumConverter.dateRangeType.convert(options.rangeType);\n    if (options.rangeType === DateRangeType.LastN || options.rangeType === DateRangeType.NextN) {\n      if (options.rangeN === undefined || options.rangeN === null) {\n        throw new TableauError(\n          EmbeddingErrorCodes.MissingRangeNForRelativeDateFilters,\n          'Missing rangeN field for a relative date filter of LASTN or NEXTN.',\n        );\n      }\n      parameters[ParameterId.RangeN] = options.rangeN;\n    }\n\n    if (options.anchorDate !== undefined && options.anchorDate !== null) {\n      parameters[ParameterId.AnchorDate] = this.convertAnchorDate(options.anchorDate);\n    }\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return response.result as string;\n    });\n  }\n\n  public getFiltersAsync(visualId: VisualId): Promise<Array<Contract.Filter>> {\n    const verb = VerbId.GetFilters;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getFiltersAsync',\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    return this.execute(verb, parameters).then<Array<Contract.Filter>>((response) => {\n      const filters = response.result as Array<InternalContract.Filter>;\n      return this.convertDomainFilters(filters);\n    });\n  }\n\n  public getCategoricalDomainAsync(\n    worksheetName: string,\n    fieldId: string,\n    domainType: FilterDomainType,\n  ): Promise<Contract.CategoricalDomain> {\n    const verb = VerbId.GetCategoricalDomain;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getCategoricalDomainAsync',\n    };\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n\n    parameters[ParameterId.FieldId] = fieldId;\n    parameters[ParameterId.DomainType] = ExternalEnumConverter.filterDomainType.convert(domainType);\n    return this.execute(verb, parameters).then<Contract.CategoricalDomain>((response) => {\n      const domain = response.result as InternalContract.CategoricalDomain;\n      return this.convertCategoricalDomain(domain, domainType);\n    });\n  }\n\n  public getRangeDomainAsync(worksheetName: string, fieldId: string, domainType: FilterDomainType): Promise<Contract.RangeDomain> {\n    const verb = VerbId.GetRangeDomain;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getRangeDomainAsync',\n    };\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n\n    parameters[ParameterId.FieldId] = fieldId;\n    parameters[ParameterId.DomainType] = ExternalEnumConverter.filterDomainType.convert(domainType);\n    return this.execute(verb, parameters).then<Contract.RangeDomain>((response) => {\n      const domain = response.result as InternalContract.RangeDomain;\n\n      return this.convertRangeDomain(domain, domainType);\n    });\n  }\n\n  public getDashboardFiltersAsync(): Promise<Array<Contract.Filter>> {\n    const verb = VerbId.GetDashboardFilters;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getDashboardFiltersAsync',\n    };\n    return this.execute(verb, parameters).then<Array<Contract.Filter>>((response) => {\n      const filters = response.result as Array<InternalContract.Filter>;\n      return this.convertDomainFilters(filters);\n    });\n  }\n\n  public applyDashboardFilterAsync(\n    fieldName: string,\n    values: Array<string>,\n    updateType: Contract.FilterUpdateType,\n    filterOptions: Contract.FilterOptions,\n  ): Promise<string> {\n    const verb = VerbId.DashboardCategoricalFilter;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'applyDashboardFilterAsync',\n    };\n    parameters[ParameterId.FieldName] = fieldName;\n    parameters[ParameterId.FilterValues] = values;\n    parameters[ParameterId.FilterUpdateType] = ExternalEnumConverter.filterUpdateType.convert(updateType);\n    parameters[ParameterId.IsExcludeMode] = filterOptions && !!filterOptions.isExcludeMode;\n\n    return this.execute(verb, parameters).then<string>((response) => {\n      return response.result as string;\n    });\n  }\n\n  public async getAppliedWorksheetsAsync(worksheetName: string, fieldId: string): Promise<Array<string>> {\n    const sharedFilterModel = await this.executeGetAppliedWorksheets(worksheetName, fieldId, 'getAppliedWorksheetsAsync');\n    const worksheetNames: string[] = [];\n    sharedFilterModel.worksheets?.map((worksheetInfo: InternalContract.SharedFilterWorksheetModel) => {\n      if (worksheetInfo.isSelected) {\n        worksheetNames.push(worksheetInfo.worksheetName);\n      }\n    });\n    return worksheetNames;\n  }\n\n  public async setAppliedWorksheetsAsync(\n    worksheetName: string,\n    fieldName: string,\n    fieldId: string,\n    applyToWorksheets: Array<string>,\n  ): Promise<Array<string>> {\n    const sharedFilterModel = await this.executeGetAppliedWorksheets(worksheetName, fieldId, 'getAppliedWorksheetsAsyncInternal');\n    if (!sharedFilterModel || !sharedFilterModel.worksheets) {\n      throw new TableauError(SharedErrorCodes.InternalError, 'This filter does not apply to multiple worksheets');\n    }\n\n    const allowedWorksheets: string[] = [];\n    let activeWorksheet = '';\n    sharedFilterModel.worksheets.forEach((worksheet) => {\n      // Get active worksheet\n      if (worksheet.isActive) {\n        activeWorksheet = worksheet.worksheetName;\n      }\n\n      // Populate allowed worksheets\n      if (worksheet.isSelected || worksheet.isEnabled) {\n        allowedWorksheets.push(worksheet.worksheetName);\n      }\n    });\n\n    if (activeWorksheet === '') {\n      throw new TableauError(SharedErrorCodes.InternalError, 'No active worksheet');\n    }\n\n    if (!applyToWorksheets.includes(activeWorksheet)) {\n      throw new TableauError(SharedErrorCodes.InternalError, `${activeWorksheet} must be included in the applied worksheets`);\n    }\n\n    applyToWorksheets.forEach((sheet) => {\n      // check if it's present within compatible sheets\n      if (!allowedWorksheets.includes(sheet)) {\n        throw new TableauError(SharedErrorCodes.InternalError, `The field ${fieldName} isn't applicable to the worksheet ${sheet}`);\n      }\n    });\n\n    const verb = VerbId.ChangeSharedFilter;\n    const parameters: ExecuteParameters = {};\n    parameters[ParameterId.FunctionName] = 'setAppliedWorksheetsAsync';\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n    parameters[ParameterId.FieldId] = fieldId;\n    parameters[ParameterId.SharedFilterSheets] = applyToWorksheets;\n\n    return this.execute(verb, parameters).then<string[]>((response) => {\n      return applyToWorksheets;\n    });\n  }\n\n  // Helper Methods\n\n  private executeGetAppliedWorksheets(\n    worksheetName: string,\n    fieldId: string,\n    telemetryFunctionName: string,\n  ): Promise<InternalContract.SharedFilterModel> {\n    const verb = VerbId.GetSharedFilter;\n    const parameters: ExecuteParameters = {};\n    parameters[ParameterId.FunctionName] = telemetryFunctionName;\n    parameters[ParameterId.VisualId] = {\n      worksheet: worksheetName,\n    };\n    parameters[ParameterId.FieldId] = fieldId;\n\n    return this.execute(verb, parameters).then<InternalContract.SharedFilterModel>((response) => {\n      const sharedFilterModel = response.result as InternalContract.SharedFilterModel;\n      return sharedFilterModel;\n    });\n  }\n\n  private convertDomainFilters(domainFilters: Array<InternalContract.Filter>): Array<Contract.Filter> {\n    const filters: Array<Contract.Filter> = [];\n    domainFilters.forEach((domainFilter) => {\n      switch (domainFilter.filterType) {\n        case FilterType.Categorical: {\n          const filter = domainFilter as InternalContract.CategoricalFilter;\n          if (filter) {\n            filters.push(this.convertCategoricalFilter(filter));\n          } else {\n            throw new Error('Invalid Categorical Filter');\n          }\n          break;\n        }\n\n        case FilterType.Hierarchical: {\n          const filter = domainFilter as InternalContract.HierarchicalFilter;\n          if (filter) {\n            filters.push(this.convertHierarchicalFilter(filter));\n          } else {\n            throw new Error('Invalid Hierarchical Filter');\n          }\n          break;\n        }\n\n        case FilterType.Range: {\n          const filter = domainFilter as InternalContract.RangeFilter;\n          if (filter) {\n            filters.push(this.convertRangeFilter(filter));\n          } else {\n            throw new Error('Invalid Range Filter');\n          }\n          break;\n        }\n\n        case FilterType.RelativeDate: {\n          const filter = domainFilter as InternalContract.RelativeDateFilter;\n          if (filter) {\n            filters.push(this.convertRelativeDateFilter(filter));\n          } else {\n            throw new Error('Invalid Relative Date Filter');\n          }\n          break;\n        }\n\n        default: {\n          break;\n        }\n      }\n    });\n    return filters;\n  }\n\n  private convertCategoricalFilter(domainFilter: InternalContract.CategoricalFilter): Contract.CategoricalFilter {\n    const appliedValues: Array<Contract.DataValue> = domainFilter.values.map((dv) => {\n      return DataValueFactory.MakeFilterDataValue(dv);\n    });\n\n    return new CategoricalFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      FilterType.Categorical,\n      this._registryId,\n      appliedValues,\n      domainFilter.isExclude,\n      domainFilter.isAllSelected,\n    );\n  }\n\n  private convertHierarchicalFilter(domainFilter: InternalContract.HierarchicalFilter): Contract.HierarchicalFilter {\n    const appliedValues: Array<Contract.HierarchicalFilterDataValue> = domainFilter.values.map((hierarchicalDataValue) => {\n      return new HierarchicalDataValue(\n        DataValueFactory.MakeFilterDataValue(hierarchicalDataValue.value),\n        hierarchicalDataValue.hierarchicalPath,\n        hierarchicalDataValue.level,\n      );\n    });\n\n    const levelDetails: Array<Contract.HierarchicalLevelDetail> = domainFilter.levelInfo.map((aLevel) => {\n      return new HierarchicalLevelDetail(\n        aLevel.name,\n        InternalEnumConverter.hierarchicalLevelSelectionState.convert(aLevel.levelSelectionState),\n      );\n    });\n\n    return new HierarchicalFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      FilterType.Hierarchical,\n      this._registryId,\n      domainFilter.dimensionName,\n      domainFilter.hierarchyCaption,\n      domainFilter.levels,\n      levelDetails,\n      appliedValues,\n      domainFilter.isAllSelected,\n    );\n  }\n\n  private convertRangeFilter(domainFilter: InternalContract.RangeFilter): Contract.RangeFilter {\n    const minValue: DataValue = DataValueFactory.MakeFilterDataValue(domainFilter.min);\n    const maxValue: DataValue = DataValueFactory.MakeFilterDataValue(domainFilter.max);\n    return new RangeFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      FilterType.Range,\n      this._registryId,\n      minValue,\n      maxValue,\n      domainFilter.includeNullValues,\n    );\n  }\n\n  private convertRelativeDateFilter(domainFilter: InternalContract.RelativeDateFilter): Contract.RelativeDateFilter {\n    const anchorDateValue: DataValue = DataValueFactory.MakeFilterDataValue(domainFilter.anchorDate);\n    return new RelativeDateFilter(\n      domainFilter.visualId.worksheet,\n      domainFilter.fieldCaption,\n      domainFilter.fieldName,\n      ExternalFilterType.RelativeDate,\n      this._registryId,\n      anchorDateValue,\n      InternalEnumConverter.dateStepPeriod.convert(domainFilter.periodType),\n      InternalEnumConverter.dateRangeType.convert(domainFilter.rangeType),\n      domainFilter.rangeN,\n    );\n  }\n\n  private convertCategoricalDomain(domain: InternalContract.CategoricalDomain, domainType: FilterDomainType): Contract.CategoricalDomain {\n    const values: Array<DataValue> = domain.values.map((domainDv) => {\n      return DataValueFactory.MakeFilterDataValue(domainDv);\n    });\n    return new CategoricalDomain(values, domainType);\n  }\n\n  private convertRangeDomain(domain: InternalContract.RangeDomain, domainType: FilterDomainType): Contract.RangeDomain {\n    const min: DataValue = DataValueFactory.MakeFilterDataValue(domain.min);\n    const max: DataValue = DataValueFactory.MakeFilterDataValue(domain.max);\n    return new RangeDomain(min, max, domainType);\n  }\n\n  private convertAnchorDate(anchorDate: Date): string {\n    // Converts a Date object into a string format that the server expects for date/time values.\n    // If anchorDate doesn't represent a valid Date object, any of these would be NaN.\n    const year = anchorDate.getUTCFullYear();\n    const month = anchorDate.getUTCMonth() + 1;\n    const day = anchorDate.getUTCDate();\n    const hh = anchorDate.getUTCHours();\n    const mm = anchorDate.getUTCMinutes();\n    const sec = anchorDate.getUTCSeconds();\n\n    if (isNaN(year) || isNaN(month) || isNaN(day) || isNaN(hh) || isNaN(mm) || isNaN(sec)) {\n      throw new TableauError(EmbeddingErrorCodes.InvalidDateParameter, 'Invalid date parameter: anchorDate');\n    }\n\n    const result = `${year}-${month}-${day} ${hh}:${mm}:${sec}`;\n    return result;\n  }\n\n  private apiFilterHandlerCheckForCommandError(serverPm: { [key: string]: string }) {\n    if (!serverPm[InternalContract.ParameterId.ParameterError]) {\n      return;\n    }\n    if (serverPm[InternalContract.ParameterId.InvalidFieldCaption]) {\n      throw new TableauError(SharedErrorCodes.InvalidFilterFieldName, serverPm[InternalContract.ParameterId.InvalidFieldCaption]);\n    }\n    if (serverPm[InternalContract.ParameterId.InvalidValues]) {\n      throw new TableauError(SharedErrorCodes.InvalidFilterFieldValue, serverPm[InternalContract.ParameterId.InvalidValues]);\n    }\n    if (serverPm[InternalContract.ParameterId.InvalidAggFieldName]) {\n      throw new TableauError(SharedErrorCodes.InvalidAggregationFieldName, serverPm[InternalContract.ParameterId.InvalidAggFieldName]);\n    }\n    throw new TableauError(SharedErrorCodes.ServerError, 'Server Error');\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ErrorCodes, IncludeDataValuesOption } from '@tableau/api-external-contract-js';\nimport {\n  ApiShowDataTableFormat,\n  DataTable as DataTableInternalContract,\n  DataTableReader as DataTableReaderInternalContract,\n  ExecuteParameters,\n  HighlightedMarksTable,\n  ParameterId,\n  SelectedMarksTable,\n  UnderlyingDataTable,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport { v4 as uuidv4 } from 'uuid';\nimport { TableauError } from '../../../ApiShared';\nimport { ExternalToInternalEnumMappings } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { Column, DataTable, MarkInfo } from '../../Models/GetDataModels';\nimport { DataTableReader } from '../../Models/GetDataTableReaderModels';\nimport { DataValueFactory } from '../../Utils/DataValueFactory';\nimport { GetDataService, GetDataType } from '../GetDataService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class GetDataServiceImpl extends ServiceImplBase implements GetDataService {\n  // The extension/embedding instance uses the same cache for all DataTableReaders.\n  private viewDataTableCacheId: string = uuidv4();\n\n  public get serviceName(): string {\n    return ServiceNames.GetData;\n  }\n\n  public getMaxRowLimit(): number {\n    return 10000;\n  }\n\n  public getViewDataTableCacheId(): string {\n    return this.viewDataTableCacheId;\n  }\n\n  private getLimitedMaxRows(requestedRows: number, rowCountLimit: number): number {\n    return requestedRows > 0 && requestedRows < rowCountLimit ? requestedRows : rowCountLimit;\n  }\n\n  public getUnderlyingDataAsync(\n    visualId: VisualId,\n    getType: GetDataType,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTable> {\n    // Create all of our parameters\n    const summaryData = getType === GetDataType.Summary;\n    const functionName = summaryData ? 'getSummaryDataAsync' : 'getUnderlyingDataAsync';\n    const verb = summaryData ? VerbId.GetDataSummaryData : VerbId.GetUnderlyingData;\n    const requestMaxRows = verb === VerbId.GetUnderlyingData ? this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1) : maxRows;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: functionName,\n    };\n    parameters[ParameterId.VisualId] = visualId;\n    parameters[ParameterId.IgnoreAliases] = ignoreAliases;\n    parameters[ParameterId.IgnoreSelection] = ignoreSelection;\n    parameters[ParameterId.IncludeAllColumns] = includeAllColumns;\n    parameters[ParameterId.ColumnsToIncludeById] = this.verifyIncludeColumnArray(columnsToIncludeById);\n    parameters[ParameterId.MaxRows] = requestMaxRows;\n    parameters[ParameterId.ShowDataTableFormat] = ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption);\n\n    return this.execute(verb, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, responseData.isSummary);\n    });\n  }\n\n  public getSummaryDataReaderAsync(\n    visualId: VisualId,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTableReader> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getSummaryDataReaderAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.PageRowCount]: pageRowCount,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.IgnoreSelection]: ignoreSelection,\n      [ParameterId.IncludeAllColumns]: includeAllColumns,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetDataSummaryDataReader, parameters).then<DataTableReader>((response) => {\n      const responseData = response.result as DataTableReaderInternalContract;\n\n      return new DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, this._registryId);\n    });\n  }\n\n  public getSummaryColumnsInfoAsync(visualId: VisualId): Promise<Array<Contract.Column>> {\n    // Create all the parameters for GetDataType of Summary with 1 row, and only native values\n    // Then return just the columns\n    const verb = VerbId.GetDataSummaryData;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getSummaryColumnsInfoAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.IgnoreAliases]: true,\n      [ParameterId.IgnoreSelection]: true,\n      [ParameterId.IncludeAllColumns]: true,\n      [ParameterId.MaxRows]: 1,\n      [ParameterId.ShowDataTableFormat]: ApiShowDataTableFormat.NativeValuesOnly,\n    };\n\n    return this.execute(verb, parameters).then<Array<Contract.Column>>((response) => {\n      const underlyingDataTable = response.result as UnderlyingDataTable;\n      const dataTable = underlyingDataTable.data;\n      const columns = dataTable.headers.map((h) => new Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index));\n      return columns;\n    });\n  }\n\n  public getSelectedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getSelectedMarksAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetSelectedMarks, parameters).then<Contract.MarksCollection>((response) => {\n      const responseData = response.result as SelectedMarksTable;\n      return {\n        data: responseData.data.map((table) => this.processResultsTable(table, true)),\n      };\n    });\n  }\n\n  public getHighlightedMarksAsync(visualId: VisualId): Promise<Contract.MarksCollection> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getHighlightedMarksAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.GetHighlightedMarks, parameters).then<Contract.MarksCollection>((response) => {\n      const responseData = response.result as HighlightedMarksTable;\n      return {\n        data: responseData.data.map((table) => this.processResultsTable(table, true)),\n      };\n    });\n  }\n\n  public getDataSourceDataAsync(\n    dataSourceId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getDataSourceDataAsync',\n      [ParameterId.DataSourceId]: dataSourceId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.MaxRows]: this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1),\n      [ParameterId.ColumnsToInclude]: this.verifyIncludeColumnArray(columnsToInclude),\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetDataSourceData, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, false);\n    });\n  }\n\n  public getLogicalTableDataAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    maxRows: number,\n    columnsToInclude: Array<string>,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getLogicalTableDataAsync',\n      [ParameterId.ColumnsToInclude]: columnsToInclude,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.DataSourceId]: datasourceId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.MaxRows]: this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetLogicalTableData, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, false);\n    });\n  }\n\n  public getLogicalTableDataReaderAsync(\n    datasourceId: string,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<DataTableReader> {\n    pageRowCount = this.getLimitedMaxRows(pageRowCount, this.getMaxRowLimit());\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getLogicalTableDataReaderAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.DataSourceId]: datasourceId,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.PageRowCount]: pageRowCount,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetLogicalTableDataReader, parameters).then<DataTableReader>((response) => {\n      const responseData = response.result as DataTableReaderInternalContract;\n\n      return new DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, this._registryId);\n    });\n  }\n\n  public getUnderlyingTableDataAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    maxRows: number,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getUnderlyingTableDataAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.IgnoreSelection]: ignoreSelection,\n      [ParameterId.IncludeAllColumns]: includeAllColumns,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.MaxRows]: this.getLimitedMaxRows(maxRows, this.getMaxRowLimit() + 1),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n    };\n\n    return this.execute(VerbId.GetUnderlyingTableData, parameters).then<DataTable>((response) => {\n      const responseData = response.result as UnderlyingDataTable;\n      return this.processResultsTable(responseData.data, false);\n    });\n  }\n\n  public getUnderlyingTableDataReaderAsync(\n    visualId: VisualId,\n    logicalTableId: string,\n    pageRowCount: number,\n    ignoreAliases: boolean,\n    ignoreSelection: boolean,\n    includeAllColumns: boolean,\n    columnsToIncludeById: Array<string>,\n    includeDataValuesOption: IncludeDataValuesOption,\n  ): Promise<Contract.DataTableReader> {\n    pageRowCount = this.getLimitedMaxRows(pageRowCount, this.getMaxRowLimit());\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getUnderlyingTableDataReaderAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.LogicalTableId]: logicalTableId,\n      [ParameterId.IgnoreAliases]: ignoreAliases,\n      [ParameterId.IgnoreSelection]: ignoreSelection,\n      [ParameterId.IncludeAllColumns]: includeAllColumns,\n      [ParameterId.ColumnsToIncludeById]: this.verifyIncludeColumnArray(columnsToIncludeById),\n      [ParameterId.ShowDataTableFormat]: ExternalToInternalEnumMappings.showDataTableFormatType.convert(includeDataValuesOption),\n      [ParameterId.PageRowCount]: pageRowCount,\n    };\n\n    return this.execute(VerbId.GetUnderlyingTableDataReader, parameters).then<DataTableReader>((response) => {\n      const responseData = response.result as DataTableReaderInternalContract;\n\n      return new DataTableReader(responseData.id, responseData.totalRowCount, pageRowCount, this._registryId);\n    });\n  }\n\n  private static summaryTableId = '';\n\n  public getPageAsync(tableId: string, pageNumber: number, pageSize: number): Promise<Contract.DataTable> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getPageAsync',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.ViewDataTableId]: tableId,\n      [ParameterId.DataRowIndex]: pageNumber * pageSize,\n    };\n\n    return this.execute(VerbId.GetDataTableReaderPage, parameters).then<DataTable>((response) => {\n      const responseData = response.result as DataTableInternalContract;\n      return this.processResultsPage(responseData, tableId === GetDataServiceImpl.summaryTableId ? true : false);\n    });\n  }\n\n  public releaseAsync(tableId: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'release',\n      [ParameterId.ViewDataTableCacheId]: this.getViewDataTableCacheId(),\n      [ParameterId.ViewDataTableId]: tableId,\n    };\n\n    return this.execute(VerbId.ReleaseDataTableReader, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  private verifyIncludeColumnArray(columns: Array<string>): Array<string> {\n    // columns must be a valid array\n    if (!Array.isArray(columns)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'columnsToInclude and columnsToIncludeById must be valid arrays');\n    }\n\n    // Remove any duplicates from the input array\n    const columnsAsSet: Set<string> = new Set(columns);\n    return Array.from(columnsAsSet);\n  }\n\n  protected processResultsTable(responseData: DataTableInternalContract, isSummary: boolean): DataTable {\n    const headers = responseData.headers.map((h) => new Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index));\n\n    // TODO This should be controlled by a flag indicating whether this api will respond marks info or not\n    let marks;\n    if (responseData.marks) {\n      marks = responseData.marks.map((h) => new MarkInfo(h.type, h.color, h.tupleId));\n    }\n\n    // Limit+1 is our sentinal that underlying data contains more rows than user is allowed to fetch.\n    // Remove the last element so we always return MaxRowLimit\n    const isTotalRowCountLimited = isSummary === false && responseData.dataTable.length === this.getMaxRowLimit() + 1;\n    if (isTotalRowCountLimited) {\n      responseData.dataTable.length -= 1;\n    }\n\n    const table = responseData.dataTable.map((row) => {\n      return row.map((cell, index) => {\n        return DataValueFactory.MakeTableDataValue(cell, headers[index].dataType);\n      });\n    });\n\n    if (marks) {\n      return new DataTable(table, headers, table.length, isTotalRowCountLimited, isSummary, marks);\n    }\n    return new DataTable(table, headers, table.length, isTotalRowCountLimited, isSummary);\n  }\n\n  protected processResultsPage(responseData: DataTableInternalContract, isSummary: boolean): DataTable {\n    const headers = responseData.headers.map((h) => new Column(h.fieldCaption, h.fieldName, h.dataType, h.isReferenced, h.index));\n\n    let marks;\n    if (responseData.marks) {\n      marks = responseData.marks.map((h) => new MarkInfo(h.type, h.color, h.tupleId));\n    }\n\n    const table = responseData.dataTable.map((row) => {\n      return row.map((cell, index) => {\n        return DataValueFactory.MakeTableDataValue(cell, headers[index].dataType);\n      });\n    });\n\n    if (marks) {\n      return new DataTable(table, headers, table.length, false, isSummary, marks);\n    }\n    return new DataTable(table, headers, table.length, false, isSummary);\n  }\n}\n","import { NotificationService } from '../NotificationService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { NotificationServiceImplBase } from './NotificationServiceImplBase';\n\nexport class NotificationServiceImpl extends NotificationServiceImplBase implements NotificationService {\n  public get serviceName(): string {\n    return ServiceNames.Notification;\n  }\n}\n","import { InternalApiDispatcher, Model, Notification, NotificationId } from '@tableau/api-internal-contract-js';\nimport { UnregisterFn } from '../NotificationService';\n\nexport class Registration {\n  public constructor(private _filterFn: (notificationModel: Model) => boolean, private _callbackFn: (notificationModel: Model) => void) {\n    // Nothing Here\n  }\n\n  public onNotification(notificationModel: Model): void {\n    if (this._filterFn(notificationModel)) {\n      this._callbackFn(notificationModel);\n    }\n  }\n}\n\nexport class NotificationServiceImplBase {\n  private _handlers: { [notificationId: string]: Array<Registration> };\n\n  public constructor(private dispatcher: InternalApiDispatcher) {\n    this._handlers = {};\n    this.dispatcher.registerNotificationHandler(this.onNotification.bind(this));\n  }\n\n  public registerHandler(id: NotificationId, filterFn: (model: Model) => boolean, handler: (model: Model) => void): UnregisterFn {\n    const handlers = this._handlers[id] || new Array<Registration>();\n    const registration = new Registration(filterFn, handler);\n    handlers.push(registration);\n    this._handlers[id] = handlers;\n    return () => this.removeRegistration(id, registration);\n  }\n\n  private hasHandlersForNotificationType(id: NotificationId): boolean {\n    // eslint-disable-next-line no-prototype-builtins\n    return this._handlers.hasOwnProperty(id);\n  }\n\n  private onNotification(notification: Notification): void {\n    if (!this.hasHandlersForNotificationType(notification.notificationId)) {\n      return;\n    }\n\n    // Go through and check for all the handlers of this particular notification\n    this._handlers[notification.notificationId].forEach((h) => h.onNotification(notification.data));\n  }\n\n  private removeRegistration(id: NotificationId, registration: Registration): void {\n    if (!this.hasHandlersForNotificationType(id)) {\n      return;\n    }\n\n    this._handlers[id] = this._handlers[id].filter((reg) => reg !== registration);\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, Model, ParameterId, ParameterInfo, SheetPath, VerbId } from '@tableau/api-internal-contract-js';\nimport { ParameterImpl } from '../../Impl/ParameterImpl';\nimport { TableauError } from '../../TableauError';\nimport { ParametersService } from '../ParametersService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ParametersServiceImpl extends ServiceImplBase implements ParametersService {\n  public get serviceName(): string {\n    return ServiceNames.Parameters;\n  }\n\n  public getParametersForSheetAsync(sheetPath: SheetPath): Promise<Array<ParameterImpl>> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'getParametersForSheetAsync',\n      [ParameterId.SheetPath]: sheetPath,\n    };\n\n    return this.getParametersAsync(parameters);\n  }\n\n  public getAllParametersAsync(): Promise<Array<ParameterImpl>> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'getParametersForSheetAsync',\n    };\n\n    return this.getParametersAsync(parameters);\n  }\n\n  private getParametersAsync(inputParameters: ExecuteParameters): Promise<Array<ParameterImpl>> {\n    return this.execute(VerbId.GetParametersForSheet, inputParameters).then((response) => {\n      const result = response.result as Array<ParameterInfo>;\n      return result.map((parameterInfo) => {\n        return new ParameterImpl(parameterInfo, this._registryId);\n      });\n    });\n  }\n\n  public changeParameterValueAsync(fieldName: string, newValue: string): Promise<ParameterInfo> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'changeParameterValueAsync',\n      [ParameterId.ParameterFieldName]: fieldName,\n      [ParameterId.ParameterValue]: newValue,\n    };\n\n    return this.execute(VerbId.ChangeParameterValue, parameters).then((response) => {\n      const result = response.result as ParameterInfo;\n      return result;\n    });\n  }\n\n  public findParameterByNameAsync(name: string): Promise<ParameterImpl | undefined> {\n    return this.findParameterAsync(name, undefined);\n  }\n\n  public findParameterByGlobalFieldNameAsync(fieldName: string): Promise<ParameterImpl | undefined> {\n    return this.findParameterAsync(undefined, fieldName);\n  }\n\n  private findParameterAsync(name: string | undefined, fieldName: string | undefined): Promise<ParameterImpl | undefined> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'findParameterAsync',\n    };\n    if (name !== undefined) {\n      parameters[ParameterId.ParameterCaption] = name;\n    } else if (fieldName !== undefined) {\n      parameters[ParameterId.ParameterFieldName] = fieldName;\n    } else {\n      throw new TableauError(ErrorCodes.InvalidParameter, 'name or fieldName must be provided to find parameter');\n    }\n\n    return this.execute(VerbId.FindParameter, parameters).then((response) => {\n      const instanceOfParameterInfo = (object: Model): object is ParameterInfo => {\n        return 'fieldName' in object;\n      };\n\n      // We need to check to see if we got a valid response back again\n      if (instanceOfParameterInfo(response.result)) {\n        const result = response.result;\n        return new ParameterImpl(result, this._registryId);\n      } else {\n        return undefined;\n      }\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport {\n  ExecuteParameters,\n  ParameterId,\n  QuantitativeIncludedValues,\n  SelectionUpdateType as SelectionUpdateTypeInternal,\n  VerbId,\n  VisualId,\n} from '@tableau/api-internal-contract-js';\nimport {\n  DimensionSelectionModel,\n  HierarchicalSelectionModel,\n  HoverTupleInteractionModel,\n  RangeSelectionModel,\n  SelectTuplesInteractionModel,\n  SelectionModelsContainer,\n  TupleSelectionModel,\n  ValueSelectionModel,\n} from '../../Models/SelectionModels';\nimport { TableauError } from '../../TableauError';\nimport { Param } from '../../Utils/Param';\nimport { SelectionService } from '../SelectionService';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class SelectionServiceImpl extends ServiceImplBase implements SelectionService {\n  public get serviceName(): string {\n    return ServiceNames.Selection;\n  }\n\n  /**\n   * Method to clear all the selected marks for the given worksheet.\n   *\n   * @param visualId\n   */\n  public clearSelectedMarksAsync(visualId: VisualId): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'clearSelectedMarksAsync',\n      [ParameterId.VisualId]: visualId,\n    };\n    return this.execute(VerbId.ClearSelectedMarks, parameters).then<void>((response) => {\n      return; // Expecting an empty model and hence the void response.\n    });\n  }\n\n  /**\n   * Method to select marks for the given worksheet.\n   *\n   * @param visualId\n   * @param selectionCriteria\n   * @param selectionUpdateType\n   */\n  public selectMarksByValueAsync(\n    visualId: VisualId,\n    selectionCriterias: Array<Contract.SelectionCriteria>,\n    selectionUpdateType: Contract.SelectionUpdateType,\n  ): Promise<void> {\n    if (selectionCriterias.length === 0) {\n      throw new TableauError(Contract.ErrorCodes.InvalidParameter, 'Selection criteria missing for selecting marks by value');\n    }\n\n    const selectionType: string = this.validateSelectionUpdateType(selectionUpdateType);\n    const selectionModelContainer: SelectionModelsContainer = this.parseSelectionMarks(selectionCriterias);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'selectMarksByValueAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.SelectionUpdateType]: selectionType,\n    };\n\n    if (selectionModelContainer.hierModelArr && selectionModelContainer.hierModelArr.length) {\n      parameters[ParameterId.HierValSelectionModels] = selectionModelContainer.hierModelArr;\n    }\n    if (selectionModelContainer.quantModelArr && selectionModelContainer.quantModelArr.length) {\n      parameters[ParameterId.QuantRangeSelectionModels] = selectionModelContainer.quantModelArr;\n    }\n    if (selectionModelContainer.dimModelArr && selectionModelContainer.dimModelArr.length) {\n      parameters[ParameterId.DimValSelectionModels] = selectionModelContainer.dimModelArr;\n    }\n\n    return this.execute(VerbId.SelectByValue, parameters).then<void>((response) => {\n      this.apiFilterHandlerCheckForCommandError(response.result as { [key: string]: string });\n      return;\n    });\n  }\n\n  /**\n   * Method to execute hover actions and render tooltip for a given tuple representing a mark in the visualization.\n   * If the tooltip parameter is included it will show the tooltip on hover. If not, no tooltip is shown.\n   *\n   * @param visualId\n   * @param hoveredTuple\n   * @param tooltip\n   * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error\n   */\n  public hoverTupleAsync(\n    visualId: VisualId,\n    hoveredTuple?: number,\n    tooltip?: Contract.TooltipContext | null,\n    allowHoverActions?: boolean,\n  ): Promise<void> {\n    let interactionModel = new HoverTupleInteractionModel(\n      visualId,\n      this.ensureTupleIDIsNonNegative(hoveredTuple),\n      tooltip,\n      allowHoverActions,\n    );\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'hoverTupleAsync',\n      [ParameterId.HoverTupleInteraction]: interactionModel,\n    };\n\n    return this.execute(VerbId.RaiseHoverTupleNotification, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  /**\n   * Method to modify selection, execute select actions and render tooltip for a given list of tuples representing a mark or marks in the visualization.\n   * If the tooltip parameter is included it will show the tooltip on select. If not, no tooltip is shown.\n   *\n   * @param visualId\n   * @param selectedTuples\n   * @param selectOption\n   * @param tooltip\n   * @returns empty promise that resolves when the extension host has successfully been informed of the request and rejects on error\n   */\n  public selectTuplesAsync(\n    visualId: VisualId,\n    selectedTuples: Array<number>,\n    selectOption: Contract.SelectOptions,\n    tooltip?: Contract.TooltipContext,\n  ): Promise<void> {\n    let interactionModel = new SelectTuplesInteractionModel(visualId, selectedTuples, selectOption, tooltip);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'selectTuplesAsync',\n      [ParameterId.SelectTuplesInteraction]: interactionModel,\n    };\n\n    return this.execute(VerbId.RaiseSelectTuplesNotification, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  private apiFilterHandlerCheckForCommandError(serverPm: { [key: string]: string }) {\n    if (!serverPm[ParameterId.ParameterError]) {\n      return;\n    }\n    if (serverPm[ParameterId.InvalidFields]) {\n      throw new TableauError(Contract.SharedErrorCodes.InvalidSelectionFieldName, serverPm[ParameterId.InvalidFields]);\n    }\n    if (serverPm[ParameterId.InvalidValues]) {\n      throw new TableauError(Contract.SharedErrorCodes.InvalidSelectionValue, serverPm[ParameterId.InvalidValues]);\n    }\n    if (serverPm[ParameterId.InvalidDates]) {\n      throw new TableauError(Contract.SharedErrorCodes.InvalidSelectionDate, serverPm[ParameterId.InvalidDates]);\n    }\n  }\n\n  /**\n   * Method to select marks for the given worksheet.\n   *\n   * @param visualId\n   * @param MarkInfo\n   * @param selectionUpdateType\n   */\n  public selectMarksByIdAsync(\n    visualId: VisualId,\n    marks: Array<Contract.MarkInfo>,\n    selectionUpdateType: Contract.SelectionUpdateType,\n  ): Promise<void> {\n    if (marks.length === 0) {\n      throw new TableauError(Contract.ErrorCodes.InvalidParameter, 'Marks info missing for selecting marks by Id');\n    }\n\n    const selectionType: string = this.validateSelectionUpdateType(selectionUpdateType);\n    const selectionModelContainer: SelectionModelsContainer = this.parseSelectionIds(marks);\n\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'selectMarksByIdAsync',\n      [ParameterId.VisualId]: visualId,\n      [ParameterId.SelectionUpdateType]: selectionType,\n      [ParameterId.Selection]: selectionModelContainer.selection,\n    };\n    return this.execute(VerbId.SelectByValue, parameters).then<void>((response) => {\n      // Expecting an empty model and hence the void response.\n      return;\n      // TODO Investigate the error response with multiple output params and throw error accordingly.\n    });\n  }\n\n  /**\n   * Method to prepare the pres models for selection by MarksInfo\n   * @param marks\n   */\n  private parseSelectionIds(marks: Array<Contract.MarkInfo>): SelectionModelsContainer {\n    const ids: Array<string> = [];\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n    for (let i = 0; i < marks.length; i++) {\n      const tupleId: number | undefined = marks[i].tupleId;\n      if (tupleId !== undefined && tupleId !== null) {\n        // If tuple id is provided use that instead of pair\n        ids.push(tupleId.toString()); // collect the tuple ids\n      } else {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'tupleId parsing error');\n      }\n    }\n    if (ids.length !== 0) {\n      // tuple ids based selection\n      const tupleSelectionModel: TupleSelectionModel = new TupleSelectionModel();\n      tupleSelectionModel.selectionType = 'tuples';\n      tupleSelectionModel.objectIds = ids;\n      selectionModelContainer.selection = tupleSelectionModel;\n    }\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to prepare the pres models for selection by values.\n   *\n   * Supports 3 types for selection:\n   * 1) Hierarchical value based selection\n   * 2) Range value based selection\n   * 3) Dimension value based selection\n   *\n   * @param marks\n   */\n  private parseSelectionMarks(selectionCriterias: Array<Contract.SelectionCriteria>): SelectionModelsContainer {\n    const selectionModelContainer: SelectionModelsContainer = new SelectionModelsContainer();\n\n    for (let i = 0; i < selectionCriterias.length; i++) {\n      const st = selectionCriterias[i];\n      if (!(st.fieldName && st.value !== undefined && st.value !== null)) {\n        throw new TableauError(Contract.ErrorCodes.InternalError, 'Selection Criteria parsing error');\n      }\n\n      const catRegex = new RegExp('([[A-Za-z0-9]+]).*', 'g');\n      const rangeOption = st.value as Contract.RangeValue;\n      if (catRegex.test(st.fieldName)) {\n        // Hierarchical value selection\n        const hierModel: HierarchicalSelectionModel = this.addToParamsList(st.fieldName, st.value) as HierarchicalSelectionModel;\n        selectionModelContainer.hierModelArr.push(hierModel);\n      } else if (rangeOption.min !== undefined && rangeOption.max !== undefined) {\n        // Range value selection\n        const quantModel: RangeSelectionModel = this.addToRangeParamsList(st.fieldName, rangeOption);\n        selectionModelContainer.quantModelArr.push(quantModel);\n      } else {\n        // Dimension value selection\n        const dimModel: DimensionSelectionModel = this.addToParamsList(st.fieldName, st.value) as DimensionSelectionModel;\n        selectionModelContainer.dimModelArr.push(dimModel);\n      }\n    }\n\n    return selectionModelContainer;\n  }\n\n  /**\n   * Method to transform the key value pair into value based pres model object.\n   *\n   * @param valueSelectionModel\n   * @param fieldName\n   * @param value\n   */\n  private addToParamsList(fieldName: string, value: Contract.CategoricalValue | Contract.RangeValue): ValueSelectionModel {\n    const valueSelectionModel: ValueSelectionModel = new ValueSelectionModel();\n    const markValues: Array<string> = [];\n\n    if (value instanceof Array) {\n      const valueArr: Array<string> = value;\n      for (let i = 0; i < valueArr.length; i++) {\n        markValues.push(Param.serializeParameterValue(valueArr[i]));\n      }\n    } else {\n      markValues.push(Param.serializeParameterValue(value));\n    }\n\n    valueSelectionModel.qualifiedFieldCaption = fieldName;\n    valueSelectionModel.selectValues = markValues;\n    return valueSelectionModel;\n  }\n\n  /**\n   * Method to transform the key value pair into range based selection pres model.\n   *\n   * TODO: Need to handle the parsing of date type values.\n   *\n   * @param valueSelectionModel\n   * @param fieldName\n   * @param value\n   */\n  private addToRangeParamsList(fieldName: string, value: Contract.RangeValue): RangeSelectionModel {\n    const rangeSelectionModel: RangeSelectionModel = new RangeSelectionModel();\n    rangeSelectionModel.qualifiedFieldCaption = fieldName;\n    if (value.max !== undefined && value.max !== null) {\n      rangeSelectionModel.maxValue = Param.serializeParameterValue(value.max);\n    }\n    if (value.min !== undefined && value.min !== null) {\n      rangeSelectionModel.minValue = Param.serializeParameterValue(value.min);\n    }\n    rangeSelectionModel.included = this.validateNullOptionType(value.nullOption);\n    return rangeSelectionModel;\n  }\n\n  /**\n   * Method to validate the selection update type.\n   *\n   * @param selectionUpdateType\n   */\n  private validateSelectionUpdateType(selectionUpdateType: Contract.SelectionUpdateType): string {\n    if (selectionUpdateType === Contract.SelectionUpdateType.Replace) {\n      return SelectionUpdateTypeInternal.Replace;\n    } else if (selectionUpdateType === Contract.SelectionUpdateType.Add) {\n      return SelectionUpdateTypeInternal.Add;\n    } else if (selectionUpdateType === Contract.SelectionUpdateType.Remove) {\n      return SelectionUpdateTypeInternal.Remove;\n    }\n    return SelectionUpdateTypeInternal.Replace;\n  }\n\n  /**\n   * Method to validate the include type for range selection.\n   *\n   * @param nullOption\n   */\n  private validateNullOptionType(nullOption: Contract.FilterNullOption | undefined): string {\n    if (nullOption) {\n      if (nullOption === Contract.FilterNullOption.NullValues) {\n        return QuantitativeIncludedValues.IncludeNull;\n      } else if (nullOption === Contract.FilterNullOption.NonNullValues) {\n        return QuantitativeIncludedValues.IncludeNonNull;\n      } else if (nullOption === Contract.FilterNullOption.AllValues) {\n        return QuantitativeIncludedValues.IncludeAll;\n      }\n    }\n\n    return QuantitativeIncludedValues.IncludeAll;\n  }\n\n  private ensureTupleIDIsNonNegative(tupleId?: number): number {\n    if (tupleId && tupleId > 0) {\n      return tupleId;\n    }\n\n    // 0 will not refer to a valid tuple (since tuple ids are 1-based),\n    // but can be used for clearing the current hover or selection\n    return 0;\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ExecuteResponse, InternalApiDispatcher, InternalTableauError, VerbId } from '@tableau/api-internal-contract-js';\nimport { InternalToExternalEnumMappings } from '../../EnumMappings/InternalToExternalEnumMappings';\nimport { TableauError } from '../../TableauError';\nimport { ShouldThrow } from '../../Utils/EnumConverter';\n\n/**\n * Each ServceImpl should extend this base class for the sake of\n * proper error handling.  This base handles the conversion\n * from internal errors to external errors that we throw to developers\n */\nexport class ServiceImplBase {\n  public constructor(private _dispatcher: InternalApiDispatcher, protected _registryId: number) {}\n\n  protected execute(verb: VerbId, params: ExecuteParameters): Promise<ExecuteResponse> {\n    return this._dispatcher.execute(verb, params).catch((error) => {\n      // Any internal error that comes from the dispatcher should be converted\n      // to an external error using the enum mapper for error codes.\n      const internalError = error as InternalTableauError;\n      const externalErrorCode: ErrorCodes = InternalToExternalEnumMappings.errorCode.convert(internalError.errorCode, ShouldThrow.No);\n      throw new TableauError(externalErrorCode, internalError.message);\n    });\n  }\n}\n","import { SheetSize } from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { SizeService } from '../SizeService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class SizeServiceImpl extends ServiceImplBase implements SizeService {\n  public get serviceName(): string {\n    return ServiceNames.Size;\n  }\n\n  changeSizeAsync(name: string, newSize: SheetSize): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'changeSizeAsync',\n      [ParameterId.SheetName]: name,\n      [ParameterId.MinHeight]: newSize.minSize?.height || 0,\n      [ParameterId.MinWidth]: newSize.minSize?.width || 0,\n      [ParameterId.MaxHeight]: newSize.maxSize?.height || 0,\n      [ParameterId.MaxWidth]: newSize.maxSize?.width || 0,\n    };\n\n    return this.execute(VerbId.SetSheetSize, parameters).then<void>((_response) => {\n      return;\n    });\n  }\n}\n","import { ExecuteParameters, ParameterId, StoryPointModel, VerbId } from '@tableau/api-internal-contract-js';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { StoryActivationService } from '../StoryActivationService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class StoryActivationServiceImpl extends ServiceImplBase implements StoryActivationService {\n  public get serviceName(): string {\n    return ServiceNames.StoryActivation;\n  }\n\n  activateNextStoryPointAsync(): Promise<void> {\n    const verb = VerbId.ActivateNextStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activateNextStoryPointAsync',\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  activatePreviousStoryPointAsync(): Promise<void> {\n    const verb = VerbId.ActivatePreviousStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activatePreviousStoryPointAsync',\n    };\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  activateStoryPointAsync(index: number): Promise<void> {\n    const verb = VerbId.ActivateStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activateStoryPointAsync',\n    };\n    parameters[ParameterId.StoryPointIndex] = index;\n\n    return this.execute(verb, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  revertStoryPointAsync(index: number): Promise<StoryPointModel> {\n    const verb = VerbId.RevertStoryPoint;\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'revertStoryPointAsync',\n    };\n    parameters[ParameterId.StoryPointIndex] = index;\n\n    return this.execute(verb, parameters).then<StoryPointModel>((response) => {\n      return response.result as StoryPointModel;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { ExecuteParameters, ParameterId, VerbId, VisualId, VisualSpecification } from '@tableau/api-internal-contract-js';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { VisualModelService } from '../VisualModelService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class VisualModelServiceImpl extends ServiceImplBase implements VisualModelService {\n  public get serviceName(): string {\n    return ServiceNames.VisualModel;\n  }\n\n  public getVisualSpecificationAsync(visualId: VisualId): Promise<Contract.VisualSpecification> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getVisualSpecificationAsync',\n      [ParameterId.WorksheetName]: visualId.worksheet,\n    };\n\n    return this.execute(VerbId.GetVisualSpecification, parameters).then<Contract.VisualSpecification>((response) => {\n      const result = response.result as VisualSpecification;\n      return result;\n    });\n  }\n}\n","import { CustomViewModel, ExecuteParameters, ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { CustomViewImpl } from '../../Impl/CustomViewImpl';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { VizService } from '../VizService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class VizServiceImpl extends ServiceImplBase implements VizService {\n  public get serviceName(): string {\n    return ServiceNames.Viz;\n  }\n\n  public createVizImageAsync(inputSpec: object): Promise<string> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'createVizImageAsync',\n      [ParameterId.VizAPIInputJson]: JSON.stringify(inputSpec),\n    };\n\n    return this.execute(VerbId.VizAPI, parameters).then((response) => {\n      const result = response.result as string;\n      return result;\n    });\n  }\n\n  public activateSheetAsync(name: string): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'activateSheetAsync',\n      [ParameterId.SwitchToSheetName]: name,\n    };\n\n    return this.execute(VerbId.ActivateSheet, parameters).then(() => {\n      return;\n    });\n  }\n\n  public getCustomViewsAsync(): Promise<Array<CustomViewImpl>> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getCustomViewsAsync',\n    };\n\n    return this.execute(VerbId.GetCustomViews, parameters).then<Array<CustomViewImpl>>((response) => {\n      const customViews = response.result as Array<CustomViewModel>;\n      return customViews.map((customView: CustomViewModel) => {\n        return new CustomViewImpl(customView, this._registryId);\n      });\n    });\n  }\n\n  public showCustomViewAsync(customViewName?: string | null): Promise<CustomViewImpl | undefined> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'showCustomViewAsync',\n      [ParameterId.CustomViewName]: customViewName || '', // a falsey value means \"show original view\"\n    };\n\n    return this.execute(VerbId.ShowCustomView, parameters).then<CustomViewImpl | undefined>((response) => {\n      const customView = response.result as CustomViewModel;\n      return customView?.luid ? new CustomViewImpl(customView, this._registryId) : undefined;\n    });\n  }\n\n  public removeCustomViewAsync(customViewName: string): Promise<CustomViewImpl> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'removeCustomViewAsync',\n      [ParameterId.CustomViewName]: customViewName,\n    };\n\n    return this.execute(VerbId.RemoveCustomView, parameters).then<CustomViewImpl>((response) => {\n      const customView = response.result as CustomViewModel;\n      return new CustomViewImpl(customView, this._registryId);\n    });\n  }\n\n  public saveCustomViewAsync(customViewName: string): Promise<CustomViewImpl> {\n    // CustomViewIsDefault is a required parameter, but our API has not been updated to allow it to be specified yet.\n    // We should add a 'default' parameter to the interface.\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'saveCustomViewAsync',\n      [ParameterId.CustomViewName]: customViewName,\n      [ParameterId.CustomViewIsDefault]: false,\n    };\n\n    return this.execute(VerbId.SaveWorkbookAsCustomView, parameters).then<CustomViewImpl>((response) => {\n      const customView = response.result as CustomViewModel;\n      return new CustomViewImpl(customView, this._registryId);\n    });\n  }\n\n  public setActiveCustomViewAsDefaultAsync(): Promise<void> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'setActiveCustomViewAsDefaultAsync',\n    };\n\n    return this.execute(VerbId.SetActiveCustomViewAsDefault, parameters).then(() => {\n      return;\n    });\n  }\n\n  public saveAsync(customView: CustomViewImpl): Promise<CustomViewImpl> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'saveAsync',\n      [ParameterId.CustomViewLuid]: customView.luid,\n      [ParameterId.CustomViewName]: customView.name,\n      [ParameterId.CustomViewIsDefault]: customView.isDefault,\n      [ParameterId.CustomViewIsPublic]: customView.shared,\n    };\n\n    return this.execute(VerbId.UpdateCustomView, parameters).then<CustomViewImpl>((response) => {\n      const customView = response.result as CustomViewModel;\n      return new CustomViewImpl(customView, this._registryId);\n    });\n  }\n\n  public getCurrentSrcAsync(): Promise<string> {\n    const parameters: ExecuteParameters = {\n      [ParameterId.FunctionName]: 'getCurrentSrcAsync',\n    };\n\n    return this.execute(VerbId.GetCurrentSrc, parameters).then((response) => response.result as string);\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { DashboardObjectVisibilityType } from '@tableau/api-external-contract-js';\nimport { ParameterId, VerbId } from '@tableau/api-internal-contract-js';\nimport { ExternalToInternalEnumMappings as ExternalEnumConverter } from '../../EnumMappings/ExternalToInternalEnumMappings';\nimport { DashboardObjectImpl } from '../../Impl/DashboardObjectImpl';\nimport { ErrorHelpers } from '../../Utils/ErrorHelpers';\nimport { Param } from '../../Utils/Param';\nimport { ServiceNames } from '../ServiceRegistry';\nimport { ZoneService } from '../ZoneService';\nimport { ServiceImplBase } from './ServiceImplBase';\n\nexport class ZoneServiceImpl extends ServiceImplBase implements ZoneService {\n  public get serviceName(): string {\n    return ServiceNames.Zone;\n  }\n\n  public setVisibilityAsync(\n    dashboard: string,\n    dashboardZoneMap: Map<number, DashboardObjectImpl>,\n    zoneVisibilityMap: Contract.ZoneVisibilityMap,\n  ): Promise<void> {\n    const parameters = {\n      [ParameterId.FunctionName]: 'setVisibilityAsync',\n      [ParameterId.Dashboard]: dashboard,\n      [ParameterId.ZoneIdsVisibilityMap]: {},\n    };\n\n    // zoneVisibilityMap can be either an object or a Map - convert it to a Map\n    const parameterAsMap = Param.convertParameterToMap(zoneVisibilityMap, 'zoneVisibilityMap');\n\n    parameterAsMap.forEach((value, key) => {\n      ErrorHelpers.verifyZoneIsValid(dashboardZoneMap, Number.parseInt(key, 10));\n      ErrorHelpers.verifyEnumValue<DashboardObjectVisibilityType>(value, DashboardObjectVisibilityType, 'DashboardObjectVisibilityType');\n      parameters[ParameterId.ZoneIdsVisibilityMap][key] = ExternalEnumConverter.setVisibilityType.convert(value);\n    });\n\n    return this.execute(VerbId.SetZoneVisibility, parameters).then<void>((response) => {\n      return;\n    });\n  }\n\n  public moveAndResizeAsync(\n    dashboard: string,\n    dashboardZoneMap: Map<number, DashboardObjectImpl>,\n    dashboardObjectPositionAndSizeUpdateArray: Contract.DashboardObjectPositionAndSizeUpdateArray,\n  ): Promise<void> {\n    const parameters = {\n      [ParameterId.Dashboard]: dashboard,\n      [ParameterId.DashboardObjectPositionAndSizeUpdateList]: dashboardObjectPositionAndSizeUpdateArray,\n    };\n\n    dashboardObjectPositionAndSizeUpdateArray.forEach((dashboardObject: Contract.DashboardObjectPositionAndSizeUpdate) => {\n      ErrorHelpers.verifyZoneIsValidAndFloating(dashboardZoneMap, dashboardObject.dashboardObjectID);\n      ErrorHelpers.verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate(dashboardObject);\n    });\n\n    return this.execute(VerbId.MoveAndResizeZones, parameters).then<void>((response) => {\n      return;\n    });\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableInfo } from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of a table summary.\n * This does not follow the Impl pattern as it is just a property bag.\n */\nexport class TableSummary implements Contract.TableSummary {\n  public constructor(private _tableInfo: TableInfo) {}\n\n  public get name(): string {\n    return this._tableInfo.name;\n  }\n\n  public get id(): string {\n    return this._tableInfo.id;\n  }\n\n  public get connectionId(): string {\n    return this._tableInfo.connectionId;\n  }\n\n  public get customSQL(): string | undefined {\n    return this._tableInfo.customSQL;\n  }\n}\n","import { EmbeddingErrorCodes, ErrorCodes, SharedErrorCodes } from '@tableau/api-external-contract-js';\n\n/**\n * Custom error class that extends the default JavaScript Error object.\n * This allows us to provide a field with a specific error code\n * so that developers can more easily programmatically respond\n * to error scenarios.\n */\nexport class TableauError extends Error {\n  public constructor(private _errorCode: ErrorCodes | EmbeddingErrorCodes | SharedErrorCodes, message: string) {\n    super(`${_errorCode}: ${message}`);\n\n    /*tslint:disable-next-line */\n    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    // Error inheritance does not work propertly when compiling to ES5, this is a workaround to force\n    // the proto chain to be built correctly.  See the github link above for details.\n    Object.setPrototypeOf(this, TableauError.prototype);\n  }\n\n  public get errorCode(): ErrorCodes | EmbeddingErrorCodes | SharedErrorCodes {\n    return this._errorCode;\n  }\n}\n","import * as InternalContract from '@tableau/api-internal-contract-js';\nimport { DataValue } from '../Models/GetDataModels';\n\n/**\n * In version 2 of the interface, we should collapse value into nativeValue, and do all this work over\n * in the platform.\n */\nexport class DataValueFactory {\n  public static MakeParameterDataValue(internalDataValue: InternalContract.DataValue, dataType: InternalContract.DataType): DataValue {\n    // Parameter values are all strings, convert from string to value\n    return new DataValue(\n      internalDataValue.value,\n      InternalContract.DataTypeConverter.convertStringValueToNativeValue(internalDataValue.value, dataType),\n      internalDataValue.formattedValue,\n    );\n  }\n\n  public static MakeFilterDataValue(internalDataValue: InternalContract.DataValue): DataValue {\n    // Filters already have native type in value, just use that for nativeValue also\n    return new DataValue(internalDataValue.value, internalDataValue.value, internalDataValue.formattedValue);\n  }\n\n  public static MakeTableDataValue(internalDataValue: InternalContract.DataValue, dataType: InternalContract.DataType): DataValue {\n    // DataTables contain boolean | number | string | date as string | '%null%\n    // convertValueToNativeValue converts dates as string to dates, and any special to null\n    // (boolean, numbers, strings are passed through)\n    // Because of IncludeDataValuesOption - we can have undefined values, which are different than any special\n    return new DataValue(\n      internalDataValue.value,\n      internalDataValue.value !== undefined\n        ? InternalContract.DataTypeConverter.convertValueToNativeValue(internalDataValue.value, dataType)\n        : undefined,\n      internalDataValue.formattedValue,\n    );\n  }\n}\n","/**\n * A Promise wrapper class allowing for resolving/rejecting the Promise outside the context of its constructor.\n *\n * @export\n * @class Deferred\n * @template TResolve The type used to resolve the promise.\n * @template TReject The type used to reject the promise. Defaults to any.\n * @link https://stackoverflow.com/a/34637436\n */\nexport class Deferred<TResolve, TReject = any> {\n  private _promise: Promise<TResolve>;\n  private _resolve: (response: TResolve | PromiseLike<TResolve>) => void;\n  private _reject: (reason?: TReject) => void;\n\n  /**\n   * Creates an instance of Deferred.\n   */\n  constructor() {\n    this._promise = new Promise<TResolve>((resolve, reject) => {\n      this._resolve = resolve;\n      this._reject = reject;\n    });\n  }\n\n  /**\n   * Gets the Promise.\n   *\n   * @readonly\n   * @type {Promise<TResolve>}\n   */\n  get promise(): Promise<TResolve> {\n    return this._promise;\n  }\n\n  /**\n   * Resolves the wrapped Promise.\n   *\n   * @param {(TResolve | PromiseLike<TResolve>)} response The argument to be resolved by the Promise.\n   * @returns {*}  {void}\n   */\n  resolve(response: TResolve | PromiseLike<TResolve>): void {\n    if (!this._resolve) {\n      return;\n    }\n\n    this._resolve(response);\n  }\n\n  /**\n   *\n   *\n   * @param {TReject} [reason] The reason why the Promise rejected.\n   * @returns {*}  {void}\n   */\n  reject(reason?: TReject): void {\n    if (!this._reject) {\n      return;\n    }\n\n    this._reject(reason);\n  }\n}\n\nexport const UnregisterTimeoutInMilliseconds = 30000;\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * This class converts from a source enum value to destination enum\n * value given a mapping from source to destination when constructed.\n *\n * Note: This exact same class is defined in api-core.  Given its small\n * nature, it is not worth having in a separate project to share this between\n * api-core and api-shared.  If more utility functionality is added that is used by api-core\n * and api-shared but has no other dependecies, a utiltity project might be merited,\n * and this class could be moved.\n */\nexport class EnumConverter<TSourceType extends string, TDestinationType> {\n  public constructor(private _mappings: { [enumVal: string]: TDestinationType }, private _defaultVal?: TDestinationType) {}\n\n  public convert(enumVal: TSourceType, throwIfMissing: ShouldThrow = ShouldThrow.Yes): TDestinationType {\n    if (this._mappings.hasOwnProperty(enumVal)) {\n      return this._mappings[enumVal as string];\n    }\n\n    if (this._defaultVal !== undefined && throwIfMissing !== ShouldThrow.Yes) {\n      return this._defaultVal;\n    }\n\n    throw new TableauError(ErrorCodes.InternalError, `Enum Mapping not found for: ${enumVal}`);\n  }\n}\n\nexport enum ShouldThrow {\n  Yes = 'yes',\n  No = 'no',\n}\n","import {\n  DashboardObjectPositionAndSizeUpdate,\n  ExportDataOptions,\n  ExportPDFOptions as ExternalExportPDFOptions,\n  ExportScenariosForPDFAndPowerPoint,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  SharedErrorCodes,\n} from '@tableau/api-external-contract-js';\nimport { DashboardObjectImpl } from '../Impl/DashboardObjectImpl';\nimport { TableauError } from '../TableauError';\nimport { Param } from './Param';\n\ninterface EnumLike {\n  toString(): string;\n}\n\n/**\n * This class is used to construct common errors throughout the external\n * projects (api-shared, extensions-api, etc.).  It has some duplication with\n * the ErrorHelpers class in api-core, but is separate due to the need to throw\n * an external TableauError vs. an InternalTableauError.\n */\nexport class ErrorHelpers {\n  /**\n   * Throws with code InternalError.\n   *\n   * @param apiName name of api that was called.\n   */\n  public static apiNotImplemented(apiName: string): TableauError {\n    return new TableauError(SharedErrorCodes.InternalError, `${apiName} API not yet implemented.`);\n  }\n\n  /**\n   * Throws an internal error if argument is null or undefined.\n   *\n   * @param argumentValue value to verify\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyInternalValue(argumentValue: any, argumentName: string) {\n    if (argumentValue === null || argumentValue === undefined) {\n      throw new TableauError(SharedErrorCodes.InternalError, `${argumentValue} is invalid value for: ${argumentName}`);\n    }\n  }\n\n  /**\n   * Throws an InvalidParameter error if argument is null or undefined.\n   *\n   * @param argumentValue value to verify\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyParameter(argumentValue: any, argumentName: string) {\n    if (argumentValue === null || argumentValue === undefined) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${argumentValue} is invalid value for parameter: ${argumentName}`);\n    }\n  }\n\n  /**\n   * Throws an InvalidParameter error if argument is not the specified type.\n   * For objects, it just tests that it is an object\n   *\n   * @param argumentValue value to verify\n   * @param expectedType expected result of typeof\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyParameterType(argumentValue: any, expectedType: string, argumentName: string) {\n    if (typeof argumentValue !== expectedType) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${argumentValue} has invalid type for parameter: ${argumentName}.`);\n    }\n  }\n\n  /**\n   * Throws an InvalidParameter error if argument is empty string, null or undefined.\n   *\n   * @param argumentValue value to verify\n   * @param argumentName name of argument to verify\n   */\n  /*tslint:disable-next-line */\n  public static verifyStringParameter(argumentValue: string, argumentName: string) {\n    if (argumentValue === null || argumentValue === undefined || argumentValue === '') {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${argumentValue} is invalid value for paramter: ${argumentName}`);\n    }\n  }\n\n  /**\n   * Verifies passed value is a valid value for that enum.\n   * Throws an InvalidParameter error if the enum value is not valid.\n   *\n   * String enums are {string : string} dictionaries which are not reverse mappable\n   * This is an ugly workaround\n   *\n   * @param enumValue value to verify\n   * @param enumType enum to verify against\n   * @param enumName enum name for clear error message\n   */\n  /*tslint:disable-next-line */\n  public static verifyEnumValue<EnumType extends EnumLike>(enumValue: EnumType, enumType: any, enumName: string) {\n    let isValid = false;\n    Object.keys(enumType).forEach((enumKey) => {\n      if (enumType[enumKey] === enumValue.toString()) {\n        isValid = true;\n      }\n    });\n\n    if (!isValid) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${enumValue} is invalid value for enum: ${enumName}.`);\n    }\n  }\n\n  /**\n   * Verifies passed value is between [min, max) ... min <= value < max\n   * Throws an InvalidParameter error if the value is not valid.\n   *\n   *\n   * @param value value to verify\n   * @param min   value must be >= min\n   * @param max   value must be < max\n   */\n  /*tslint:disable-next-line */\n  public static verifyRange(value: number, min: number, max: number) {\n    let isValid = min <= value && value < max;\n\n    if (!isValid) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, `${value} is invalid value for range: [${min}..${max})`);\n    }\n  }\n\n  /**\n   * Verifies the params min and max for applying range filter.\n   * Throws with error code InvalidParameter if range is invalid.\n   *\n   * @param min range min\n   * @param max range max\n   */\n  /*tslint:disable-next-line */\n  public static verifyRangeParamType(min: any, max: any): void {\n    if (!min && !max) {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, 'Unexpected invalid param value, at least one of min or max is required.');\n    }\n\n    if (min && !Param.isTypeNumber(min) && !Param.isTypeDate(min)) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        'Unexpected invalid param value, only Date and number are allowed for parameter min.',\n      );\n    }\n\n    if (max && !Param.isTypeNumber(max) && !Param.isTypeDate(max)) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        'Unexpected invalid param value, only Date and number are allowed for parameter max.',\n      );\n    }\n\n    if (min && max && typeof min !== typeof max) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        'Unexpected invalid param value, parameters min and max should be of the same type.',\n      );\n    }\n  }\n\n  /**\n   * Verifies that the zoneId is present in the current dashboard.\n   * Throws with error code InvalidParameter if either condition is false.\n   *\n   * @param dashboardZoneMap A map of zoneId's to the corresponding dashboard object.\n   * @param zoneID ZoneId to be validated\n   */\n  public static verifyZoneIsValid(dashboardZoneMap: Map<number, DashboardObjectImpl>, zoneID: number): void {\n    if (dashboardZoneMap.has(zoneID)) {\n      return;\n    }\n\n    throw new TableauError(\n      SharedErrorCodes.InvalidParameter,\n      `Unexpected invalid param value, Dashboard Object Id: ${zoneID} is not present in dashboard.`,\n    );\n  }\n\n  /**\n   * Verifies that the zone is present and floating in the current dashboard.\n   * Throws with error code InvalidParameter if either condition is false.\n   *\n   * @param dashboardZoneMap A map of zoneId's to the corresponding dashboard object.\n   * @param zoneID ZoneId to be validated\n   */\n  public static verifyZoneIsValidAndFloating(dashboardZoneMap: Map<number, DashboardObjectImpl>, zoneID: number): void {\n    if (dashboardZoneMap.has(zoneID) && dashboardZoneMap.get(zoneID)!.isFloating) {\n      return;\n    }\n\n    throw new TableauError(\n      SharedErrorCodes.InvalidParameter,\n      `Unexpected invalid param value, Dashboard Object Id: ${zoneID} is not present or is a fixed zone in the dashboard.`,\n    );\n  }\n\n  /**\n   * Verifies that width and height are > 0 for each DashboardObjectPositionAndSizeUpdate object.\n   * Throws with error code InvalidParameter if either condition is false.\n   *\n   * @param dashboardObjectPositionAndSizeUpdate DashboardObjectPositionAndSizeUpdate object for which width and height will be validated\n   */\n  public static verifyWidthAndHeightOfDashboardObjectPositionAndSizeUpdate(\n    dashboardObjectPositionAndSizeUpdate: DashboardObjectPositionAndSizeUpdate,\n  ): void {\n    if (dashboardObjectPositionAndSizeUpdate.width < 0 || dashboardObjectPositionAndSizeUpdate.height < 0) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidParameter,\n        `Unexpected invalid param value for dashboard object ID ${dashboardObjectPositionAndSizeUpdate.dashboardObjectID}:` +\n          ` negative widths and heights are not allowed.`,\n      );\n    }\n  }\n\n  /**\n   * Verifies is the given sheet name is in the list of sheets names allowed for exporting.\n   * Throws with error code InvalidParameter if the condition above is false.\n   *\n   * @param exportableSheetNames A list of sheet names allowed for exporting\n   * @param sheetName the name of the sheet selected for export\n   */\n  public static verifySheetName(exportableSheetNames: Array<string>, sheetName: string) {\n    if (!exportableSheetNames.includes(sheetName)) {\n      throw new TableauError(\n        SharedErrorCodes.InvalidSelectionSheet,\n        'sheetName parameter must belong to a worksheet within the current view',\n      );\n    }\n  }\n\n  /**\n   * Verifies the ExportDataOptions object\n   * Throws with error code InvalidParameter if the parameter is not of ExportDataOptions type.\n   *\n   * @param options The ExportDataOptions object used to configure the output CSV file for exportDataAsync.\n   */\n  public static verifyExportDataOptions(options: ExportDataOptions): void {\n    if (\n      (!Param.isNullOrUndefined(options.ignoreAliases) && !Param.isTypeBool(options.ignoreAliases)) ||\n      (!Param.isNullOrUndefined(options.columnsToIncludeById) && !Array.isArray(options.columnsToIncludeById))\n    )\n      throw new TableauError(SharedErrorCodes.InvalidParameter, 'options paramater must be of type ExportDataOptions');\n  }\n\n  /**\n   * Verifies if the sheet names are included in any of the export scenarios.\n   * Throws with error code InvalidParameter if the parameter is not an array.\n   * Throws with error code InvalidSelectionSheet if there are array entries that dont exist or if there is mixing between sheets from the dashboard and sheet from the workbook.\n   *\n   * @param sheetNames List of sheet names selected for exporting.\n   * @param exportScenarios an object containing the current sheet name, exportable sheets from the dashboard, and exportable sheets from the workbook.\n   */\n  public static verifySheetNamesForPDFAndPPT(sheetNames: Array<string>, exportScenarios: ExportScenariosForPDFAndPowerPoint): void {\n    if (!Array.isArray(sheetNames)) throw new TableauError(SharedErrorCodes.InvalidParameter, 'sheetNames parameter must be an array');\n    if (sheetNames.length === 0) throw new TableauError(SharedErrorCodes.InternalError, 'sheetNames should not be empty');\n\n    const isIncludedInDashboard = sheetNames.every((sheetName: string) =>\n      exportScenarios.exportableSheetNamesFromDashboard.includes(sheetName),\n    );\n    if (isIncludedInDashboard) {\n      return;\n    }\n    const isIncludedInWorkbook = sheetNames.every((sheetName: string) =>\n      exportScenarios.exportableSheetNamesFromWorkbook.includes(sheetName),\n    );\n    if (isIncludedInWorkbook) {\n      return;\n    }\n    const isCurrentSheet = sheetNames.length === 1 && sheetNames[0] === exportScenarios.currentSheetName;\n    if (isCurrentSheet) {\n      return;\n    }\n\n    // Export requirement: all sheet names must be included in the list of exportable sheets in the dashboard or\n    // all sheet names must be included in the list of exportable sheets in the workbook, or the sheet name is the current sheet\n    throw new TableauError(\n      SharedErrorCodes.InvalidSelectionSheet,\n      'sheetNames parameter must have all its entries be exportable sheet names from the dashboard or all its entries be exportable sheet names from the workbook',\n    );\n  }\n\n  /**\n   * Verifies the external ExportPDFOptions object's properties.\n   * Throws with error code InvalidParameter if the parameter is not of external ExportPDFOptions type.\n   *\n   * @param options The external user-facing ExportPDFOptions object used to configure the output PDF file for exportPDFAsync.\n   */\n  public static verifyExportPDFOptions(options: ExternalExportPDFOptions) {\n    try {\n      this.verifyEnumValue<PrintOrientation>(options.orientation, PrintOrientation, 'PrintOrientation');\n      this.verifyEnumValue<PrintPageSize>(options.pageSize, PrintPageSize, 'PrintPageSize');\n      this.verifyEnumValue<PrintScaling>(options.scaling, PrintScaling, 'PrintScaling');\n    } catch {\n      throw new TableauError(SharedErrorCodes.InvalidParameter, 'options parameter must be of type ExportPDFOptions');\n    }\n  }\n}\n","import {\n  ExportLayoutOptions,\n  ExportPDFOptions as InternalExportPDFOptions,\n  FitPages,\n  PageOrientation,\n  PageScalingOption,\n  PageSizeOption,\n  ScaleMode,\n  ScalingSelection,\n} from '@tableau/api-internal-contract-js';\nimport {\n  ExportDataOptions,\n  ExportPDFOptions as ExternalExportPDFOptions,\n  PrintOrientation,\n  PrintPageSize,\n  PrintScaling,\n  SharedErrorCodes,\n} from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\n\n/**\n * Helper methods for Export APIs.\n *\n * @class ExportHelpers\n */\nexport class ExportHelpers {\n  public static DefaultDataOptions: ExportDataOptions = {\n    ignoreAliases: false,\n    columnsToIncludeById: [],\n  };\n\n  public static DefaultPDFOptions: ExternalExportPDFOptions = {\n    scaling: PrintScaling.Automatic,\n    pageSize: PrintPageSize.Letter,\n    orientation: PrintOrientation.Portrait,\n  };\n\n  private static DefaultLayoutOptions: ExportLayoutOptions = {\n    imageHeight: 0,\n    imageWidth: 0,\n    pageFitHorizontal: 1,\n    pageFitVertical: 1,\n    pageOrientationOption: PageOrientation.Portrait,\n    pageScaleMode: ScaleMode.ScaleAuto,\n    pageScalePercent: 100,\n    pageSizeOption: PageSizeOption.Letter,\n  };\n\n  /**\n   * Modifies the internal ExportPDFOptions' properties based on the given PDF export configuration.\n   * This method will construct the internal ExportPDFOptions identically to how the 'Export PDF' dialog constructs the ExportPdfOptionsPresModel.\n   * See the handleExportClick method in @browser-clients/export-pdf-options-dialog for reference.\n   *\n   * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n   * @param externalExportPdfOptions The external ExportPDFOptions user-facing object passed to exportPDFAsync.\n   * @param sheetNames The list of sheets selected for export.\n   */\n  public static updateInternalExportPDFOptions(\n    internalExportPdfOptions: InternalExportPDFOptions,\n    externalExportPdfOptions: ExternalExportPDFOptions,\n    sheetNames: Array<string>,\n  ): void {\n    internalExportPdfOptions.currentSheet = sheetNames[0];\n    this.updateExportLayoutOptions(internalExportPdfOptions, externalExportPdfOptions);\n    this.updateSheetOptions(internalExportPdfOptions, sheetNames);\n  }\n\n  /**\n   * Helper method for updateInternalExportPDFOptions.\n   * Modifies the exportLayoutOptions property of the internal ExportPDFOptions based on the external ExportPDFOptions.\n   * See the getExportLayoutOptions method in @browser-clients/export-pdf-options-dialog for reference.\n   *\n   * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n   * @param externalExportPdfOptions The external ExportPDFOptions user-facing object passed to exportPDFAsync.\n   */\n  public static updateExportLayoutOptions(\n    internalExportPdfOptions: InternalExportPDFOptions,\n    externalExportPdfOptions: ExternalExportPDFOptions,\n  ): void {\n    const exportLayoutOptions = internalExportPdfOptions.exportLayoutOptions;\n\n    // setting the image height and width properties to their default values\n    exportLayoutOptions.imageHeight = this.DefaultLayoutOptions.imageHeight;\n    exportLayoutOptions.imageWidth = this.DefaultLayoutOptions.imageWidth;\n\n    //  setting the orientation value for the exportLayoutOptions\n    switch (externalExportPdfOptions.orientation) {\n      case PrintOrientation.Landscape:\n        exportLayoutOptions.pageOrientationOption = PageOrientation.Landscape;\n        break;\n      case PrintOrientation.Portrait:\n        exportLayoutOptions.pageOrientationOption = PageOrientation.Portrait;\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'invalid orientation for ExportPDFOption');\n    }\n\n    // setting the page size value for the exportLayoutOptions\n    switch (externalExportPdfOptions.pageSize) {\n      case PrintPageSize.A3:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.A3;\n        break;\n      case PrintPageSize.A4:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.A4;\n        break;\n      case PrintPageSize.A5:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.A5;\n        break;\n      case PrintPageSize.B4:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.B4;\n        break;\n      case PrintPageSize.B5:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.B5;\n        break;\n      case PrintPageSize.Executive:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Executive;\n        break;\n      case PrintPageSize.Folio:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Folio;\n        break;\n      case PrintPageSize.Ledger:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Ledger;\n        break;\n      case PrintPageSize.Legal:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Legal;\n        break;\n      case PrintPageSize.Letter:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Letter;\n        break;\n      case PrintPageSize.Note:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Note;\n        break;\n      case PrintPageSize.Quarto:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Quarto;\n        break;\n      case PrintPageSize.Statement:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Statement;\n        break;\n      case PrintPageSize.Tabloid:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Tabloid;\n        break;\n      case PrintPageSize.Unspecified:\n        exportLayoutOptions.pageSizeOption = PageSizeOption.Unspecified;\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'invalid pageSize for ExportPDFOption');\n    }\n\n    // setting the scaling values for the exportLayoutOptions\n    switch (externalExportPdfOptions.scaling) {\n      case PrintScaling.AtMost1PageHigh:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitOneHigh);\n        break;\n      case PrintScaling.AtMost1PageWide:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitOneWide);\n        break;\n      case PrintScaling.AtMost2PagesHigh:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitTwoHigh);\n        break;\n      case PrintScaling.AtMost2PagesWide:\n        this.setFitAndScaleValues(exportLayoutOptions, FitPages.FitTwoWide);\n        break;\n      case PrintScaling.Automatic:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePctAuto);\n        break;\n      case PrintScaling.Perc100:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct100);\n        break;\n      case PrintScaling.Perc200:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct200);\n        break;\n      case PrintScaling.Perc25:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct25);\n        break;\n      case PrintScaling.Perc400:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct400);\n        break;\n      case PrintScaling.Perc50:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct50);\n        break;\n      case PrintScaling.Perc60:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct60);\n        break;\n      case PrintScaling.Perc75:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct75);\n        break;\n      case PrintScaling.Perc80:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct80);\n        break;\n      case PrintScaling.Perc90:\n        this.setFitAndScaleValues(exportLayoutOptions, PageScalingOption.ScalePct90);\n        break;\n      default:\n        throw new TableauError(SharedErrorCodes.InternalError, 'invalid scaling for ExportPDFOption');\n    }\n  }\n\n  /**\n   * Helper method for updateInternalExportPDFOptions.\n   * Modifies the sheetOptions property of the internal ExportPDFOptions based on the sheets selected for export.\n   * See the handleExportClick method in @browser-clients/export-pdf-options-dialog for reference.\n   *\n   * @param internalExportPdfOptions The internal ExportPDFOptions pres model used to configure the output PDF file.\n   * @param sheetNames The list of sheets selected for export.\n   */\n  public static updateSheetOptions(internalExportPdfOptions: InternalExportPDFOptions, sheetNames: Array<string>): void {\n    const { exportLayoutOptions, sheetOptions } = internalExportPdfOptions;\n    // updating the export layouts options for each sheet and selecting sheet for export if included in list\n    for (const sheetOption of sheetOptions) {\n      sheetOption.exportLayoutOptions = exportLayoutOptions;\n      sheetOption.isSelected = sheetNames.includes(sheetOption.sheet);\n    }\n  }\n\n  /**\n   * Helper method for updateExportLayoutOptons.\n   * This method is a spoof of the getFitAndScaleValues method used in @browser-clients/export-pdf-options to set the exportLayoutOptions' scaling properties.\n   * In the future, this file should be refactored to import the method directly from @browser-clients/export-pdf-options.\n   *\n   * @param scalingSelection string used for setting the exportLayoutOptions based on the PrintScaling property from the ExternalExportPDFOptions.\n   * @param exportLayoutOptions the ExportLayoutOptions used by the internal ExportPDFOptions pres model.\n   */\n  public static setFitAndScaleValues(exportLayoutOptions: ExportLayoutOptions, scalingSelection: ScalingSelection): void {\n    let { pageFitHorizontal, pageFitVertical, pageScaleMode, pageScalePercent } = this.DefaultLayoutOptions;\n\n    const fitMatch = this.fitRegex.exec(scalingSelection);\n    const percentMatch = this.pctRegex.exec(scalingSelection);\n\n    if (fitMatch) {\n      [pageFitHorizontal, pageFitVertical] = fitMatch.slice(1).map((value) => Number(value));\n      pageScaleMode = ScaleMode.ScaleFitPages;\n    } else if (percentMatch) {\n      [pageScalePercent] = percentMatch.slice(1).map((value) => Number(value));\n      pageScaleMode = ScaleMode.ScalePercentage;\n    }\n\n    // getFitAndScaleValues returns the properties below, but instead this method will set them.\n    exportLayoutOptions.pageFitHorizontal = pageFitHorizontal;\n    exportLayoutOptions.pageFitVertical = pageFitVertical;\n    exportLayoutOptions.pageScaleMode = pageScaleMode;\n    exportLayoutOptions.pageScalePercent = pageScalePercent;\n  }\n\n  private static fitRegex = new RegExp('fit([0-9]+)x([0-9]+)');\n  private static pctRegex = new RegExp('pct([0-9]+)');\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\nimport { ErrorHelpers } from './ErrorHelpers';\n\nexport class Param {\n  /**\n   * serializes the date into the format that the server expects.\n   * @param date the date to serialize\n   */\n  public static serializeDateForPlatform(date: Date): string {\n    const year: number = date.getUTCFullYear();\n    const month: number = date.getUTCMonth() + 1;\n    const day: number = date.getUTCDate();\n    const hh: number = date.getUTCHours();\n    const mm: number = date.getUTCMinutes();\n    const sec: number = date.getUTCSeconds();\n    return `${year}-${month}-${day} ${hh}:${mm}:${sec}`;\n  }\n\n  public static serializeBooleanForPlatform(bool: boolean): string {\n    return bool ? 'true' : 'false';\n  }\n\n  public static serializeNumberForPlatform(num: number): string {\n    return num.toString(10);\n  }\n\n  /**\n   * Verifies the input is a number\n   */\n  /* tslint:disable-next-line:no-any */\n  public static isTypeNumber(input: any): boolean {\n    return typeof input === 'number' || input instanceof Number;\n  }\n\n  /**\n   * Verifies the input is a Date\n   */\n  /* tslint:disable-next-line:no-any */\n  public static isTypeDate(input: any): boolean {\n    return input instanceof Date;\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static isTypeString(input: any): boolean {\n    return typeof input === 'string' || input instanceof String;\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static isTypeBool(input: any): boolean {\n    return typeof input === 'boolean' || input instanceof Boolean;\n  }\n\n  /**\n   * Determines if the input is null or undefined\n   */\n  /* tslint:disable-next-line:no-any */\n  public static isNullOrUndefined(input: any): boolean {\n    return input === null || input === undefined;\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static serializeParameterValue(value: any): string {\n    if (Param.isTypeNumber(value)) {\n      return Param.serializeNumberForPlatform(value as number);\n    } else if (Param.isTypeDate(value)) {\n      return Param.serializeDateForPlatform(value as Date);\n    } else if (Param.isTypeBool(value)) {\n      return Param.serializeBooleanForPlatform(value as boolean);\n    } else if (Param.isTypeString(value)) {\n      return value;\n    } else {\n      throw new TableauError(ErrorCodes.InternalError, `Unexpected invalid value for: ${value}`);\n    }\n  }\n\n  /**\n   * Verifies that the parameter is already a Map, or converts an object to a Map.\n   * If the parameter is an object, we convert it to a Map using Object.entries.\n   * @throws if the parameter is not an object or Map\n   */\n  // tslint:disable-next-line:no-any\n  public static convertParameterToMap(param: object, paramName: string): Map<any, any> {\n    ErrorHelpers.verifyParameterType(param, 'object', paramName);\n    if (Array.isArray(param)) {\n      throw new TableauError(ErrorCodes.InvalidParameter, `Expecting object or Map for: ${paramName}.`);\n    }\n\n    return param instanceof Map ? param : new Map(Object.entries(param));\n  }\n\n  /* tslint:disable-next-line:no-any */\n  public static tryParseNumber(value: any): { parsed?: number; success: boolean } {\n    if (Param.isNullOrUndefined(value)) {\n      return { success: false };\n    }\n\n    if (Param.isTypeNumber(value)) {\n      return { parsed: value as number, success: true };\n    }\n\n    const valueString = value.toString();\n    if (valueString === 'NaN') {\n      // 'NaN' parses as NaN which is indistinguishable from a failed parse.\n      return { parsed: NaN, success: true };\n    }\n\n    const parsed = parseFloat(valueString);\n    if (isNaN(parsed)) {\n      return { success: false };\n    }\n\n    return { parsed, success: true };\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { SheetInfo, SheetType, SizeConstraint } from '@tableau/api-internal-contract-js';\nimport { TableauError } from '../TableauError';\n\nexport class SheetUtils {\n  // This is a direct port from SheetSize.cs - SheetSizeFactory\n  public static getSheetSizeFromSizeConstraints(sizeConstraint: SizeConstraint): Contract.SheetSize {\n    const { minWidth, minHeight, maxWidth, maxHeight } = sizeConstraint;\n\n    if (minHeight === 0 && minWidth === 0) {\n      if (maxHeight === 0 && maxWidth === 0) {\n        return {\n          behavior: Contract.SheetSizeBehavior.Automatic,\n        };\n      }\n\n      return {\n        behavior: Contract.SheetSizeBehavior.AtMost,\n        maxSize: { width: maxWidth, height: maxHeight },\n      };\n    }\n\n    if (maxHeight === 0 && maxWidth === 0) {\n      return {\n        behavior: Contract.SheetSizeBehavior.AtLeast,\n        minSize: { width: minWidth, height: minHeight },\n      };\n    }\n\n    if (maxHeight === minHeight && maxWidth === minWidth && minWidth > 0) {\n      return {\n        behavior: Contract.SheetSizeBehavior.Exactly,\n        minSize: { width: minWidth, height: minHeight },\n        maxSize: { width: minWidth, height: minHeight },\n      };\n    }\n\n    // 'Fit Width' for a DSD layout\n    const isDsdLayout = minWidth === 0 && maxWidth === 0;\n\n    return {\n      behavior: Contract.SheetSizeBehavior.Range,\n      minSize: { width: minWidth, height: minHeight },\n      maxSize: { width: isDsdLayout ? 2147483647 : maxWidth, height: maxHeight },\n    };\n  }\n\n  public static createAutomaticSize(): Contract.SheetSize {\n    let behavior = Contract.SheetSizeBehavior.Automatic;\n    let minSize = { width: 0, height: 0 };\n    let maxSize = { width: 0, height: 0 };\n    return { behavior, minSize, maxSize };\n  }\n\n  public static getPublishedSheetInfoByName(name: string, sheetInfos: Array<SheetInfo>): SheetInfo | undefined {\n    const sheetInfo = sheetInfos.find((sheet) => sheet.name === name);\n    return sheetInfo;\n  }\n\n  public static getSheetTypeEnum(internalSheetType: SheetType): Contract.SheetType {\n    let sheetType: Contract.SheetType;\n    switch (internalSheetType) {\n      case SheetType.Worksheet: {\n        sheetType = Contract.SheetType.Worksheet;\n        break;\n      }\n      case SheetType.Dashboard: {\n        sheetType = Contract.SheetType.Dashboard;\n        break;\n      }\n      case SheetType.Story: {\n        sheetType = Contract.SheetType.Story;\n        break;\n      }\n      default: {\n        throw new TableauError(Contract.SharedErrorCodes.ServerError, 'Invalid SheetType');\n      }\n    }\n    return sheetType;\n  }\n\n  public static isValidSheetSize(sizeObject: Contract.Size | Contract.SheetSize): sizeObject is Contract.SheetSize {\n    return (<Contract.SheetSize>sizeObject).behavior !== undefined;\n  }\n}\n","import * as Contract from '@tableau/api-external-contract-js';\nimport { TableauError } from '../TableauError';\nimport { Deferred, UnregisterTimeoutInMilliseconds } from './Deferred';\n\n/**\n * A Deferred wrapper class adding functionality to reject unresponsive promises after timeout\n *\n * this class handles two things:\n\n *    1. Adds timeout logic for deferred\n *    2. It blocks multiple calls from executing at the same time.\n *\n * @export\n * @class ShortLivedDeferred\n * @template TResolve The type used to resolve the promise.\n * @template TReject The type used to reject the promise. Defaults to any.\n *\n */\nexport class ShortLivedDeferred<TResolve, TReject = any> {\n  private _deferred: Deferred<TResolve, TReject> | undefined;\n  private _timeoutId;\n  constructor(private _timeoutInMilliseconds = UnregisterTimeoutInMilliseconds) {}\n\n  public getNewPromiseOrThrowIfBusy(): Promise<TResolve> {\n    if (this._deferred) {\n      throw new TableauError(Contract.SharedErrorCodes.ApiExecutionError, 'This api cannot be executed till previous call is resolved.');\n    }\n    this._deferred = new Deferred();\n\n    this._timeoutId = setTimeout(() => {\n      const error = new TableauError(\n        Contract.SharedErrorCodes.Timeout,\n        `Api failed to complete in ${this._timeoutInMilliseconds / 1000} seconds`,\n      );\n      this.reject(error);\n    }, this._timeoutInMilliseconds);\n\n    return this._deferred.promise;\n  }\n\n  public resolve(response: TResolve | PromiseLike<TResolve>): void {\n    if (this._deferred) {\n      clearTimeout(this._timeoutId);\n      this._deferred.resolve(response);\n      this._deferred = undefined;\n    }\n  }\n\n  public reject(error: any): void {\n    if (this._deferred) {\n      clearTimeout(this._timeoutId);\n      this._deferred.reject(error);\n      this._deferred = undefined;\n    }\n  }\n}\n","import { ErrorCodes } from '@tableau/api-external-contract-js';\nimport { TableauError } from './TableauError';\nimport { VersionNumberContract } from './VersionNumberContract';\n\n/**\n * Represents the current version of the extensions, embedding\n * and extensions-api-types library\n */\nexport class VersionNumber implements VersionNumberContract {\n  public major: number;\n  public minor: number;\n  public fix: number;\n  public build: number;\n  public isAlpha: boolean;\n\n  // private constructor so everyone uses the singleton instance\n  // build numbers have this form: M.m.f-pre.N\n  public constructor(versionString: string, isAlpha: boolean) {\n    const partStr = versionString.split('-');\n    this.build = this.getBuildNumber(partStr[1]);\n    versionString = partStr[0];\n\n    const parts = versionString.split('.').map((p) => parseInt(p, 10));\n    if (parts.length !== 3) {\n      throw new TableauError(ErrorCodes.InternalError, `Invalid version number: ${versionString}`);\n    }\n\n    this.major = parts[0];\n    this.minor = parts[1];\n    this.fix = parts[2];\n    this.isAlpha = isAlpha;\n  }\n\n  private getBuildNumber(preReleaseString: string): number {\n    const noBuildNumber = -1;\n    if (!preReleaseString) {\n      return noBuildNumber;\n    }\n\n    // The preRelease string has this form: pre.N, but we don't depend on the actual string being 'pre'\n    const partStr = preReleaseString.split('.');\n    return partStr[1] ? parseInt(partStr[1], 10) : noBuildNumber;\n  }\n\n  public get formattedValue(): string {\n    return `${this.major}.${this.minor}.${this.fix}`;\n  }\n\n  public get fullFormattedValue(): string {\n    return `${this.major}.${this.minor}.${this.fix}-pre.${this.build}`;\n  }\n}\n","import {\n  CreateExternalCompatibleVersionConverter,\n  ExecuteParameters,\n  ExecuteResponse,\n  ExternalContractVersionConverter,\n  InternalApiDispatcher,\n  INTERNAL_CONTRACT_VERSION,\n  Notification,\n  NotificationHandler,\n  VerbId,\n  VersionLessThan,\n  VersionNumber,\n} from '@tableau/api-internal-contract-js';\n\n/**\n * Implementation of the InternalApiDispatcher which supports upgrading and downgrading the input\n * internal contract to the version that this module is built against\n *\n * @class VersionedExternalApiDispatcher\n * @implements {InternalApiDispatcher}\n */\nexport class VersionedExternalApiDispatcher implements InternalApiDispatcher {\n  private _versionConverter: ExternalContractVersionConverter;\n  private _notificationHandlers: Array<NotificationHandler>;\n\n  /**\n   * Creates a new instance of the VersionedExternalApiDispatcher\n   * We have multiple version converting dispatchers that work together.\n   * If needed, the VersionedExternalApiDispatcher wraps either the InternalApiDispatcher (desktop)\n   * or the CrossFrameDispatcher (server).\n   * The Internal/CrossFrame dispatchers handle an updated platform with an older external library.\n   * (The CrossFrameDispatcher sends messages across the frame, and it is handled by the PresLayerHandler.)\n   * Meanwhile, the VersionedExternalApiDispatcher handles an updated external library with an older platform.\n\n   * @param _apiDelegateDispatcher The delegate that does the actual work.\n   * @param platformVersionNumber The version of the internal contract which the platform module is using.\n   * This number will be used to figure out how to downgrade incoming commands and upgrade the results\n   */\n  public constructor(private _apiDelegateDispatcher: InternalApiDispatcher, platformVersionNumber: VersionNumber) {\n    this._versionConverter = CreateExternalCompatibleVersionConverter(INTERNAL_CONTRACT_VERSION, platformVersionNumber);\n\n    this._notificationHandlers = [];\n    _apiDelegateDispatcher.registerNotificationHandler((notification: Notification): void => {\n      if (this._notificationHandlers.length === 0) {\n        return;\n      }\n      const upgradedNotification = this._versionConverter.upgradeNotification(notification);\n      this._notificationHandlers.forEach((handler) => {\n        handler(upgradedNotification);\n      });\n    });\n  }\n\n  public static needsVersionConverter(platformVersion: VersionNumber): boolean {\n    // If our platform is less than external library version, then we need a converter\n    return VersionLessThan(platformVersion, INTERNAL_CONTRACT_VERSION);\n  }\n\n  public execute(verb: VerbId, parameters: ExecuteParameters): Promise<ExecuteResponse> {\n    try {\n      const downgradeParameters = this._versionConverter.downgradeExecuteCall(verb, parameters);\n      return this._apiDelegateDispatcher.execute(downgradeParameters.verb, downgradeParameters.parameters).then((response) => {\n        const upgradeResponse = this._versionConverter.upgradeExecuteReturn(response, verb, parameters);\n        return upgradeResponse;\n      });\n    } catch (e) {\n      return Promise.reject(e);\n    }\n  }\n\n  public registerNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers.push(handler);\n  }\n\n  public unregisterNotificationHandler(handler: NotificationHandler): void {\n    this._notificationHandlers = this._notificationHandlers.filter((h) => h !== handler);\n  }\n}\n","export { default as v1 } from './v1.js';\nexport { default as v3 } from './v3.js';\nexport { default as v4 } from './v4.js';\nexport { default as v5 } from './v5.js';\nexport { default as NIL } from './nil.js';\nexport { default as version } from './version.js';\nexport { default as validate } from './validate.js';\nexport { default as stringify } from './stringify.js';\nexport { default as parse } from './parse.js';","/*\n * Browser-compatible JavaScript MD5\n *\n * Modification of JavaScript MD5\n * https://github.com/blueimp/JavaScript-MD5\n *\n * Copyright 2011, Sebastian Tschan\n * https://blueimp.net\n *\n * Licensed under the MIT license:\n * https://opensource.org/licenses/MIT\n *\n * Based on\n * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message\n * Digest Algorithm, as defined in RFC 1321.\n * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for more info.\n */\nfunction md5(bytes) {\n  if (typeof bytes === 'string') {\n    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\n\n    bytes = new Uint8Array(msg.length);\n\n    for (var i = 0; i < msg.length; ++i) {\n      bytes[i] = msg.charCodeAt(i);\n    }\n  }\n\n  return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));\n}\n/*\n * Convert an array of little-endian words to an array of bytes\n */\n\n\nfunction md5ToHexEncodedArray(input) {\n  var output = [];\n  var length32 = input.length * 32;\n  var hexTab = '0123456789abcdef';\n\n  for (var i = 0; i < length32; i += 8) {\n    var x = input[i >> 5] >>> i % 32 & 0xff;\n    var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);\n    output.push(hex);\n  }\n\n  return output;\n}\n/**\n * Calculate output length with padding and bit length\n */\n\n\nfunction getOutputLength(inputLength8) {\n  return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;\n}\n/*\n * Calculate the MD5 of an array of little-endian words, and a bit length.\n */\n\n\nfunction wordsToMd5(x, len) {\n  /* append padding */\n  x[len >> 5] |= 0x80 << len % 32;\n  x[getOutputLength(len) - 1] = len;\n  var a = 1732584193;\n  var b = -271733879;\n  var c = -1732584194;\n  var d = 271733878;\n\n  for (var i = 0; i < x.length; i += 16) {\n    var olda = a;\n    var oldb = b;\n    var oldc = c;\n    var oldd = d;\n    a = md5ff(a, b, c, d, x[i], 7, -680876936);\n    d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);\n    c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);\n    b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);\n    a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);\n    d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);\n    c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);\n    b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);\n    a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);\n    d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);\n    c = md5ff(c, d, a, b, x[i + 10], 17, -42063);\n    b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);\n    a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);\n    d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);\n    c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);\n    b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);\n    a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);\n    d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);\n    c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);\n    b = md5gg(b, c, d, a, x[i], 20, -373897302);\n    a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);\n    d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);\n    c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);\n    b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);\n    a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);\n    d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);\n    c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);\n    b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);\n    a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);\n    d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);\n    c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);\n    b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);\n    a = md5hh(a, b, c, d, x[i + 5], 4, -378558);\n    d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);\n    c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);\n    b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);\n    a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);\n    d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);\n    c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);\n    b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);\n    a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);\n    d = md5hh(d, a, b, c, x[i], 11, -358537222);\n    c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);\n    b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);\n    a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);\n    d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);\n    c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);\n    b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);\n    a = md5ii(a, b, c, d, x[i], 6, -198630844);\n    d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);\n    c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);\n    b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);\n    a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);\n    d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);\n    c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);\n    b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);\n    a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);\n    d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);\n    c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);\n    b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);\n    a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);\n    d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);\n    c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);\n    b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);\n    a = safeAdd(a, olda);\n    b = safeAdd(b, oldb);\n    c = safeAdd(c, oldc);\n    d = safeAdd(d, oldd);\n  }\n\n  return [a, b, c, d];\n}\n/*\n * Convert an array bytes to an array of little-endian words\n * Characters >255 have their high-byte silently ignored.\n */\n\n\nfunction bytesToWords(input) {\n  if (input.length === 0) {\n    return [];\n  }\n\n  var length8 = input.length * 8;\n  var output = new Uint32Array(getOutputLength(length8));\n\n  for (var i = 0; i < length8; i += 8) {\n    output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;\n  }\n\n  return output;\n}\n/*\n * Add integers, wrapping at 2^32. This uses 16-bit operations internally\n * to work around bugs in some JS interpreters.\n */\n\n\nfunction safeAdd(x, y) {\n  var lsw = (x & 0xffff) + (y & 0xffff);\n  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n  return msw << 16 | lsw & 0xffff;\n}\n/*\n * Bitwise rotate a 32-bit number to the left.\n */\n\n\nfunction bitRotateLeft(num, cnt) {\n  return num << cnt | num >>> 32 - cnt;\n}\n/*\n * These functions implement the four basic operations the algorithm uses.\n */\n\n\nfunction md5cmn(q, a, b, x, s, t) {\n  return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);\n}\n\nfunction md5ff(a, b, c, d, x, s, t) {\n  return md5cmn(b & c | ~b & d, a, b, x, s, t);\n}\n\nfunction md5gg(a, b, c, d, x, s, t) {\n  return md5cmn(b & d | c & ~d, a, b, x, s, t);\n}\n\nfunction md5hh(a, b, c, d, x, s, t) {\n  return md5cmn(b ^ c ^ d, a, b, x, s, t);\n}\n\nfunction md5ii(a, b, c, d, x, s, t) {\n  return md5cmn(c ^ (b | ~d), a, b, x, s, t);\n}\n\nexport default md5;","export default '00000000-0000-0000-0000-000000000000';","import validate from './validate.js';\n\nfunction parse(uuid) {\n  if (!validate(uuid)) {\n    throw TypeError('Invalid UUID');\n  }\n\n  var v;\n  var arr = new Uint8Array(16); // Parse ########-....-....-....-............\n\n  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;\n  arr[1] = v >>> 16 & 0xff;\n  arr[2] = v >>> 8 & 0xff;\n  arr[3] = v & 0xff; // Parse ........-####-....-....-............\n\n  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;\n  arr[5] = v & 0xff; // Parse ........-....-####-....-............\n\n  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;\n  arr[7] = v & 0xff; // Parse ........-....-....-####-............\n\n  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;\n  arr[9] = v & 0xff; // Parse ........-....-....-....-############\n  // (Use \"/\" to avoid 32-bit truncation when bit-shifting high-order bytes)\n\n  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;\n  arr[11] = v / 0x100000000 & 0xff;\n  arr[12] = v >>> 24 & 0xff;\n  arr[13] = v >>> 16 & 0xff;\n  arr[14] = v >>> 8 & 0xff;\n  arr[15] = v & 0xff;\n  return arr;\n}\n\nexport default parse;","export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nvar getRandomValues;\nvar rnds8 = new Uint8Array(16);\nexport default function rng() {\n  // lazy load so that environments that need to polyfill have a chance to do so\n  if (!getRandomValues) {\n    // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation. Also,\n    // find the complete implementation of crypto (msCrypto) on IE11.\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\n\n    if (!getRandomValues) {\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n    }\n  }\n\n  return getRandomValues(rnds8);\n}","// Adapted from Chris Veness' SHA1 code at\n// http://www.movable-type.co.uk/scripts/sha1.html\nfunction f(s, x, y, z) {\n  switch (s) {\n    case 0:\n      return x & y ^ ~x & z;\n\n    case 1:\n      return x ^ y ^ z;\n\n    case 2:\n      return x & y ^ x & z ^ y & z;\n\n    case 3:\n      return x ^ y ^ z;\n  }\n}\n\nfunction ROTL(x, n) {\n  return x << n | x >>> 32 - n;\n}\n\nfunction sha1(bytes) {\n  var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];\n  var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];\n\n  if (typeof bytes === 'string') {\n    var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape\n\n    bytes = [];\n\n    for (var i = 0; i < msg.length; ++i) {\n      bytes.push(msg.charCodeAt(i));\n    }\n  } else if (!Array.isArray(bytes)) {\n    // Convert Array-like to Array\n    bytes = Array.prototype.slice.call(bytes);\n  }\n\n  bytes.push(0x80);\n  var l = bytes.length / 4 + 2;\n  var N = Math.ceil(l / 16);\n  var M = new Array(N);\n\n  for (var _i = 0; _i < N; ++_i) {\n    var arr = new Uint32Array(16);\n\n    for (var j = 0; j < 16; ++j) {\n      arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];\n    }\n\n    M[_i] = arr;\n  }\n\n  M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);\n  M[N - 1][14] = Math.floor(M[N - 1][14]);\n  M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;\n\n  for (var _i2 = 0; _i2 < N; ++_i2) {\n    var W = new Uint32Array(80);\n\n    for (var t = 0; t < 16; ++t) {\n      W[t] = M[_i2][t];\n    }\n\n    for (var _t = 16; _t < 80; ++_t) {\n      W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);\n    }\n\n    var a = H[0];\n    var b = H[1];\n    var c = H[2];\n    var d = H[3];\n    var e = H[4];\n\n    for (var _t2 = 0; _t2 < 80; ++_t2) {\n      var s = Math.floor(_t2 / 20);\n      var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;\n      e = d;\n      d = c;\n      c = ROTL(b, 30) >>> 0;\n      b = a;\n      a = T;\n    }\n\n    H[0] = H[0] + a >>> 0;\n    H[1] = H[1] + b >>> 0;\n    H[2] = H[2] + c >>> 0;\n    H[3] = H[3] + d >>> 0;\n    H[4] = H[4] + e >>> 0;\n  }\n\n  return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];\n}\n\nexport default sha1;","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nvar byteToHex = [];\n\nfor (var i = 0; i < 256; ++i) {\n  byteToHex.push((i + 0x100).toString(16).substr(1));\n}\n\nfunction stringify(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  // Note: Be careful editing this code!  It's been tuned for performance\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one\n  // of the following:\n  // - One or more input array values don't map to a hex octet (leading to\n  // \"undefined\" in the uuid)\n  // - Invalid input values for the RFC `version` or `variant` fields\n\n  if (!validate(uuid)) {\n    throw TypeError('Stringified UUID is invalid');\n  }\n\n  return uuid;\n}\n\nexport default stringify;","import rng from './rng.js';\nimport stringify from './stringify.js'; // **`v1()` - Generate time-based UUID**\n//\n// Inspired by https://github.com/LiosK/UUID.js\n// and http://docs.python.org/library/uuid.html\n\nvar _nodeId;\n\nvar _clockseq; // Previous uuid creation time\n\n\nvar _lastMSecs = 0;\nvar _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details\n\nfunction v1(options, buf, offset) {\n  var i = buf && offset || 0;\n  var b = buf || new Array(16);\n  options = options || {};\n  var node = options.node || _nodeId;\n  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not\n  // specified.  We do this lazily to minimize issues related to insufficient\n  // system entropy.  See #189\n\n  if (node == null || clockseq == null) {\n    var seedBytes = options.random || (options.rng || rng)();\n\n    if (node == null) {\n      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)\n      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];\n    }\n\n    if (clockseq == null) {\n      // Per 4.2.2, randomize (14 bit) clockseq\n      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;\n    }\n  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,\n  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so\n  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'\n  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.\n\n\n  var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock\n  // cycle to simulate higher resolution clock\n\n  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)\n\n  var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression\n\n  if (dt < 0 && options.clockseq === undefined) {\n    clockseq = clockseq + 1 & 0x3fff;\n  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new\n  // time interval\n\n\n  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {\n    nsecs = 0;\n  } // Per 4.2.1.2 Throw error if too many uuids are requested\n\n\n  if (nsecs >= 10000) {\n    throw new Error(\"uuid.v1(): Can't create more than 10M uuids/sec\");\n  }\n\n  _lastMSecs = msecs;\n  _lastNSecs = nsecs;\n  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch\n\n  msecs += 12219292800000; // `time_low`\n\n  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;\n  b[i++] = tl >>> 24 & 0xff;\n  b[i++] = tl >>> 16 & 0xff;\n  b[i++] = tl >>> 8 & 0xff;\n  b[i++] = tl & 0xff; // `time_mid`\n\n  var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;\n  b[i++] = tmh >>> 8 & 0xff;\n  b[i++] = tmh & 0xff; // `time_high_and_version`\n\n  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version\n\n  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)\n\n  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`\n\n  b[i++] = clockseq & 0xff; // `node`\n\n  for (var n = 0; n < 6; ++n) {\n    b[i + n] = node[n];\n  }\n\n  return buf || stringify(b);\n}\n\nexport default v1;","import v35 from './v35.js';\nimport md5 from './md5.js';\nvar v3 = v35('v3', 0x30, md5);\nexport default v3;","import stringify from './stringify.js';\nimport parse from './parse.js';\n\nfunction stringToBytes(str) {\n  str = unescape(encodeURIComponent(str)); // UTF8 escape\n\n  var bytes = [];\n\n  for (var i = 0; i < str.length; ++i) {\n    bytes.push(str.charCodeAt(i));\n  }\n\n  return bytes;\n}\n\nexport var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';\nexport var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';\nexport default function (name, version, hashfunc) {\n  function generateUUID(value, namespace, buf, offset) {\n    if (typeof value === 'string') {\n      value = stringToBytes(value);\n    }\n\n    if (typeof namespace === 'string') {\n      namespace = parse(namespace);\n    }\n\n    if (namespace.length !== 16) {\n      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');\n    } // Compute hash of namespace and value, Per 4.3\n    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =\n    // hashfunc([...namespace, ... value])`\n\n\n    var bytes = new Uint8Array(16 + value.length);\n    bytes.set(namespace);\n    bytes.set(value, namespace.length);\n    bytes = hashfunc(bytes);\n    bytes[6] = bytes[6] & 0x0f | version;\n    bytes[8] = bytes[8] & 0x3f | 0x80;\n\n    if (buf) {\n      offset = offset || 0;\n\n      for (var i = 0; i < 16; ++i) {\n        buf[offset + i] = bytes[i];\n      }\n\n      return buf;\n    }\n\n    return stringify(bytes);\n  } // Function#name is not settable on some platforms (#270)\n\n\n  try {\n    generateUUID.name = name; // eslint-disable-next-line no-empty\n  } catch (err) {} // For CommonJS default export support\n\n\n  generateUUID.DNS = DNS;\n  generateUUID.URL = URL;\n  return generateUUID;\n}","import rng from './rng.js';\nimport stringify from './stringify.js';\n\nfunction v4(options, buf, offset) {\n  options = options || {};\n  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n  rnds[6] = rnds[6] & 0x0f | 0x40;\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n  if (buf) {\n    offset = offset || 0;\n\n    for (var i = 0; i < 16; ++i) {\n      buf[offset + i] = rnds[i];\n    }\n\n    return buf;\n  }\n\n  return stringify(rnds);\n}\n\nexport default v4;","import v35 from './v35.js';\nimport sha1 from './sha1.js';\nvar v5 = v35('v5', 0x50, sha1);\nexport default v5;","import REGEX from './regex.js';\n\nfunction validate(uuid) {\n  return typeof uuid === 'string' && REGEX.test(uuid);\n}\n\nexport default validate;","import validate from './validate.js';\n\nfunction version(uuid) {\n  if (!validate(uuid)) {\n    throw TypeError('Invalid UUID');\n  }\n\n  return parseInt(uuid.substr(14, 1), 16);\n}\n\nexport default version;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","/**\n * This is your main. This is where you re-export everything you want to be publicly available.\n *\n * The build enforces that the file has the same name as the global variable that is exported.\n */\n\n// The following polyfills are needed for IE11\n\nimport { ApiVersion } from '@tableau/api-shared-js';\nimport 'core-js/es/array/find';\nimport 'core-js/es/array/from';\nimport 'core-js/es/map';\nimport 'core-js/es/number/is-integer';\nimport 'core-js/es/number/is-nan';\nimport 'core-js/es/number/parse-float';\nimport 'core-js/es/number/parse-int';\nimport 'core-js/es/object/assign';\nimport 'core-js/es/object/entries';\nimport 'core-js/es/object/set-prototype-of';\nimport 'core-js/es/promise';\n// Due to the way we configured webpack, we should be exporting things which will be under\n// a global variable called \"tableau\". Export everything we want to be visible under tableau\n// from this file.\nimport { ExtensionsImpl } from './ExtensionsApi/Impl/ExtensionsImpl';\nimport { Extensions } from './ExtensionsApi/Namespaces/Extensions';\n\ndeclare let VERSION_IS_ALPHA: boolean;\nconst isAlpha: boolean = typeof VERSION_IS_ALPHA !== 'undefined' ? VERSION_IS_ALPHA : false;\n\ndeclare let API_VERSION_NUMBER: string;\nApiVersion.SetVersionNumber(typeof API_VERSION_NUMBER !== 'undefined' ? API_VERSION_NUMBER : '0.0.0', isAlpha);\n\nconst extensionImpl = new ExtensionsImpl();\nexport const extensions = new Extensions(extensionImpl);\n\n// Export Enums\n// These show up under the tableau object. I.e. tableau.ExtensionContext.Server\nexport {\n  AnalyticsObjectType,\n  AnnotationType,\n  ClassNameKey,\n  ColumnType,\n  DashboardLayoutChange,\n  DashboardObjectType,\n  DashboardObjectVisibilityType,\n  DataType,\n  DateRangeType,\n  DialogStyle,\n  EncodingType,\n  ErrorCodes,\n  ExtensionContext,\n  ExtensionMode,\n  FieldAggregationType,\n  FieldRoleType,\n  FilterDomainType,\n  FilterNullOption,\n  FilterType,\n  FilterUpdateType,\n  HierarchicalLevelSelectionState,\n  IncludeDataValuesOption,\n  MarkType,\n  ParameterValueType,\n  PeriodType,\n  QuickTableCalcType,\n  RelativeDateFilterOptions,\n  ReplaySpeedType,\n  SelectOptions,\n  SelectionUpdateType,\n  SheetType,\n  SortDirection,\n  TableauEventType,\n  TrendLineModelType,\n  VizImageEncodingType,\n  VizImagePaletteType,\n  VizImageSizeSettingAlignmentType,\n  VizImageSizeSettingType,\n  VizImageSortDirectionType,\n  ZoneVisibilityType,\n} from '@tableau/api-external-contract-js';\n"],"names":[],"sourceRoot":""} \ No newline at end of file diff --git a/lib/tableau.extensions.1.latest.min.js b/lib/tableau.extensions.1.latest.min.js index 124aa493..fd2bda4a 100644 --- a/lib/tableau.extensions.1.latest.min.js +++ b/lib/tableau.extensions.1.latest.min.js @@ -1,2 +1,2 @@ -(()=>{var e={163:(e,t,r)=>{r(9228);var n=r(8791);e.exports=n("Array","find")},6916:(e,t,r)=>{r(8673),r(7233);var n=r(9276);e.exports=n.Array.from},9618:(e,t,r)=>{r(5735),r(9321),r(8188),r(8673);var n=r(9276);e.exports=n.Map},5611:(e,t,r)=>{r(3132);var n=r(9276);e.exports=n.Number.isInteger},2316:(e,t,r)=>{r(4586);var n=r(9276);e.exports=n.Number.isNaN},119:(e,t,r)=>{r(8836);var n=r(9276);e.exports=n.Number.parseFloat},1980:(e,t,r)=>{r(7208);var n=r(9276);e.exports=n.Number.parseInt},47:(e,t,r)=>{r(3105);var n=r(9276);e.exports=n.Object.assign},188:(e,t,r)=>{r(5883);var n=r(9276);e.exports=n.Object.entries},5956:(e,t,r)=>{r(2506);var n=r(9276);e.exports=n.Object.setPrototypeOf},4137:(e,t,r)=>{r(5738),r(5735),r(8188),r(3439),r(7919),r(7178),r(1515),r(8673);var n=r(9276);e.exports=n.Promise},7111:(e,t,r)=>{var n=r(9859),i=r(6733),o=r(9821),a=n.TypeError;e.exports=function(e){if(i(e))return e;throw a(o(e)+" is not a function")}},7988:(e,t,r)=>{var n=r(9859),i=r(2359),o=r(9821),a=n.TypeError;e.exports=function(e){if(i(e))return e;throw a(o(e)+" is not a constructor")}},8505:(e,t,r)=>{var n=r(9859),i=r(6733),o=n.String,a=n.TypeError;e.exports=function(e){if("object"==typeof e||i(e))return e;throw a("Can't set "+o(e)+" as a prototype")}},9736:(e,t,r)=>{var n=r(95),i=r(7263),o=r(1787),a=n("unscopables"),s=Array.prototype;null==s[a]&&o.f(s,a,{configurable:!0,value:i(null)}),e.exports=function(e){s[a][e]=!0}},7728:(e,t,r)=>{var n=r(9859),i=r(1321),o=n.TypeError;e.exports=function(e,t){if(i(t,e))return e;throw o("Incorrect invocation")}},1176:(e,t,r)=>{var n=r(9859),i=r(5052),o=n.String,a=n.TypeError;e.exports=function(e){if(i(e))return e;throw a(o(e)+" is not an object")}},507:(e,t,r)=>{"use strict";var n=r(9859),i=r(7636),o=r(266),a=r(2991),s=r(4960),u=r(1943),l=r(2359),c=r(9646),p=r(2324),d=r(8403),f=r(8830),y=n.Array;e.exports=function(e){var t=a(e),r=l(this),n=arguments.length,h=n>1?arguments[1]:void 0,m=void 0!==h;m&&(h=i(h,n>2?arguments[2]:void 0));var g,v,b,I,S,_,T=f(t),P=0;if(!T||this==y&&u(T))for(g=c(t),v=r?new this(g):y(g);g>P;P++)_=m?h(t[P],P):t[P],p(v,P,_);else for(S=(I=d(t,T)).next,v=r?new this:[];!(b=o(S,I)).done;P++)_=m?s(I,h,[b.value,P],!0):b.value,p(v,P,_);return v.length=P,v}},9540:(e,t,r)=>{var n=r(905),i=r(3231),o=r(9646),a=function(e){return function(t,r,a){var s,u=n(t),l=o(u),c=i(a,l);if(e&&r!=r){for(;l>c;)if((s=u[c++])!=s)return!0}else for(;l>c;c++)if((e||c in u)&&u[c]===r)return e||c||0;return!e&&-1}};e.exports={includes:a(!0),indexOf:a(!1)}},9996:(e,t,r)=>{var n=r(7636),i=r(5968),o=r(9337),a=r(2991),s=r(9646),u=r(7501),l=i([].push),c=function(e){var t=1==e,r=2==e,i=3==e,c=4==e,p=6==e,d=7==e,f=5==e||p;return function(y,h,m,g){for(var v,b,I=a(y),S=o(I),_=n(h,m),T=s(S),P=0,A=g||u,E=t?A(y,T):r||d?A(y,0):void 0;T>P;P++)if((f||P in S)&&(b=_(v=S[P],P,I),e))if(t)E[P]=b;else if(b)switch(e){case 3:return!0;case 5:return v;case 6:return P;case 2:l(E,v)}else switch(e){case 4:return!1;case 7:l(E,v)}return p?-1:i||c?c:E}};e.exports={forEach:c(0),map:c(1),filter:c(2),some:c(3),every:c(4),find:c(5),findIndex:c(6),filterReject:c(7)}},1909:(e,t,r)=>{var n=r(5968);e.exports=n([].slice)},8760:(e,t,r)=>{var n=r(9859),i=r(3718),o=r(2359),a=r(5052),s=r(95)("species"),u=n.Array;e.exports=function(e){var t;return i(e)&&(t=e.constructor,(o(t)&&(t===u||i(t.prototype))||a(t)&&null===(t=t[s]))&&(t=void 0)),void 0===t?u:t}},7501:(e,t,r)=>{var n=r(8760);e.exports=function(e,t){return new(n(e))(0===t?0:t)}},4960:(e,t,r)=>{var n=r(1176),i=r(7281);e.exports=function(e,t,r,o){try{return o?t(n(r)[0],r[1]):t(r)}catch(t){i(e,"throw",t)}}},4575:(e,t,r)=>{var n=r(95)("iterator"),i=!1;try{var o=0,a={next:function(){return{done:!!o++}},return:function(){i=!0}};a[n]=function(){return this},Array.from(a,(function(){throw 2}))}catch(e){}e.exports=function(e,t){if(!t&&!i)return!1;var r=!1;try{var o={};o[n]=function(){return{next:function(){return{done:r=!0}}}},e(o)}catch(e){}return r}},7079:(e,t,r)=>{var n=r(5968),i=n({}.toString),o=n("".slice);e.exports=function(e){return o(i(e),8,-1)}},1589:(e,t,r)=>{var n=r(9859),i=r(1601),o=r(6733),a=r(7079),s=r(95)("toStringTag"),u=n.Object,l="Arguments"==a(function(){return arguments}());e.exports=i?a:function(e){var t,r,n;return void 0===e?"Undefined":null===e?"Null":"string"==typeof(r=function(e,t){try{return e[t]}catch(e){}}(t=u(e),s))?r:l?a(t):"Object"==(n=a(t))&&o(t.callee)?"Arguments":n}},1590:(e,t,r)=>{var n=r(5968),i=r(1909),o=n("".replace),a=n("".split),s=n([].join),u=String(Error("zxcasd").stack),l=/\n\s*at [^:]*:[^\n]*/,c=l.test(u),p=/@[^\n]*\n/.test(u)&&!/zxcasd/.test(u);e.exports=function(e,t){if("string"!=typeof e)return e;if(c)for(;t--;)e=o(e,l,"");else if(p)return s(i(a(e,"\n"),t),"\n");return e}},8081:(e,t,r)=>{"use strict";var n=r(1787).f,i=r(7263),o=r(8787),a=r(7636),s=r(7728),u=r(9003),l=r(7675),c=r(1832),p=r(7400),d=r(5926).fastKey,f=r(6407),y=f.set,h=f.getterFor;e.exports={getConstructor:function(e,t,r,l){var c=e((function(e,n){s(e,f),y(e,{type:t,index:i(null),first:void 0,last:void 0,size:0}),p||(e.size=0),null!=n&&u(n,e[l],{that:e,AS_ENTRIES:r})})),f=c.prototype,m=h(t),g=function(e,t,r){var n,i,o=m(e),a=v(e,t);return a?a.value=r:(o.last=a={index:i=d(t,!0),key:t,value:r,previous:n=o.last,next:void 0,removed:!1},o.first||(o.first=a),n&&(n.next=a),p?o.size++:e.size++,"F"!==i&&(o.index[i]=a)),e},v=function(e,t){var r,n=m(e),i=d(t);if("F"!==i)return n.index[i];for(r=n.first;r;r=r.next)if(r.key==t)return r};return o(f,{clear:function(){for(var e=m(this),t=e.index,r=e.first;r;)r.removed=!0,r.previous&&(r.previous=r.previous.next=void 0),delete t[r.index],r=r.next;e.first=e.last=void 0,p?e.size=0:this.size=0},delete:function(e){var t=this,r=m(t),n=v(t,e);if(n){var i=n.next,o=n.previous;delete r.index[n.index],n.removed=!0,o&&(o.next=i),i&&(i.previous=o),r.first==n&&(r.first=i),r.last==n&&(r.last=o),p?r.size--:t.size--}return!!n},forEach:function(e){for(var t,r=m(this),n=a(e,arguments.length>1?arguments[1]:void 0);t=t?t.next:r.first;)for(n(t.value,t.key,this);t&&t.removed;)t=t.previous},has:function(e){return!!v(this,e)}}),o(f,r?{get:function(e){var t=v(this,e);return t&&t.value},set:function(e,t){return g(this,0===e?0:e,t)}}:{add:function(e){return g(this,e=0===e?0:e,e)}}),p&&n(f,"size",{get:function(){return m(this).size}}),c},setStrong:function(e,t,r){var n=t+" Iterator",i=h(t),o=h(n);l(e,t,(function(e,t){y(this,{type:n,target:e,state:i(e),kind:t,last:void 0})}),(function(){for(var e=o(this),t=e.kind,r=e.last;r&&r.removed;)r=r.previous;return e.target&&(e.last=r=r?r.next:e.state.first)?"keys"==t?{value:r.key,done:!1}:"values"==t?{value:r.value,done:!1}:{value:[r.key,r.value],done:!1}:(e.target=void 0,{value:void 0,done:!0})}),r?"entries":"values",!r,!0),c(t)}}},9789:(e,t,r)=>{"use strict";var n=r(3103),i=r(9859),o=r(5968),a=r(6541),s=r(7487),u=r(5926),l=r(9003),c=r(7728),p=r(6733),d=r(5052),f=r(4229),y=r(4575),h=r(4555),m=r(835);e.exports=function(e,t,r){var g=-1!==e.indexOf("Map"),v=-1!==e.indexOf("Weak"),b=g?"set":"add",I=i[e],S=I&&I.prototype,_=I,T={},P=function(e){var t=o(S[e]);s(S,e,"add"==e?function(e){return t(this,0===e?0:e),this}:"delete"==e?function(e){return!(v&&!d(e))&&t(this,0===e?0:e)}:"get"==e?function(e){return v&&!d(e)?void 0:t(this,0===e?0:e)}:"has"==e?function(e){return!(v&&!d(e))&&t(this,0===e?0:e)}:function(e,r){return t(this,0===e?0:e,r),this})};if(a(e,!p(I)||!(v||S.forEach&&!f((function(){(new I).entries().next()})))))_=r.getConstructor(t,e,g,b),u.enable();else if(a(e,!0)){var A=new _,E=A[b](v?{}:-0,1)!=A,w=f((function(){A.has(1)})),O=y((function(e){new I(e)})),D=!v&&f((function(){for(var e=new I,t=5;t--;)e[b](t,t);return!e.has(-0)}));O||((_=t((function(e,t){c(e,S);var r=m(new I,e,_);return null!=t&&l(t,r[b],{that:r,AS_ENTRIES:g}),r}))).prototype=S,S.constructor=_),(w||D)&&(P("delete"),P("has"),g&&P("get")),(D||E)&&P(b),v&&S.clear&&delete S.clear}return T[e]=_,n({global:!0,forced:_!=I},T),h(_,e),v||r.setStrong(_,e,g),_}},7081:(e,t,r)=>{var n=r(8270),i=r(4826),o=r(7933),a=r(1787);e.exports=function(e,t){for(var r=i(t),s=a.f,u=o.f,l=0;l{var n=r(4229);e.exports=!n((function(){function e(){}return e.prototype.constructor=null,Object.getPrototypeOf(new e)!==e.prototype}))},3723:(e,t,r)=>{"use strict";var n=r(693).IteratorPrototype,i=r(7263),o=r(5358),a=r(4555),s=r(5495),u=function(){return this};e.exports=function(e,t,r){var l=t+" Iterator";return e.prototype=i(n,{next:o(1,r)}),a(e,l,!1,!0),s[l]=u,e}},5762:(e,t,r)=>{var n=r(7400),i=r(1787),o=r(5358);e.exports=n?function(e,t,r){return i.f(e,t,o(1,r))}:function(e,t,r){return e[t]=r,e}},5358:e=>{e.exports=function(e,t){return{enumerable:!(1&e),configurable:!(2&e),writable:!(4&e),value:t}}},2324:(e,t,r)=>{"use strict";var n=r(9310),i=r(1787),o=r(5358);e.exports=function(e,t,r){var a=n(t);a in e?i.f(e,a,o(0,r)):e[a]=r}},7675:(e,t,r)=>{"use strict";var n=r(3103),i=r(266),o=r(4231),a=r(1805),s=r(6733),u=r(3723),l=r(7567),c=r(6540),p=r(4555),d=r(5762),f=r(7487),y=r(95),h=r(5495),m=r(693),g=a.PROPER,v=a.CONFIGURABLE,b=m.IteratorPrototype,I=m.BUGGY_SAFARI_ITERATORS,S=y("iterator"),_="keys",T="values",P="entries",A=function(){return this};e.exports=function(e,t,r,a,y,m,E){u(r,t,a);var w,O,D,x=function(e){if(e===y&&k)return k;if(!I&&e in N)return N[e];switch(e){case _:case T:case P:return function(){return new r(this,e)}}return function(){return new r(this)}},F=t+" Iterator",C=!1,N=e.prototype,M=N[S]||N["@@iterator"]||y&&N[y],k=!I&&M||x(y),R="Array"==t&&N.entries||M;if(R&&(w=l(R.call(new e)))!==Object.prototype&&w.next&&(o||l(w)===b||(c?c(w,b):s(w[S])||f(w,S,A)),p(w,F,!0,!0),o&&(h[F]=A)),g&&y==T&&M&&M.name!==T&&(!o&&v?d(N,"name",T):(C=!0,k=function(){return i(M,this)})),y)if(O={values:x(T),keys:m?k:x(_),entries:x(P)},E)for(D in O)(I||C||!(D in N))&&f(N,D,O[D]);else n({target:t,proto:!0,forced:I||C},O);return o&&!E||N[S]===k||f(N,S,k,{name:y}),h[t]=k,O}},7400:(e,t,r)=>{var n=r(4229);e.exports=!n((function(){return 7!=Object.defineProperty({},1,{get:function(){return 7}})[1]}))},2635:(e,t,r)=>{var n=r(9859),i=r(5052),o=n.document,a=i(o)&&i(o.createElement);e.exports=function(e){return a?o.createElement(e):{}}},8639:e=>{e.exports="object"==typeof window},8983:(e,t,r)=>{var n=r(598),i=r(9859);e.exports=/ipad|iphone|ipod/i.test(n)&&void 0!==i.Pebble},2023:(e,t,r)=>{var n=r(598);e.exports=/(?:ipad|iphone|ipod).*applewebkit/i.test(n)},8801:(e,t,r)=>{var n=r(7079),i=r(9859);e.exports="process"==n(i.process)},263:(e,t,r)=>{var n=r(598);e.exports=/web0s(?!.*chrome)/i.test(n)},598:(e,t,r)=>{var n=r(1333);e.exports=n("navigator","userAgent")||""},6358:(e,t,r)=>{var n,i,o=r(9859),a=r(598),s=o.process,u=o.Deno,l=s&&s.versions||u&&u.version,c=l&&l.v8;c&&(i=(n=c.split("."))[0]>0&&n[0]<4?1:+(n[0]+n[1])),!i&&a&&(!(n=a.match(/Edge\/(\d+)/))||n[1]>=74)&&(n=a.match(/Chrome\/(\d+)/))&&(i=+n[1]),e.exports=i},8791:(e,t,r)=>{var n=r(9859),i=r(5968);e.exports=function(e,t){return i(n[e].prototype[t])}},3837:e=>{e.exports=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"]},373:(e,t,r)=>{var n=r(4229),i=r(5358);e.exports=!n((function(){var e=Error("a");return!("stack"in e)||(Object.defineProperty(e,"stack",i(1,7)),7!==e.stack)}))},3103:(e,t,r)=>{var n=r(9859),i=r(7933).f,o=r(5762),a=r(7487),s=r(2079),u=r(7081),l=r(6541);e.exports=function(e,t){var r,c,p,d,f,y=e.target,h=e.global,m=e.stat;if(r=h?n:m?n[y]||s(y,{}):(n[y]||{}).prototype)for(c in t){if(d=t[c],p=e.noTargetGet?(f=i(r,c))&&f.value:r[c],!l(h?c:y+(m?".":"#")+c,e.forced)&&void 0!==p){if(typeof d==typeof p)continue;u(d,p)}(e.sham||p&&p.sham)&&o(d,"sham",!0),a(r,c,d,e)}}},4229:e=>{e.exports=function(e){try{return!!e()}catch(e){return!0}}},8476:(e,t,r)=>{var n=r(4229);e.exports=!n((function(){return Object.isExtensible(Object.preventExtensions({}))}))},3171:e=>{var t=Function.prototype,r=t.apply,n=t.bind,i=t.call;e.exports="object"==typeof Reflect&&Reflect.apply||(n?i.bind(r):function(){return i.apply(r,arguments)})},7636:(e,t,r)=>{var n=r(5968),i=r(7111),o=n(n.bind);e.exports=function(e,t){return i(e),void 0===t?e:o?o(e,t):function(){return e.apply(t,arguments)}}},266:e=>{var t=Function.prototype.call;e.exports=t.bind?t.bind(t):function(){return t.apply(t,arguments)}},1805:(e,t,r)=>{var n=r(7400),i=r(8270),o=Function.prototype,a=n&&Object.getOwnPropertyDescriptor,s=i(o,"name"),u=s&&"something"===function(){}.name,l=s&&(!n||n&&a(o,"name").configurable);e.exports={EXISTS:s,PROPER:u,CONFIGURABLE:l}},5968:e=>{var t=Function.prototype,r=t.bind,n=t.call,i=r&&r.bind(n);e.exports=r?function(e){return e&&i(n,e)}:function(e){return e&&function(){return n.apply(e,arguments)}}},1333:(e,t,r)=>{var n=r(9859),i=r(6733),o=function(e){return i(e)?e:void 0};e.exports=function(e,t){return arguments.length<2?o(n[e]):n[e]&&n[e][t]}},8830:(e,t,r)=>{var n=r(1589),i=r(5300),o=r(5495),a=r(95)("iterator");e.exports=function(e){if(null!=e)return i(e,a)||i(e,"@@iterator")||o[n(e)]}},8403:(e,t,r)=>{var n=r(9859),i=r(266),o=r(7111),a=r(1176),s=r(9821),u=r(8830),l=n.TypeError;e.exports=function(e,t){var r=arguments.length<2?u(e):t;if(o(r))return a(i(r,e));throw l(s(e)+" is not iterable")}},5300:(e,t,r)=>{var n=r(7111);e.exports=function(e,t){var r=e[t];return null==r?void 0:n(r)}},9859:(e,t,r)=>{var n=function(e){return e&&e.Math==Math&&e};e.exports=n("object"==typeof globalThis&&globalThis)||n("object"==typeof window&&window)||n("object"==typeof self&&self)||n("object"==typeof r.g&&r.g)||function(){return this}()||Function("return this")()},8270:(e,t,r)=>{var n=r(5968),i=r(2991),o=n({}.hasOwnProperty);e.exports=Object.hasOwn||function(e,t){return o(i(e),t)}},5977:e=>{e.exports={}},4665:(e,t,r)=>{var n=r(9859);e.exports=function(e,t){var r=n.console;r&&r.error&&(1==arguments.length?r.error(e):r.error(e,t))}},3777:(e,t,r)=>{var n=r(1333);e.exports=n("document","documentElement")},4394:(e,t,r)=>{var n=r(7400),i=r(4229),o=r(2635);e.exports=!n&&!i((function(){return 7!=Object.defineProperty(o("div"),"a",{get:function(){return 7}}).a}))},9337:(e,t,r)=>{var n=r(9859),i=r(5968),o=r(4229),a=r(7079),s=n.Object,u=i("".split);e.exports=o((function(){return!s("z").propertyIsEnumerable(0)}))?function(e){return"String"==a(e)?u(e,""):s(e)}:s},835:(e,t,r)=>{var n=r(6733),i=r(5052),o=r(6540);e.exports=function(e,t,r){var a,s;return o&&n(a=t.constructor)&&a!==r&&i(s=a.prototype)&&s!==r.prototype&&o(e,s),e}},8511:(e,t,r)=>{var n=r(5968),i=r(6733),o=r(5353),a=n(Function.toString);i(o.inspectSource)||(o.inspectSource=function(e){return a(e)}),e.exports=o.inspectSource},9679:(e,t,r)=>{var n=r(5052),i=r(5762);e.exports=function(e,t){n(t)&&"cause"in t&&i(e,"cause",t.cause)}},5926:(e,t,r)=>{var n=r(3103),i=r(5968),o=r(5977),a=r(5052),s=r(8270),u=r(1787).f,l=r(8151),c=r(166),p=r(1441),d=r(8476),f=!1,y=p("meta"),h=0,m=Object.isExtensible||function(){return!0},g=function(e){u(e,y,{value:{objectID:"O"+h++,weakData:{}}})},v=e.exports={enable:function(){v.enable=function(){},f=!0;var e=l.f,t=i([].splice),r={};r[y]=1,e(r).length&&(l.f=function(r){for(var n=e(r),i=0,o=n.length;i{var n,i,o,a=r(8694),s=r(9859),u=r(5968),l=r(5052),c=r(5762),p=r(8270),d=r(5353),f=r(4399),y=r(5977),h="Object already initialized",m=s.TypeError,g=s.WeakMap;if(a||d.state){var v=d.state||(d.state=new g),b=u(v.get),I=u(v.has),S=u(v.set);n=function(e,t){if(I(v,e))throw new m(h);return t.facade=e,S(v,e,t),t},i=function(e){return b(v,e)||{}},o=function(e){return I(v,e)}}else{var _=f("state");y[_]=!0,n=function(e,t){if(p(e,_))throw new m(h);return t.facade=e,c(e,_,t),t},i=function(e){return p(e,_)?e[_]:{}},o=function(e){return p(e,_)}}e.exports={set:n,get:i,has:o,enforce:function(e){return o(e)?i(e):n(e,{})},getterFor:function(e){return function(t){var r;if(!l(t)||(r=i(t)).type!==e)throw m("Incompatible receiver, "+e+" required");return r}}}},1943:(e,t,r)=>{var n=r(95),i=r(5495),o=n("iterator"),a=Array.prototype;e.exports=function(e){return void 0!==e&&(i.Array===e||a[o]===e)}},3718:(e,t,r)=>{var n=r(7079);e.exports=Array.isArray||function(e){return"Array"==n(e)}},6733:e=>{e.exports=function(e){return"function"==typeof e}},2359:(e,t,r)=>{var n=r(5968),i=r(4229),o=r(6733),a=r(1589),s=r(1333),u=r(8511),l=function(){},c=[],p=s("Reflect","construct"),d=/^\s*(?:class|function)\b/,f=n(d.exec),y=!d.exec(l),h=function(e){if(!o(e))return!1;try{return p(l,c,e),!0}catch(e){return!1}};e.exports=!p||i((function(){var e;return h(h.call)||!h(Object)||!h((function(){e=!0}))||e}))?function(e){if(!o(e))return!1;switch(a(e)){case"AsyncFunction":case"GeneratorFunction":case"AsyncGeneratorFunction":return!1}return y||!!f(d,u(e))}:h},6541:(e,t,r)=>{var n=r(4229),i=r(6733),o=/#|\.prototype\./,a=function(e,t){var r=u[s(e)];return r==c||r!=l&&(i(t)?n(t):!!t)},s=a.normalize=function(e){return String(e).replace(o,".").toLowerCase()},u=a.data={},l=a.NATIVE="N",c=a.POLYFILL="P";e.exports=a},2292:(e,t,r)=>{var n=r(5052),i=Math.floor;e.exports=Number.isInteger||function(e){return!n(e)&&isFinite(e)&&i(e)===e}},5052:(e,t,r)=>{var n=r(6733);e.exports=function(e){return"object"==typeof e?null!==e:n(e)}},4231:e=>{e.exports=!1},9395:(e,t,r)=>{var n=r(9859),i=r(1333),o=r(6733),a=r(1321),s=r(6969),u=n.Object;e.exports=s?function(e){return"symbol"==typeof e}:function(e){var t=i("Symbol");return o(t)&&a(t.prototype,u(e))}},9003:(e,t,r)=>{var n=r(9859),i=r(7636),o=r(266),a=r(1176),s=r(9821),u=r(1943),l=r(9646),c=r(1321),p=r(8403),d=r(8830),f=r(7281),y=n.TypeError,h=function(e,t){this.stopped=e,this.result=t},m=h.prototype;e.exports=function(e,t,r){var n,g,v,b,I,S,_,T=r&&r.that,P=!(!r||!r.AS_ENTRIES),A=!(!r||!r.IS_ITERATOR),E=!(!r||!r.INTERRUPTED),w=i(t,T),O=function(e){return n&&f(n,"normal",e),new h(!0,e)},D=function(e){return P?(a(e),E?w(e[0],e[1],O):w(e[0],e[1])):E?w(e,O):w(e)};if(A)n=e;else{if(!(g=d(e)))throw y(s(e)+" is not iterable");if(u(g)){for(v=0,b=l(e);b>v;v++)if((I=D(e[v]))&&c(m,I))return I;return new h(!1)}n=p(e,g)}for(S=n.next;!(_=o(S,n)).done;){try{I=D(_.value)}catch(e){f(n,"throw",e)}if("object"==typeof I&&I&&c(m,I))return I}return new h(!1)}},7281:(e,t,r)=>{var n=r(266),i=r(1176),o=r(5300);e.exports=function(e,t,r){var a,s;i(e);try{if(!(a=o(e,"return"))){if("throw"===t)throw r;return r}a=n(a,e)}catch(e){s=!0,a=e}if("throw"===t)throw r;if(s)throw a;return i(a),r}},693:(e,t,r)=>{"use strict";var n,i,o,a=r(4229),s=r(6733),u=r(7263),l=r(7567),c=r(7487),p=r(95),d=r(4231),f=p("iterator"),y=!1;[].keys&&("next"in(o=[].keys())?(i=l(l(o)))!==Object.prototype&&(n=i):y=!0),null==n||a((function(){var e={};return n[f].call(e)!==e}))?n={}:d&&(n=u(n)),s(n[f])||c(n,f,(function(){return this})),e.exports={IteratorPrototype:n,BUGGY_SAFARI_ITERATORS:y}},5495:e=>{e.exports={}},9646:(e,t,r)=>{var n=r(4237);e.exports=function(e){return n(e.length)}},4794:(e,t,r)=>{var n,i,o,a,s,u,l,c,p=r(9859),d=r(7636),f=r(7933).f,y=r(5795).set,h=r(2023),m=r(8983),g=r(263),v=r(8801),b=p.MutationObserver||p.WebKitMutationObserver,I=p.document,S=p.process,_=p.Promise,T=f(p,"queueMicrotask"),P=T&&T.value;P||(n=function(){var e,t;for(v&&(e=S.domain)&&e.exit();i;){t=i.fn,i=i.next;try{t()}catch(e){throw i?a():o=void 0,e}}o=void 0,e&&e.enter()},h||v||g||!b||!I?!m&&_&&_.resolve?((l=_.resolve(void 0)).constructor=_,c=d(l.then,l),a=function(){c(n)}):v?a=function(){S.nextTick(n)}:(y=d(y,p),a=function(){y(n)}):(s=!0,u=I.createTextNode(""),new b(n).observe(u,{characterData:!0}),a=function(){u.data=s=!s})),e.exports=P||function(e){var t={fn:e,next:void 0};o&&(o.next=t),i||(i=t,a()),o=t}},4226:(e,t,r)=>{var n=r(9859);e.exports=n.Promise},3839:(e,t,r)=>{var n=r(6358),i=r(4229);e.exports=!!Object.getOwnPropertySymbols&&!i((function(){var e=Symbol();return!String(e)||!(Object(e)instanceof Symbol)||!Symbol.sham&&n&&n<41}))},8694:(e,t,r)=>{var n=r(9859),i=r(6733),o=r(8511),a=n.WeakMap;e.exports=i(a)&&/native code/.test(o(a))},6485:(e,t,r)=>{"use strict";var n=r(7111),i=function(e){var t,r;this.promise=new e((function(e,n){if(void 0!==t||void 0!==r)throw TypeError("Bad Promise constructor");t=e,r=n})),this.resolve=n(t),this.reject=n(r)};e.exports.f=function(e){return new i(e)}},635:(e,t,r)=>{var n=r(3326);e.exports=function(e,t){return void 0===e?arguments.length<2?"":t:n(e)}},5496:(e,t,r)=>{var n=r(9859),i=r(4229),o=r(5968),a=r(3326),s=r(1017).trim,u=r(1647),l=o("".charAt),c=n.parseFloat,p=n.Symbol,d=p&&p.iterator,f=1/c(u+"-0")!=-1/0||d&&!i((function(){c(Object(d))}));e.exports=f?function(e){var t=s(a(e)),r=c(t);return 0===r&&"-"==l(t,0)?-0:r}:c},6596:(e,t,r)=>{var n=r(9859),i=r(4229),o=r(5968),a=r(3326),s=r(1017).trim,u=r(1647),l=n.parseInt,c=n.Symbol,p=c&&c.iterator,d=/^[+-]?0x/i,f=o(d.exec),y=8!==l(u+"08")||22!==l(u+"0x16")||p&&!i((function(){l(Object(p))}));e.exports=y?function(e,t){var r=s(a(e));return l(r,t>>>0||(f(d,r)?16:10))}:l},7888:(e,t,r)=>{"use strict";var n=r(7400),i=r(5968),o=r(266),a=r(4229),s=r(5632),u=r(894),l=r(9195),c=r(2991),p=r(9337),d=Object.assign,f=Object.defineProperty,y=i([].concat);e.exports=!d||a((function(){if(n&&1!==d({b:1},d(f({},"a",{enumerable:!0,get:function(){f(this,"b",{value:3,enumerable:!1})}}),{b:2})).b)return!0;var e={},t={},r=Symbol(),i="abcdefghijklmnopqrst";return e[r]=7,i.split("").forEach((function(e){t[e]=e})),7!=d({},e)[r]||s(d({},t)).join("")!=i}))?function(e,t){for(var r=c(e),i=arguments.length,a=1,d=u.f,f=l.f;i>a;)for(var h,m=p(arguments[a++]),g=d?y(s(m),d(m)):s(m),v=g.length,b=0;v>b;)h=g[b++],n&&!o(f,m,h)||(r[h]=m[h]);return r}:d},7263:(e,t,r)=>{var n,i=r(1176),o=r(219),a=r(3837),s=r(5977),u=r(3777),l=r(2635),c=r(4399)("IE_PROTO"),p=function(){},d=function(e){return"