diff --git a/bower.json b/bower.json
index 3607de4d8f0..6c5a0a5831f 100644
--- a/bower.json
+++ b/bower.json
@@ -21,6 +21,7 @@
"angular-native-dragdrop": "~1.1.0",
"angular-bindonce": "~0.3.3",
"requirejs": "~2.1.18",
- "requirejs-text": "~2.0.14"
+ "requirejs-text": "~2.0.14",
+ "aws-sdk": "~2.1.42"
}
}
diff --git a/public/app/components/require.config.js b/public/app/components/require.config.js
index 12a72dd42e3..36b94b2b7ff 100644
--- a/public/app/components/require.config.js
+++ b/public/app/components/require.config.js
@@ -44,6 +44,7 @@ require.config({
modernizr: '../vendor/modernizr-2.6.1',
'bootstrap-tagsinput': '../vendor/tagsinput/bootstrap-tagsinput',
+ 'aws-sdk': '../vendor/aws-sdk/dist/aws-sdk.min',
},
shim: {
diff --git a/public/app/plugins/datasource/cloudwatch/datasource.js b/public/app/plugins/datasource/cloudwatch/datasource.js
new file mode 100644
index 00000000000..b5709e8935f
--- /dev/null
+++ b/public/app/plugins/datasource/cloudwatch/datasource.js
@@ -0,0 +1,154 @@
+/* global AWS */
+define([
+ 'angular',
+ 'lodash',
+ 'kbn',
+ 'moment',
+ './queryCtrl',
+ 'aws-sdk',
+],
+function (angular, _, kbn) {
+ 'use strict';
+
+ var module = angular.module('grafana.services');
+
+ module.factory('CloudWatchDatasource', function($q, $http, templateSrv) {
+
+ function CloudWatchDatasource(datasource) {
+ this.type = 'cloudwatch';
+ this.name = datasource.name;
+ this.supportMetrics = true;
+
+ AWS.config.update({ region: datasource.jsonData.region });
+ this.cloudwatch = new AWS.CloudWatch({
+ accessKeyId: datasource.jsonData.accessKeyId,
+ secretAccessKey: datasource.jsonData.secretAccessKey,
+ });
+ }
+
+ // Called once per panel (graph)
+ CloudWatchDatasource.prototype.query = function(options) {
+ var start = convertToCloudWatchTime(options.range.from);
+ var end = convertToCloudWatchTime(options.range.to);
+
+ var queries = [];
+ _.each(options.targets, _.bind(function(target) {
+ if (!target.namespace || !target.metricName || _.isEmpty(target.dimensions) || _.isEmpty(target.statistics)) {
+ return;
+ }
+
+ var query = {};
+ query.namespace = templateSrv.replace(target.namespace, options.scopedVars);
+ query.metricName = templateSrv.replace(target.metricName, options.scopedVars);
+ query.dimensions = _.map(_.keys(target.dimensions), function(key) {
+ return {
+ Name: key,
+ Value: target.dimensions[key]
+ };
+ });
+ query.statistics = _.keys(target.statistics);
+ query.period = target.period;
+
+ var range = (end.getTime() - start.getTime()) / 1000;
+ // CloudWatch limit datapoints up to 1440
+ if (range / query.period >= 1440) {
+ query.period = Math.floor(range / 1440 / 60) * 60;
+ }
+
+ queries.push(query);
+ }, this));
+
+ // No valid targets, return the empty result to save a round trip.
+ if (_.isEmpty(queries)) {
+ var d = $q.defer();
+ d.resolve({ data: [] });
+ return d.promise;
+ }
+
+ var allQueryPromise = _.map(queries, _.bind(function(query) {
+ return this.performTimeSeriesQuery(query, start, end);
+ }, this));
+
+ return $q.all(allQueryPromise)
+ .then(function(allResponse) {
+ var result = [];
+
+ _.each(allResponse, function(response, index) {
+ var metrics = transformMetricData(response, options.targets[index]);
+ _.each(metrics, function(m) {
+ result.push(m);
+ });
+ });
+
+ return { data: result };
+ });
+ };
+
+ CloudWatchDatasource.prototype.performTimeSeriesQuery = function(query, start, end) {
+ var params = {
+ Namespace: query.namespace,
+ MetricName: query.metricName,
+ Dimensions: query.dimensions,
+ Statistics: query.statistics,
+ StartTime: start,
+ EndTime: end,
+ Period: query.period
+ };
+
+ var d = $q.defer();
+ this.cloudwatch.getMetricStatistics(params, function(err, data) {
+ if (err) {
+ return d.reject(err);
+ }
+ return d.resolve(data);
+ });
+
+ return d.promise;
+ };
+
+ CloudWatchDatasource.prototype.performSuggestQuery = function(params) {
+ var d = $q.defer();
+
+ this.cloudwatch.listMetrics(params, function(err, data) {
+ if (err) {
+ return d.reject(err);
+ }
+
+ return d.resolve(data);
+ });
+
+ return d.promise;
+ };
+
+ CloudWatchDatasource.prototype.testDatasource = function() {
+ return this.performSuggestQuery({}).then(function () {
+ return { status: 'success', message: 'Data source is working', title: 'Success' };
+ });
+ };
+
+ function transformMetricData(md, options) {
+ var result = [];
+
+ var dimensionPart = JSON.stringify(options.dimensions);
+ _.each(_.keys(options.statistics), function(s) {
+ var metricLabel = md.Label + '_' + s + dimensionPart;
+
+ var dps = _.map(md.Datapoints, function(value) {
+ return [value[s], new Date(value.Timestamp).getTime()];
+ });
+ dps = _.sortBy(dps, function(dp) { return dp[1]; });
+
+ result.push({ target: metricLabel, datapoints: dps });
+ });
+
+ return result;
+ }
+
+ function convertToCloudWatchTime(date) {
+ return kbn.parseDate(date);
+ }
+
+ return CloudWatchDatasource;
+ });
+
+});
diff --git a/public/app/plugins/datasource/cloudwatch/partials/config.html b/public/app/plugins/datasource/cloudwatch/partials/config.html
new file mode 100644
index 00000000000..9cfcb2f4909
--- /dev/null
+++ b/public/app/plugins/datasource/cloudwatch/partials/config.html
@@ -0,0 +1,30 @@
+CloudWatch details
+
+
+
diff --git a/public/app/plugins/datasource/cloudwatch/partials/query.editor.html b/public/app/plugins/datasource/cloudwatch/partials/query.editor.html
new file mode 100644
index 00000000000..53a78895ba8
--- /dev/null
+++ b/public/app/plugins/datasource/cloudwatch/partials/query.editor.html
@@ -0,0 +1,212 @@
+
diff --git a/public/app/plugins/datasource/cloudwatch/plugin.json b/public/app/plugins/datasource/cloudwatch/plugin.json
new file mode 100644
index 00000000000..906764c7b44
--- /dev/null
+++ b/public/app/plugins/datasource/cloudwatch/plugin.json
@@ -0,0 +1,16 @@
+{
+ "pluginType": "datasource",
+ "name": "CloudWatch",
+
+ "type": "cloudwatch",
+ "serviceName": "CloudWatchDatasource",
+
+ "module": "plugins/datasource/cloudwatch/datasource",
+
+ "partials": {
+ "config": "app/plugins/datasource/cloudwatch/partials/config.html",
+ "query": "app/plugins/datasource/cloudwatch/partials/query.editor.html"
+ },
+
+ "metrics": true
+}
diff --git a/public/app/plugins/datasource/cloudwatch/queryCtrl.js b/public/app/plugins/datasource/cloudwatch/queryCtrl.js
new file mode 100644
index 00000000000..dce56f16d94
--- /dev/null
+++ b/public/app/plugins/datasource/cloudwatch/queryCtrl.js
@@ -0,0 +1,271 @@
+define([
+ 'angular',
+ 'lodash',
+ 'kbn',
+],
+function (angular, _, kbn) {
+ 'use strict';
+
+ var module = angular.module('grafana.controllers');
+
+ var supportedMetrics = {
+ "AWS/AutoScaling": [
+ "GroupMinSize", "GroupMaxSize", "GroupDesiredCapacity", "GroupInServiceInstances", "GroupPendingInstances", "GroupStandbyInstances", "GroupTerminatingInstances", "GroupTotalInstances"
+ ],
+ "AWS/Billing": [
+ "EstimatedCharges"
+ ],
+ "AWS/CloudFront": [
+ "Requests", "BytesDownloaded", "BytesUploaded", "TotalErrorRate", "4xxErrorRate", "5xxErrorRate"
+ ],
+ "AWS/CloudSearch": [
+ "SuccessfulRequests", "SearchableDocuments", "IndexUtilization", "Partitions"
+ ],
+ "AWS/DynamoDB": [
+ "ConditionalCheckFailedRequests", "ConsumedReadCapacityUnits", "ConsumedWriteCapacityUnits", "OnlineIndexConsumedWriteCapacity", "OnlineIndexPercentageProgress", "OnlineIndexThrottleEvents", "ProvisionedReadCapacityUnits", "ProvisionedWriteCapacityUnits", "ReadThrottleEvents", "ReturnedItemCount", "SuccessfulRequestLatency", "SystemErrors", "ThrottledRequests", "UserErrors", "WriteThrottleEvents"
+ ],
+ "AWS/ElastiCache": [
+ "CPUUtilization", "SwapUsage", "FreeableMemory", "NetworkBytesIn", "NetworkBytesOut",
+ "BytesUsedForCacheItems", "BytesReadIntoMemcached", "BytesWrittenOutFromMemcached", "CasBadval", "CasHits", "CasMisses", "CmdFlush", "CmdGet", "CmdSet", "CurrConnections", "CurrItems", "DecrHits", "DecrMisses", "DeleteHits", "DeleteMisses", "Evictions", "GetHits", "GetMisses", "IncrHits", "IncrMisses", "Reclaimed",
+ "CurrConnections", "Evictions", "Reclaimed", "NewConnections", "BytesUsedForCache", "CacheHits", "CacheMisses", "ReplicationLag", "GetTypeCmds", "SetTypeCmds", "KeyBasedCmds", "StringBasedCmds", "HashBasedCmds", "ListBasedCmds", "SetBasedCmds", "SortedSetBasedCmds", "CurrItems"
+ ],
+ "AWS/EBS": [
+ "VolumeReadBytes", "VolumeWriteBytes", "VolumeReadOps", "VolumeWriteOps", "VolumeTotalReadTime", "VolumeTotalWriteTime", "VolumeIdleTime", "VolumeQueueLength", "VolumeThroughputPercentage", "VolumeConsumedReadWriteOps",
+ ],
+ "AWS/EC2": [
+ "CPUCreditUsage", "CPUCreditBalance", "CPUUtilization", "DiskReadOps", "DiskWriteOps", "DiskReadBytes", "DiskWriteBytes", "NetworkIn", "NetworkOut", "StatusCheckFailed", "StatusCheckFailed_Instance", "StatusCheckFailed_System"
+ ],
+ "AWS/ELB": [
+ "HealthyHostCount", "UnHealthyHostCount", "RequestCount", "Latency", "HTTPCode_ELB_4XX", "HTTPCode_ELB_5XX", "HTTPCode_Backend_2XX", "HTTPCode_Backend_3XX", "HTTPCode_Backend_4XX", "HTTPCode_Backend_5XX", "BackendConnectionErrors", "SurgeQueueLength", "SpilloverCount"
+ ],
+ "AWS/ElasticMapReduce": [
+ "CoreNodesPending", "CoreNodesRunning", "HBaseBackupFailed", "HBaseMostRecentBackupDuration", "HBaseTimeSinceLastSuccessfulBackup", "HDFSBytesRead", "HDFSBytesWritten", "HDFSUtilization", "IsIdle", "JobsFailed", "JobsRunning", "LiveDataNodes", "LiveTaskTrackers", "MapSlotsOpen", "MissingBlocks", "ReduceSlotsOpen", "RemainingMapTasks", "RemainingMapTasksPerSlot", "RemainingReduceTasks", "RunningMapTasks", "RunningReduceTasks", "S3BytesRead", "S3BytesWritten", "TaskNodesPending", "TaskNodesRunning", "TotalLoad"
+ ],
+ "AWS/Kinesis": [
+ "PutRecord.Bytes", "PutRecord.Latency", "PutRecord.Success", "PutRecords.Bytes", "PutRecords.Latency", "PutRecords.Records", "PutRecords.Success", "IncomingBytes", "IncomingRecords", "GetRecords.Bytes", "GetRecords.IteratorAgeMilliseconds", "GetRecords.Latency", "GetRecords.Success"
+ ],
+ "AWS/ML": [
+ "PredictCount", "PredictFailureCount"
+ ],
+ "AWS/OpsWorks": [
+ "cpu_idle", "cpu_nice", "cpu_system", "cpu_user", "cpu_waitio", "load_1", "load_5", "load_15", "memory_buffers", "memory_cached", "memory_free", "memory_swap", "memory_total", "memory_used", "procs"
+ ],
+ "AWS/Redshift": [
+ "CPUUtilization", "DatabaseConnections", "HealthStatus", "MaintenanceMode", "NetworkReceiveThroughput", "NetworkTransmitThroughput", "PercentageDiskSpaceUsed", "ReadIOPS", "ReadLatency", "ReadThroughput", "WriteIOPS", "WriteLatency", "WriteThroughput"
+ ],
+ "AWS/RDS": [
+ "BinLogDiskUsage", "CPUUtilization", "DatabaseConnections", "DiskQueueDepth", "FreeableMemory", "FreeStorageSpace", "ReplicaLag", "SwapUsage", "ReadIOPS", "WriteIOPS", "ReadLatency", "WriteLatency", "ReadThroughput", "WriteThroughput", "NetworkReceiveThroughput", "NetworkTransmitThroughput"
+ ],
+ "AWS/Route53": [
+ "HealthCheckStatus", "HealthCheckPercentageHealthy"
+ ],
+ "AWS/SNS": [
+ "NumberOfMessagesPublished", "PublishSize", "NumberOfNotificationsDelivered", "NumberOfNotificationsFailed"
+ ],
+ "AWS/SQS": [
+ "NumberOfMessagesSent", "SentMessageSize", "NumberOfMessagesReceived", "NumberOfEmptyReceives", "NumberOfMessagesDeleted", "ApproximateNumberOfMessagesDelayed", "ApproximateNumberOfMessagesVisible", "ApproximateNumberOfMessagesNotVisible"
+ ],
+ "AWS/S3": [
+ "BucketSizeBytes", "NumberOfObjects"
+ ],
+ "AWS/SWF": [
+ "DecisionTaskScheduleToStartTime", "DecisionTaskStartToCloseTime", "DecisionTasksCompleted", "StartedDecisionTasksTimedOutOnClose", "WorkflowStartToCloseTime", "WorkflowsCanceled", "WorkflowsCompleted", "WorkflowsContinuedAsNew", "WorkflowsFailed", "WorkflowsTerminated", "WorkflowsTimedOut"
+ ],
+ "AWS/StorageGateway": [
+ "CacheHitPercent", "CachePercentUsed", "CachePercentDirty", "CloudBytesDownloaded", "CloudDownloadLatency", "CloudBytesUploaded", "UploadBufferFree", "UploadBufferPercentUsed", "UploadBufferUsed", "QueuedWrites", "ReadBytes", "ReadTime", "TotalCacheSize", "WriteBytes", "WriteTime", "WorkingStorageFree", "WorkingStoragePercentUsed", "WorkingStorageUsed", "CacheHitPercent", "CachePercentUsed", "CachePercentDirty", "ReadBytes", "ReadTime", "WriteBytes", "WriteTime", "QueuedWrites"
+ ],
+ "AWS/WorkSpaces": [
+ "Available", "Unhealthy", "ConnectionAttempt", "ConnectionSuccess", "ConnectionFailure", "SessionLaunchTime", "InSessionLatency", "SessionDisconnect"
+ ],
+ };
+
+ var supportedDimensions = {
+ "AWS/AutoScaling": [
+ "AutoScalingGroupName"
+ ],
+ "AWS/Billing": [
+ "ServiceName", "LinkedAccount", "Currency"
+ ],
+ "AWS/CloudFront": [
+ "DistributionId", "Region"
+ ],
+ "AWS/CloudSearch": [
+
+ ],
+ "AWS/DynamoDB": [
+ "TableName", "GlobalSecondaryIndexName", "Operation"
+ ],
+ "AWS/ElastiCache": [
+ "CacheClusterId", "CacheNodeId"
+ ],
+ "AWS/EBS": [
+ "VolumeId"
+ ],
+ "AWS/EC2": [
+ "AutoScalingGroupName", "ImageId", "InstanceId", "InstanceType"
+ ],
+ "AWS/ELB": [
+ "LoadBalancerName", "AvailabilityZone"
+ ],
+ "AWS/ElasticMapReduce": [
+ "ClusterId", "JobId"
+ ],
+ "AWS/Kinesis": [
+ "StreamName"
+ ],
+ "AWS/ML": [
+ "MLModelId", "RequestMode"
+ ],
+ "AWS/OpsWorks": [
+ "StackId", "LayerId", "InstanceId"
+ ],
+ "AWS/Redshift": [
+ "NodeID", "ClusterIdentifier"
+ ],
+ "AWS/RDS": [
+ "DBInstanceIdentifier", "DatabaseClass", "EngineName"
+ ],
+ "AWS/Route53": [
+ "HealthCheckId"
+ ],
+ "AWS/SNS": [
+ "Application", "Platform", "TopicName"
+ ],
+ "AWS/SQS": [
+ "QueueName"
+ ],
+ "AWS/S3": [
+ "BucketName", "StorageType"
+ ],
+ "AWS/SWF": [
+ "Domain", "ActivityTypeName", "ActivityTypeVersion"
+ ],
+ "AWS/StorageGateway": [
+ "GatewayId", "GatewayName", "VolumeId"
+ ],
+ "AWS/WorkSpaces": [
+ "DirectoryId", "WorkspaceId"
+ ],
+ };
+
+ module.controller('CloudWatchQueryCtrl', function($scope) {
+
+ $scope.init = function() {
+ $scope.target.namespace = $scope.target.namespace || '';
+ $scope.target.metricName = $scope.target.metricName || '';
+ $scope.target.dimensions = $scope.target.dimensions || {};
+ $scope.target.statistics = $scope.target.statistics || {};
+ $scope.target.period = $scope.target.period || 60;
+
+ $scope.target.errors = validateTarget();
+ };
+
+ $scope.refreshMetricData = function() {
+ $scope.target.errors = validateTarget($scope.target);
+
+ // this does not work so good
+ if (!_.isEqual($scope.oldTarget, $scope.target) && _.isEmpty($scope.target.errors)) {
+ $scope.oldTarget = angular.copy($scope.target);
+ $scope.get_data();
+ }
+ };
+
+ $scope.moveMetricQuery = function(fromIndex, toIndex) {
+ _.move($scope.panel.targets, fromIndex, toIndex);
+ };
+
+ $scope.duplicate = function() {
+ var clone = angular.copy($scope.target);
+ $scope.panel.targets.push(clone);
+ };
+
+ $scope.suggestNamespace = function(query, callback) {
+ return _.keys(supportedMetrics);
+ };
+
+ $scope.suggestMetrics = function(query, callback) {
+ return supportedMetrics[$scope.target.namespace] || [];
+ };
+
+ $scope.suggestDimensionKeys = function(query, callback) {
+ return supportedDimensions[$scope.target.namespace] || [];
+ };
+
+ $scope.suggestDimensionValues = function(query, callback) {
+ if (!$scope.target.namespace || !$scope.target.metricName) {
+ return callback([]);
+ }
+
+ var params = {
+ Namespace: $scope.target.namespace,
+ MetricName: $scope.target.metricName
+ };
+ if (!_.isEmpty($scope.target.dimensions)) {
+ params.Dimensions = $scope.target.dimensions;
+ }
+
+ $scope.datasource
+ .performSuggestQuery(params)
+ .then(function(result) {
+ var suggestData = _.chain(result.Metrics)
+ .map(function(metric) {
+ return metric.Dimensions;
+ })
+ .flatten(true)
+ .filter(function(dimension) {
+ return dimension.Name === $scope.target.currentDimensionKey;
+ })
+ .map(function(metric) {
+ return metric;
+ })
+ .pluck('Value')
+ .uniq()
+ .value();
+
+ callback(suggestData);
+ }, function() {
+ callback([]);
+ });
+ };
+
+ $scope.addDimension = function() {
+ if (!$scope.addDimensionMode) {
+ $scope.addDimensionMode = true;
+ return;
+ }
+
+ if (!$scope.target.dimensions) {
+ $scope.target.dimensions = {};
+ }
+
+ $scope.target.dimensions[$scope.target.currentDimensionKey] = $scope.target.currentDimensionValue;
+ $scope.target.currentDimensionKey = '';
+ $scope.target.currentDimensionValue = '';
+ $scope.refreshMetricData();
+
+ $scope.addDimensionMode = false;
+ };
+
+ $scope.removeDimension = function(key) {
+ delete $scope.target.dimensions[key];
+ $scope.refreshMetricData();
+ };
+
+ $scope.statisticsOptionChanged = function() {
+ $scope.refreshMetricData();
+ };
+
+ // TODO: validate target
+ function validateTarget() {
+ var errs = {};
+
+ if ($scope.target.period < 60 || ($scope.target.period % 60) !== 0) {
+ errs.period = 'Period must be at least 60 seconds and must be a multiple of 60';
+ }
+
+ return errs;
+ }
+
+ });
+
+});
diff --git a/public/vendor/aws-sdk/.bower.json b/public/vendor/aws-sdk/.bower.json
new file mode 100644
index 00000000000..bb0b777e832
--- /dev/null
+++ b/public/vendor/aws-sdk/.bower.json
@@ -0,0 +1,33 @@
+{
+ "name": "aws-sdk",
+ "ignore": [
+ "apis",
+ "doc-src",
+ "dist-tools",
+ "eslint-rules",
+ "features",
+ "lib",
+ "scripts",
+ "tasks",
+ "test",
+ "Gemfile*",
+ "configuration*",
+ "Rakefile",
+ "package.json",
+ "testem.json",
+ ".*",
+ "index.js"
+ ],
+ "main": "dist/aws-sdk.js",
+ "homepage": "https://github.com/aws/aws-sdk-js",
+ "version": "2.1.42",
+ "_release": "2.1.42",
+ "_resolution": {
+ "type": "version",
+ "tag": "v2.1.42",
+ "commit": "6ad65d3e09a3a4531c84d12b980e6fb9af136a0a"
+ },
+ "_source": "git://github.com/aws/aws-sdk-js.git",
+ "_target": "~2.1.41",
+ "_originalSource": "aws-sdk"
+}
\ No newline at end of file
diff --git a/public/vendor/aws-sdk/CONTRIBUTING.md b/public/vendor/aws-sdk/CONTRIBUTING.md
new file mode 100644
index 00000000000..79cbc7ee694
--- /dev/null
+++ b/public/vendor/aws-sdk/CONTRIBUTING.md
@@ -0,0 +1,84 @@
+# Contributing to the AWS SDK for JavaScript
+
+We work hard to provide a high-quality and useful SDK, and we greatly value
+feedback and contributions from our community. Whether it's a bug report,
+new feature, correction, or additional documentation, we welcome your issues
+and pull requests. Please read through this document before submitting any
+issues or pull requests to ensure we have all the necessary information to
+effectively respond to your bug report or contribution.
+
+
+## Filing Bug Reports
+
+You can file bug reports against the SDK on the [GitHub issues][issues] page.
+
+If you are filing a report for a bug or regression in the SDK, it's extremely
+helpful to provide as much information as possible when opening the original
+issue. This helps us reproduce and investigate the possible bug without having
+to wait for this extra information to be provided. Please read the following
+guidelines prior to filing a bug report.
+
+1. Search through existing [issues][] to ensure that your specific issue has
+ not yet been reported. If it is a common issue, it is likely there is
+ already a bug report for your problem.
+
+2. Ensure that you have tested the latest version of the SDK. Although you
+ may have an issue against an older version of the SDK, we cannot provide
+ bug fixes for old versions. It's also possible that the bug may have been
+ fixed in the latest release.
+
+3. Provide as much information about your environment, SDK version, and
+ relevant dependencies as possible. For example, let us know what version
+ of Node.js you are using, or if it's a browser issue, which browser you
+ are using. If the issue only occurs with a specific dependency loaded,
+ please provide that dependency name and version.
+
+4. Provide a minimal test case that reproduces your issue or any error
+ information you related to your problem. We can provide feedback much
+ more quickly if we know what operations you are calling in the SDK. If
+ you cannot provide a full test case, provide as much code as you can
+ to help us diagnose the problem. Any relevant information should be provided
+ as well, like whether this is a persistent issue, or if it only occurs
+ some of the time.
+
+
+## Submitting Pull Requests
+
+We are always happy to receive code and documentation contributions to the SDK.
+Please be aware of the following notes prior to opening a pull request:
+
+1. The SDK is released under the [Apache license][license]. Any code you submit
+ will be released under that license. For substantial contributions, we may
+ ask you to sign a [Contributor License Agreement (CLA)][cla].
+
+2. If you would like to implement support for a significant feature that is not
+ yet available in the SDK, please talk to us beforehand to avoid any
+ duplication of effort.
+
+### Testing
+
+To run the tests locally, install `phantomjs`. You can do so using [Homebrew][homebrew]:
+
+```
+brew install phantomjs
+```
+
+Then, to run all tests:
+
+```
+npm test
+```
+
+To run a particular test subset e.g. just the unit tests:
+
+```
+npm run-script unit
+```
+
+See the implementation of the `test` script in `package.json` for more options.
+
+[issues]: https://github.com/aws/aws-sdk-js/issues
+[pr]: https://github.com/aws/aws-sdk-js/pulls
+[license]: http://aws.amazon.com/apache2.0/
+[cla]: http://en.wikipedia.org/wiki/Contributor_License_Agreement
+[homebrew]: http://brew.sh/
diff --git a/public/vendor/aws-sdk/LICENSE.txt b/public/vendor/aws-sdk/LICENSE.txt
new file mode 100644
index 00000000000..feaf8659d62
--- /dev/null
+++ b/public/vendor/aws-sdk/LICENSE.txt
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+Copyright 2012-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/public/vendor/aws-sdk/NOTICE.txt b/public/vendor/aws-sdk/NOTICE.txt
new file mode 100644
index 00000000000..23fd6f0c984
--- /dev/null
+++ b/public/vendor/aws-sdk/NOTICE.txt
@@ -0,0 +1,5 @@
+AWS SDK for JavaScript
+Copyright 2012-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+This product includes software developed at
+Amazon Web Services, Inc. (http://aws.amazon.com/).
diff --git a/public/vendor/aws-sdk/README.md b/public/vendor/aws-sdk/README.md
new file mode 100644
index 00000000000..852efa5e73b
--- /dev/null
+++ b/public/vendor/aws-sdk/README.md
@@ -0,0 +1,124 @@
+# AWS SDK for JavaScript
+
+[](https://nodei.co/npm/aws-sdk/)
+
+[](https://gitter.im/aws/aws-sdk-js)
+
+[](http://badge.fury.io/js/aws-sdk) [](https://travis-ci.org/aws/aws-sdk-js) [](https://coveralls.io/r/aws/aws-sdk-js?branch=master)
+
+The official AWS SDK for JavaScript, available for browsers and mobile devices,
+or Node.js backends
+
+Release notes can be found at http://aws.amazon.com/releasenotes/SDK/JavaScript
+
+
+If you are upgrading from 1.x to 2.0 of the SDK, please see
+the {file:UPGRADING.md} notes for information on how to migrate existing code
+to work with the new major version.
+
+
+## Installing
+
+### In the Browser
+
+To use the SDK in the browser, simply add the following script tag to your
+HTML pages:
+
+
+
+The AWS SDK is also compatible with [browserify](http://browserify.org).
+
+### In Node.js
+
+The preferred way to install the AWS SDK for Node.js is to use the
+[npm](http://npmjs.org) package manager for Node.js. Simply type the following
+into a terminal window:
+
+```sh
+npm install aws-sdk
+```
+
+### Using Bower
+
+You can also use [Bower](http://bower.io) to install the SDK by typing the
+following into a terminal window:
+
+```sh
+bower install aws-sdk-js
+```
+
+## Usage and Getting Started
+
+You can find a getting started guide at:
+
+http://docs.aws.amazon.com/AWSJavaScriptSDK/guide/
+
+## Supported Services
+
+Note:
+Although all services are supported in the browser version of the SDK,
+not all of the services are available in the default hosted build (using the
+script tag provided above). A list of services in the hosted build are provided
+in the "Working With Services"
+section of the browser SDK guide, including instructions on how to build a
+custom version of the SDK with extra services.
+
+
+The SDK currently supports the following services:
+
+
+
+ | Service Name |
+ Class Name |
+ API Version |
+
+
+ | Amazon CloudFront | AWS.CloudFront | 2014-10-21 |
+ | Amazon CloudSearch | AWS.CloudSearch | 2013-01-01 |
+ | Amazon CloudSearch Domain | AWS.CloudSearchDomain | 2013-01-01 |
+ | Amazon CloudWatch | AWS.CloudWatch | 2010-08-01 |
+ | Amazon CloudWatch Logs | AWS.CloudWatchLogs | 2014-03-28 |
+ | Amazon Cognito Identity | AWS.CognitoIdentity | 2014-06-30 |
+ | Amazon Cognito Sync | AWS.CognitoSync | 2014-06-30 |
+ | Amazon DynamoDB | AWS.DynamoDB | 2012-08-10 |
+ | Amazon Elastic Compute Cloud | AWS.EC2 | 2014-10-01 |
+ | Amazon Elastic MapReduce | AWS.EMR | 2009-03-31 |
+ | Amazon Elastic Transcoder | AWS.ElasticTranscoder | 2012-09-25 |
+ | Amazon ElastiCache | AWS.ElastiCache | 2014-09-30 |
+ | Amazon Glacier | AWS.Glacier | 2012-06-01 |
+ | Amazon Kinesis | AWS.Kinesis | 2013-12-02 |
+ | Amazon Redshift | AWS.Redshift | 2012-12-01 |
+ | Amazon Relational Database Service | AWS.RDS | 2014-09-01 |
+ | Amazon Route 53 | AWS.Route53 | 2013-04-01 |
+ | Amazon Route 53 Domains | AWS.Route53Domains | 2014-05-15 |
+ | Amazon Simple Email Service | AWS.SES | 2010-12-01 |
+ | Amazon Simple Notification Service | AWS.SNS | 2010-03-31 |
+ | Amazon Simple Queue Service | AWS.SQS | 2012-11-05 |
+ | Amazon Simple Storage Service | AWS.S3 | 2006-03-01 |
+ | Amazon Simple Workflow Service | AWS.SWF | 2012-01-25 |
+ | Amazon SimpleDB | AWS.SimpleDB | 2009-04-15 |
+ | Auto Scaling | AWS.AutoScaling | 2011-01-01 |
+ | AWS CloudFormation | AWS.CloudFormation | 2010-05-15 |
+ | AWS CloudTrail | AWS.CloudTrail | 2013-11-01 |
+ | AWS CodeDeploy | AWS.CodeDeploy | 2014-10-06 |
+ | AWS Config | AWS.ConfigService | 2014-11-12 |
+ | AWS Data Pipeline | AWS.DataPipeline | 2012-10-29 |
+ | AWS Direct Connect | AWS.DirectConnect | 2012-10-25 |
+ | AWS Elastic Beanstalk | AWS.ElasticBeanstalk | 2010-12-01 |
+ | AWS Identity and Access Management | AWS.IAM | 2010-05-08 |
+ | AWS Import/Export | AWS.ImportExport | 2010-06-01 |
+ | AWS Key Management Service | AWS.KMS | 2014-11-01 |
+ | AWS Lambda | AWS.Lambda | 2014-11-11 |
+ | AWS OpsWorks | AWS.OpsWorks | 2013-02-18 |
+ | AWS Security Token Service | AWS.STS | 2011-06-15 |
+ | AWS Storage Gateway | AWS.StorageGateway | 2013-06-30 |
+ | AWS Support | AWS.Support | 2013-04-15 |
+ | Elastic Load Balancing | AWS.ELB | 2012-06-01 |
+
+
+
+## License
+
+This SDK is distributed under the
+[Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0),
+see LICENSE.txt and NOTICE.txt for more information.
diff --git a/public/vendor/aws-sdk/UPGRADING.md b/public/vendor/aws-sdk/UPGRADING.md
new file mode 100644
index 00000000000..f67fd91492d
--- /dev/null
+++ b/public/vendor/aws-sdk/UPGRADING.md
@@ -0,0 +1,157 @@
+# @!title Upgrading Notes (1.x to 2.0)
+
+# Upgrading Notes (1.x to 2.0)
+
+This document captures breaking changes from 1.x versions to the first
+stable 2.x (non-RC) release of the AWS SDK for JavaScript.
+
+## 1. Automatic Conversion of Base64 and Timestamp Types on Input/Output
+
+The SDK will now automatically encode and decode base64-encoded values, as well
+as timestamp values, on the user's behalf. This change affects any operation
+where Base64 or Timestamp values were sent by a request or returned in a
+response, i.e., `AWS.DynamoDB` and `AWS.SQS`, which allow for Base64
+encoded values.
+
+User code that previously did base64 conversion no longer requires this.
+Furthermore, values encoded as base64 are now returned as Buffer objects
+from server responses (and can also be passed as Buffer input). For
+example, the following 1.x `SQS.sendMessage()` parameters:
+
+```javascript
+var params = {
+ MessageBody: 'Some Message',
+ MessageAttributes: {
+ attrName: {
+ DataType: 'Binary',
+ BinaryValue: new Buffer('example text').toString('base64')
+ }
+ }
+};
+```
+
+Can be rewritten as:
+
+```javascript
+var params = {
+ MessageBody: 'Some Message',
+ MessageAttributes: {
+ attrName: {
+ DataType: 'Binary',
+ BinaryValue: 'example text'
+ }
+ }
+};
+```
+
+And the message will be read as:
+
+```javascript
+sqs.receiveMessage(params, function(err, data) {
+ // buf is
+ var buf = data.Messages[0].MessageAttributes.attrName.BinaryValue;
+ console.log(buf.toString()); // "example text"
+});
+```
+
+## 2. Moved response.data.RequestId to response.requestId
+
+The SDK now stores request IDs for all services in a consistent place on the
+response object, rather than inside the response.data property. This is to
+improve consistency across services that expose request IDs in different ways.
+Note that this is also a breaking change that renames the
+`response.data.RequestId` property to `response.requestId`
+(or `this.requestId` inside of a callback).
+
+To migrate your code, change:
+
+```javascript
+svc.operation(params, function (err, data) {
+ console.log('Request ID:', data.RequestId);
+});
+```
+
+To the following:
+
+```javascript
+svc.operation(params, function () {
+ console.log('Request ID:', this.requestId);
+});
+```
+
+## 3. Exposed Wrapper Elements
+
+If you use {AWS.ElastiCache}, {AWS.RDS}, or {AWS.Redshift}, you must now access
+the response through the top-level output property in the response for certain
+operations. This change corrects the SDK to behave according to documentation
+output, which was previously listing this wrapper element.
+
+Example:
+
+`RDS.describeEngineDefaultParameters()` used to return:
+
+```javascript
+{ Parameters: [ ... ] }
+```
+
+This operation now returns:
+
+```javascript
+{ EngineDefaults: { Parameters: [ ... ] } }
+```
+
+The full list of affected operations for each service are:
+
+**AWS.ElastiCache**: authorizeCacheSecurityGroupIngress, createCacheCluster,
+createCacheParameterGroup, createCacheSecurityGroup, createCacheSubnetGroup,
+createReplicationGroup, deleteCacheCluster, deleteReplicationGroup,
+describeEngineDefaultParameters, modifyCacheCluster, modifyCacheSubnetGroup,
+modifyReplicationGroup, purchaseReservedCacheNodesOffering, rebootCacheCluster,
+revokeCacheSecurityGroupIngress
+
+**AWS.RDS**: addSourceIdentifierToSubscription, authorizeDBSecurityGroupIngress,
+copyDBSnapshot, createDBInstance, createDBInstanceReadReplica,
+createDBParameterGroup, createDBSecurityGroup, createDBSnapshot,
+createDBSubnetGroup, createEventSubscription, createOptionGroup,
+deleteDBInstance, deleteDBSnapshot, deleteEventSubscription,
+describeEngineDefaultParameters, modifyDBInstance, modifyDBSubnetGroup,
+modifyEventSubscription, modifyOptionGroup, promoteReadReplica,
+purchaseReservedDBInstancesOffering, rebootDBInstance,
+removeSourceIdentifierFromSubscription, restoreDBInstanceFromDBSnapshot,
+restoreDBInstanceToPointInTime, revokeDBSecurityGroupIngress
+
+**AWS.Redshift**: authorizeClusterSecurityGroupIngress, authorizeSnapshotAccess,
+copyClusterSnapshot, createCluster, createClusterParameterGroup,
+createClusterSecurityGroup, createClusterSnapshot, createClusterSubnetGroup,
+createEventSubscription, createHsmClientCertificate, createHsmConfiguration,
+deleteCluster, deleteClusterSnapshot, describeDefaultClusterParameters,
+disableSnapshotCopy, enableSnapshotCopy, modifyCluster,
+modifyClusterSubnetGroup, modifyEventSubscription,
+modifySnapshotCopyRetentionPeriod, purchaseReservedNodeOffering, rebootCluster,
+restoreFromClusterSnapshot, revokeClusterSecurityGroupIngress,
+revokeSnapshotAccess, rotateEncryptionKey
+
+## 4. Dropped `.Client` and `.client` Properties
+
+The `.Client` and `.client` properties have been removed from Service objects.
+If you are using the `.Client` property on a Service class or a `.client`
+property on an instance of the service, remove these properties from your code.
+
+Upgrading example:
+
+The following 1.x code:
+
+```
+var sts = new AWS.STS.Client();
+// or
+var sts = new AWS.STS();
+
+sts.client.operation(...);
+```
+
+Should be changed to the following:
+
+```
+var sts = new AWS.STS();
+sts.operation(...)
+```
diff --git a/public/vendor/aws-sdk/bower.json b/public/vendor/aws-sdk/bower.json
new file mode 100644
index 00000000000..bda489f676a
--- /dev/null
+++ b/public/vendor/aws-sdk/bower.json
@@ -0,0 +1,9 @@
+{
+ "name": "aws-sdk",
+ "ignore": [
+ "apis", "doc-src", "dist-tools", "eslint-rules", "features", "lib",
+ "scripts", "tasks", "test", "Gemfile*", "configuration*",
+ "Rakefile", "package.json", "testem.json", ".*", "index.js"
+ ],
+ "main": "dist/aws-sdk.js"
+}
diff --git a/public/vendor/aws-sdk/dist/BUNDLE_LICENSE.txt b/public/vendor/aws-sdk/dist/BUNDLE_LICENSE.txt
new file mode 100644
index 00000000000..14e46589be4
--- /dev/null
+++ b/public/vendor/aws-sdk/dist/BUNDLE_LICENSE.txt
@@ -0,0 +1,96 @@
+The bundled package of the AWS SDK for JavaScript is available under the
+Apache License, Version 2.0:
+
+ Copyright 2012-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+ Licensed under the Apache License, Version 2.0 (the "License"). You
+ may not use this file except in compliance with the License. A copy of
+ the License is located at
+
+ http://aws.amazon.com/apache2.0/
+
+ or in the "license" file accompanying this file. This file is
+ distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ ANY KIND, either express or implied. See the License for the specific
+ language governing permissions and limitations under the License.
+
+This product bundles browserify, which is available under a
+"3-clause BSD" license:
+
+ Copyright Joyent, Inc. and other Node contributors.
+
+ Permission is hereby granted, free of charge, to any person obtaining a
+ copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to permit
+ persons to whom the Software is furnished to do so, subject to the
+ following conditions:
+
+ The above copyright notice and this permission notice shall be included
+ in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+ NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+This product bundles crypto-browserify, which is available under
+the MIT license:
+
+ Copyright (c) 2013 Dominic Tarr
+
+ Permission is hereby granted, free of charge,
+ to any person obtaining a copy of this software and
+ associated documentation files (the "Software"), to
+ deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify,
+ merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom
+ the Software is furnished to do so,
+ subject to the following conditions:
+
+ The above copyright notice and this permission notice
+ shall be included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+ ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+This product bundles MD5, SHA-1, and SHA-256 hashing algorithm components,
+which are available under a BSD license:
+
+ Copyright (c) 1998 - 2009, Paul Johnston & Contributors
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ Redistributions of source code must retain the above copyrightnotice,
+ this list of conditions and the following disclaimer. Redistributions
+ in binary form must reproduce the above copyright notice, this list of
+ conditions and the following disclaimer in the documentation and/or
+ other materials provided with the distribution.
+
+ Neither the name of the author nor the names of its contributors may
+ be used to endorse or promote products derived from this software
+ without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/public/vendor/aws-sdk/dist/aws-sdk.js b/public/vendor/aws-sdk/dist/aws-sdk.js
new file mode 100644
index 00000000000..2da7464d469
--- /dev/null
+++ b/public/vendor/aws-sdk/dist/aws-sdk.js
@@ -0,0 +1,10800 @@
+// AWS SDK for JavaScript v2.1.42
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// License at https://sdk.amazonaws.com/js/BUNDLE_LICENSE.txt
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o this.expireTime) {
+ return true;
+ } else {
+ return this.expired || !this.accessKeyId || !this.secretAccessKey;
+ }
+ },
+
+
+ get: function get(callback) {
+ var self = this;
+ if (this.needsRefresh()) {
+ this.refresh(function(err) {
+ if (!err) self.expired = false; // reset expired flag
+ if (callback) callback(err);
+ });
+ } else if (callback) {
+ callback();
+ }
+ },
+
+
+ refresh: function refresh(callback) {
+ this.expired = false;
+ callback();
+ }
+});
+
+},{"./core":3}],5:[function(require,module,exports){
+var AWS = require('../core');
+
+
+AWS.CognitoIdentityCredentials = AWS.util.inherit(AWS.Credentials, {
+
+ localStorageKey: {
+ id: 'aws.cognito.identity-id.',
+ providers: 'aws.cognito.identity-providers.'
+ },
+
+
+ constructor: function CognitoIdentityCredentials(params) {
+ AWS.Credentials.call(this);
+ this.expired = true;
+ this.params = params;
+ this.data = null;
+ this.identityId = null;
+ this.loadCachedId();
+ },
+
+
+ refresh: function refresh(callback) {
+ var self = this;
+ self.createClients();
+ self.data = null;
+ self.identityId = null;
+ self.getId(function(err) {
+ if (!err) {
+ if (!self.params.RoleArn) {
+ self.getCredentialsForIdentity(callback);
+ } else {
+ self.getCredentialsFromSTS(callback);
+ }
+ } else {
+ self.clearCachedId();
+ callback(err);
+ }
+ });
+ },
+
+
+ clearCachedId: function clearCache() {
+ this.identityId = null;
+ delete this.params.IdentityId;
+
+ var poolId = this.params.IdentityPoolId;
+ delete this.storage[this.localStorageKey.id + poolId];
+ delete this.storage[this.localStorageKey.providers + poolId];
+ },
+
+
+ getId: function getId(callback) {
+ var self = this;
+ if (typeof self.params.IdentityId === 'string') {
+ return callback(null, self.params.IdentityId);
+ }
+
+ self.cognito.getId(function(err, data) {
+ if (!err && data.IdentityId) {
+ self.params.IdentityId = data.IdentityId;
+ callback(null, data.IdentityId);
+ } else {
+ callback(err);
+ }
+ });
+ },
+
+
+
+ loadCredentials: function loadCredentials(data, credentials) {
+ if (!data || !credentials) return;
+ credentials.expired = false;
+ credentials.accessKeyId = data.Credentials.AccessKeyId;
+ credentials.secretAccessKey = data.Credentials.SecretKey;
+ credentials.sessionToken = data.Credentials.SessionToken;
+ credentials.expireTime = data.Credentials.Expiration;
+ },
+
+
+ getCredentialsForIdentity: function getCredentialsForIdentity(callback) {
+ var self = this;
+ self.cognito.getCredentialsForIdentity(function(err, data) {
+ if (!err) {
+ self.cacheId(data);
+ self.data = data;
+ self.loadCredentials(self.data, self);
+ } else {
+ self.clearCachedId();
+ }
+ callback(err);
+ });
+ },
+
+
+ getCredentialsFromSTS: function getCredentialsFromSTS(callback) {
+ var self = this;
+ self.cognito.getOpenIdToken(function(err, data) {
+ if (!err) {
+ self.cacheId(data);
+ self.params.WebIdentityToken = data.Token;
+ self.webIdentityCredentials.refresh(function(webErr) {
+ if (!webErr) {
+ self.data = self.webIdentityCredentials.data;
+ self.sts.credentialsFrom(self.data, self);
+ } else {
+ self.clearCachedId();
+ }
+ callback(webErr);
+ });
+ } else {
+ self.clearCachedId();
+ callback(err);
+ }
+ });
+ },
+
+
+ loadCachedId: function loadCachedId() {
+ var self = this;
+
+ if (AWS.util.isBrowser() && !self.params.IdentityId) {
+ var id = self.getStorage('id');
+ if (id && self.params.Logins) {
+ var actualProviders = Object.keys(self.params.Logins);
+ var cachedProviders =
+ (self.getStorage('providers') || '').split(',');
+
+ var intersect = cachedProviders.filter(function(n) {
+ return actualProviders.indexOf(n) !== -1;
+ });
+ if (intersect.length !== 0) {
+ self.params.IdentityId = id;
+ }
+ } else if (id) {
+ self.params.IdentityId = id;
+ }
+ }
+ },
+
+
+ createClients: function() {
+ this.webIdentityCredentials = this.webIdentityCredentials ||
+ new AWS.WebIdentityCredentials(this.params);
+ this.cognito = this.cognito ||
+ new AWS.CognitoIdentity({params: this.params});
+ this.sts = this.sts || new AWS.STS();
+ },
+
+
+ cacheId: function cacheId(data) {
+ this.identityId = data.IdentityId;
+ this.params.IdentityId = this.identityId;
+
+ if (AWS.util.isBrowser()) {
+ this.setStorage('id', data.IdentityId);
+
+ if (this.params.Logins) {
+ this.setStorage('providers', Object.keys(this.params.Logins).join(','));
+ }
+ }
+ },
+
+
+ getStorage: function getStorage(key) {
+ return this.storage[this.localStorageKey[key] + this.params.IdentityPoolId];
+ },
+
+
+ setStorage: function setStorage(key, val) {
+ try {
+ this.storage[this.localStorageKey[key] + this.params.IdentityPoolId] = val;
+ } catch (_) {}
+ },
+
+
+ storage: (function() {
+ try {
+ return AWS.util.isBrowser() && typeof window.localStorage === 'object' ?
+ window.localStorage : {};
+ } catch (_) {
+ return {};
+ }
+ })()
+});
+
+},{"../core":3}],6:[function(require,module,exports){
+var AWS = require('../core');
+
+
+AWS.CredentialProviderChain = AWS.util.inherit(AWS.Credentials, {
+
+
+ constructor: function CredentialProviderChain(providers) {
+ if (providers) {
+ this.providers = providers;
+ } else {
+ this.providers = AWS.CredentialProviderChain.defaultProviders.slice(0);
+ }
+ },
+
+
+ resolve: function resolve(callback) {
+ if (this.providers.length === 0) {
+ callback(new Error('No providers'));
+ return this;
+ }
+
+ var index = 0;
+ var providers = this.providers.slice(0);
+
+ function resolveNext(err, creds) {
+ if ((!err && creds) || index === providers.length) {
+ callback(err, creds);
+ return;
+ }
+
+ var provider = providers[index++];
+ if (typeof provider === 'function') {
+ creds = provider.call();
+ } else {
+ creds = provider;
+ }
+
+ if (creds.get) {
+ creds.get(function(getErr) {
+ resolveNext(getErr, getErr ? null : creds);
+ });
+ } else {
+ resolveNext(null, creds);
+ }
+ }
+
+ resolveNext();
+ return this;
+ }
+
+});
+
+
+AWS.CredentialProviderChain.defaultProviders = [];
+
+},{"../core":3}],7:[function(require,module,exports){
+var AWS = require('../core');
+
+
+AWS.SAMLCredentials = AWS.util.inherit(AWS.Credentials, {
+
+ constructor: function SAMLCredentials(params) {
+ AWS.Credentials.call(this);
+ this.expired = true;
+ this.params = params;
+ },
+
+
+ refresh: function refresh(callback) {
+ var self = this;
+ self.createClients();
+ if (!callback) callback = function(err) { if (err) throw err; };
+
+ self.service.assumeRoleWithSAML(function (err, data) {
+ if (!err) {
+ self.service.credentialsFrom(data, self);
+ }
+ callback(err);
+ });
+ },
+
+
+ createClients: function() {
+ this.service = this.service || new AWS.STS({params: this.params});
+ }
+
+});
+
+},{"../core":3}],8:[function(require,module,exports){
+var AWS = require('../core');
+
+
+AWS.TemporaryCredentials = AWS.util.inherit(AWS.Credentials, {
+
+ constructor: function TemporaryCredentials(params) {
+ AWS.Credentials.call(this);
+ this.loadMasterCredentials();
+ this.expired = true;
+
+ this.params = params || {};
+ if (this.params.RoleArn) {
+ this.params.RoleSessionName =
+ this.params.RoleSessionName || 'temporary-credentials';
+ }
+ },
+
+
+ refresh: function refresh(callback) {
+ var self = this;
+ self.createClients();
+ if (!callback) callback = function(err) { if (err) throw err; };
+
+ self.service.config.credentials = self.masterCredentials;
+ var operation = self.params.RoleArn ?
+ self.service.assumeRole : self.service.getSessionToken;
+ operation.call(self.service, function (err, data) {
+ if (!err) {
+ self.service.credentialsFrom(data, self);
+ }
+ callback(err);
+ });
+ },
+
+
+ loadMasterCredentials: function loadMasterCredentials() {
+ this.masterCredentials = AWS.config.credentials;
+ while (this.masterCredentials.masterCredentials) {
+ this.masterCredentials = this.masterCredentials.masterCredentials;
+ }
+ },
+
+
+ createClients: function() {
+ this.service = this.service || new AWS.STS({params: this.params});
+ }
+
+});
+
+},{"../core":3}],9:[function(require,module,exports){
+var AWS = require('../core');
+
+
+AWS.WebIdentityCredentials = AWS.util.inherit(AWS.Credentials, {
+
+ constructor: function WebIdentityCredentials(params) {
+ AWS.Credentials.call(this);
+ this.expired = true;
+ this.params = params;
+ this.params.RoleSessionName = this.params.RoleSessionName || 'web-identity';
+ this.data = null;
+ },
+
+
+ refresh: function refresh(callback) {
+ var self = this;
+ self.createClients();
+ if (!callback) callback = function(err) { if (err) throw err; };
+
+ self.service.assumeRoleWithWebIdentity(function (err, data) {
+ self.data = null;
+ if (!err) {
+ self.data = data;
+ self.service.credentialsFrom(data, self);
+ }
+ callback(err);
+ });
+ },
+
+
+ createClients: function() {
+ this.service = this.service || new AWS.STS({params: this.params});
+ }
+
+});
+
+},{"../core":3}],10:[function(require,module,exports){
+var AWS = require('./core');
+var SequentialExecutor = require('./sequential_executor');
+
+
+AWS.EventListeners = {
+
+ Core: {} /* doc hack */
+};
+
+AWS.EventListeners = {
+ Core: new SequentialExecutor().addNamedListeners(function(add, addAsync) {
+ addAsync('VALIDATE_CREDENTIALS', 'validate',
+ function VALIDATE_CREDENTIALS(req, done) {
+ if (!req.service.api.signatureVersion) return done(); // none
+ req.service.config.getCredentials(function(err) {
+ if (err) {
+ req.response.error = AWS.util.error(err,
+ {code: 'CredentialsError', message: 'Missing credentials in config'});
+ }
+ done();
+ });
+ });
+
+ add('VALIDATE_REGION', 'validate', function VALIDATE_REGION(req) {
+ if (!req.service.config.region && !req.service.isGlobalEndpoint) {
+ req.response.error = AWS.util.error(new Error(),
+ {code: 'ConfigError', message: 'Missing region in config'});
+ }
+ });
+
+ add('VALIDATE_PARAMETERS', 'validate', function VALIDATE_PARAMETERS(req) {
+ var rules = req.service.api.operations[req.operation].input;
+ new AWS.ParamValidator().validate(rules, req.params);
+ });
+
+ addAsync('COMPUTE_SHA256', 'afterBuild', function COMPUTE_SHA256(req, done) {
+ req.haltHandlersOnError();
+ if (!req.service.api.signatureVersion) return done(); // none
+ if (req.service.getSignerClass(req) === AWS.Signers.V4) {
+ var body = req.httpRequest.body || '';
+ AWS.util.computeSha256(body, function(err, sha) {
+ if (err) {
+ done(err);
+ }
+ else {
+ req.httpRequest.headers['X-Amz-Content-Sha256'] = sha;
+ done();
+ }
+ });
+ } else {
+ done();
+ }
+ });
+
+ add('SET_CONTENT_LENGTH', 'afterBuild', function SET_CONTENT_LENGTH(req) {
+ if (req.httpRequest.headers['Content-Length'] === undefined) {
+ var length = AWS.util.string.byteLength(req.httpRequest.body);
+ req.httpRequest.headers['Content-Length'] = length;
+ }
+ });
+
+ add('SET_HTTP_HOST', 'afterBuild', function SET_HTTP_HOST(req) {
+ req.httpRequest.headers['Host'] = req.httpRequest.endpoint.host;
+ });
+
+ add('RESTART', 'restart', function RESTART() {
+ var err = this.response.error;
+ if (!err || !err.retryable) return;
+
+ this.httpRequest = new AWS.HttpRequest(
+ this.service.endpoint,
+ this.service.region
+ );
+
+ if (this.response.retryCount < this.service.config.maxRetries) {
+ this.response.retryCount++;
+ } else {
+ this.response.error = null;
+ }
+ });
+
+ addAsync('SIGN', 'sign', function SIGN(req, done) {
+ if (!req.service.api.signatureVersion) return done(); // none
+
+ req.service.config.getCredentials(function (err, credentials) {
+ if (err) {
+ req.response.error = err;
+ return done();
+ }
+
+ try {
+ var date = AWS.util.date.getDate();
+ var SignerClass = req.service.getSignerClass(req);
+ var signer = new SignerClass(req.httpRequest,
+ req.service.api.signingName || req.service.api.endpointPrefix);
+
+ delete req.httpRequest.headers['Authorization'];
+ delete req.httpRequest.headers['Date'];
+ delete req.httpRequest.headers['X-Amz-Date'];
+
+ signer.addAuthorization(credentials, date);
+ req.signedAt = date;
+ } catch (e) {
+ req.response.error = e;
+ }
+ done();
+ });
+ });
+
+ add('VALIDATE_RESPONSE', 'validateResponse', function VALIDATE_RESPONSE(resp) {
+ if (this.service.successfulResponse(resp, this)) {
+ resp.data = {};
+ resp.error = null;
+ } else {
+ resp.data = null;
+ resp.error = AWS.util.error(new Error(),
+ {code: 'UnknownError', message: 'An unknown error occurred.'});
+ }
+ });
+
+ addAsync('SEND', 'send', function SEND(resp, done) {
+ resp.httpResponse._abortCallback = done;
+ resp.error = null;
+ resp.data = null;
+
+ function callback(httpResp) {
+ resp.httpResponse.stream = httpResp;
+
+ httpResp.on('headers', function onHeaders(statusCode, headers) {
+ resp.request.emit('httpHeaders', [statusCode, headers, resp]);
+
+ if (!resp.httpResponse.streaming) {
+ if (AWS.HttpClient.streamsApiVersion === 2) { // streams2 API check
+ httpResp.on('readable', function onReadable() {
+ var data = httpResp.read();
+ if (data !== null) {
+ resp.request.emit('httpData', [data, resp]);
+ }
+ });
+ } else { // legacy streams API
+ httpResp.on('data', function onData(data) {
+ resp.request.emit('httpData', [data, resp]);
+ });
+ }
+ }
+ });
+
+ httpResp.on('end', function onEnd() {
+ resp.request.emit('httpDone');
+ done();
+ });
+ }
+
+ function progress(httpResp) {
+ httpResp.on('sendProgress', function onSendProgress(value) {
+ resp.request.emit('httpUploadProgress', [value, resp]);
+ });
+
+ httpResp.on('receiveProgress', function onReceiveProgress(value) {
+ resp.request.emit('httpDownloadProgress', [value, resp]);
+ });
+ }
+
+ function error(err) {
+ resp.error = AWS.util.error(err, {
+ code: 'NetworkingError',
+ region: resp.request.httpRequest.region,
+ hostname: resp.request.httpRequest.endpoint.hostname,
+ retryable: true
+ });
+ resp.request.emit('httpError', [resp.error, resp], function() {
+ done();
+ });
+ }
+
+ function executeSend() {
+ var http = AWS.HttpClient.getInstance();
+ var httpOptions = resp.request.service.config.httpOptions || {};
+ try {
+ var stream = http.handleRequest(resp.request.httpRequest, httpOptions,
+ callback, error);
+ progress(stream);
+ } catch (err) {
+ error(err);
+ }
+ }
+
+ var timeDiff = (AWS.util.date.getDate() - this.signedAt) / 1000;
+ if (timeDiff >= 60 * 10) { // if we signed 10min ago, re-sign
+ this.emit('sign', [this], function(err) {
+ if (err) done(err);
+ else executeSend();
+ });
+ } else {
+ executeSend();
+ }
+ });
+
+ add('HTTP_HEADERS', 'httpHeaders',
+ function HTTP_HEADERS(statusCode, headers, resp) {
+ resp.httpResponse.statusCode = statusCode;
+ resp.httpResponse.headers = headers;
+ resp.httpResponse.body = new AWS.util.Buffer('');
+ resp.httpResponse.buffers = [];
+ resp.httpResponse.numBytes = 0;
+ });
+
+ add('HTTP_DATA', 'httpData', function HTTP_DATA(chunk, resp) {
+ if (chunk) {
+ if (AWS.util.isNode()) {
+ resp.httpResponse.numBytes += chunk.length;
+
+ var total = resp.httpResponse.headers['content-length'];
+ var progress = { loaded: resp.httpResponse.numBytes, total: total };
+ resp.request.emit('httpDownloadProgress', [progress, resp]);
+ }
+
+ resp.httpResponse.buffers.push(new AWS.util.Buffer(chunk));
+ }
+ });
+
+ add('HTTP_DONE', 'httpDone', function HTTP_DONE(resp) {
+ if (resp.httpResponse.buffers && resp.httpResponse.buffers.length > 0) {
+ var body = AWS.util.buffer.concat(resp.httpResponse.buffers);
+ resp.httpResponse.body = body;
+ }
+ delete resp.httpResponse.numBytes;
+ delete resp.httpResponse.buffers;
+ });
+
+ add('FINALIZE_ERROR', 'retry', function FINALIZE_ERROR(resp) {
+ if (resp.httpResponse.statusCode) {
+ resp.error.statusCode = resp.httpResponse.statusCode;
+ if (resp.error.retryable === undefined) {
+ resp.error.retryable = this.service.retryableError(resp.error, this);
+ }
+ }
+ });
+
+ add('INVALIDATE_CREDENTIALS', 'retry', function INVALIDATE_CREDENTIALS(resp) {
+ if (!resp.error) return;
+ switch (resp.error.code) {
+ case 'RequestExpired': // EC2 only
+ case 'ExpiredTokenException':
+ case 'ExpiredToken':
+ resp.error.retryable = true;
+ resp.request.service.config.credentials.expired = true;
+ }
+ });
+
+ add('EXPIRED_SIGNATURE', 'retry', function EXPIRED_SIGNATURE(resp) {
+ var err = resp.error;
+ if (!err) return;
+ if (typeof err.code === 'string' && typeof err.message === 'string') {
+ if (err.code.match(/Signature/) && err.message.match(/expired/)) {
+ resp.error.retryable = true;
+ }
+ }
+ });
+
+ add('REDIRECT', 'retry', function REDIRECT(resp) {
+ if (resp.error && resp.error.statusCode >= 300 &&
+ resp.error.statusCode < 400 && resp.httpResponse.headers['location']) {
+ this.httpRequest.endpoint =
+ new AWS.Endpoint(resp.httpResponse.headers['location']);
+ this.httpRequest.headers['Host'] = this.httpRequest.endpoint.host;
+ resp.error.redirect = true;
+ resp.error.retryable = true;
+ }
+ });
+
+ add('RETRY_CHECK', 'retry', function RETRY_CHECK(resp) {
+ if (resp.error) {
+ if (resp.error.redirect && resp.redirectCount < resp.maxRedirects) {
+ resp.error.retryDelay = 0;
+ } else if (resp.retryCount < resp.maxRetries) {
+ var delays = this.service.retryDelays();
+ resp.error.retryDelay = delays[resp.retryCount] || 0;
+ }
+ }
+ });
+
+ addAsync('RESET_RETRY_STATE', 'afterRetry', function RESET_RETRY_STATE(resp, done) {
+ var delay, willRetry = false;
+
+ if (resp.error) {
+ delay = resp.error.retryDelay || 0;
+ if (resp.error.retryable && resp.retryCount < resp.maxRetries) {
+ resp.retryCount++;
+ willRetry = true;
+ } else if (resp.error.redirect && resp.redirectCount < resp.maxRedirects) {
+ resp.redirectCount++;
+ willRetry = true;
+ }
+ }
+
+ if (willRetry) {
+ resp.error = null;
+ setTimeout(done, delay);
+ } else {
+ done();
+ }
+ });
+ }),
+
+ CorePost: new SequentialExecutor().addNamedListeners(function(add) {
+ add('EXTRACT_REQUEST_ID', 'extractData', function EXTRACT_REQUEST_ID(resp) {
+
+ if (!resp.requestId) {
+ resp.requestId = resp.httpResponse.headers['x-amz-request-id'] ||
+ resp.httpResponse.headers['x-amzn-requestid'];
+ }
+
+ if (!resp.requestId && resp.data && resp.data.ResponseMetadata) {
+ resp.requestId = resp.data.ResponseMetadata.RequestId;
+ }
+ });
+
+ add('ENOTFOUND_ERROR', 'httpError', function ENOTFOUND_ERROR(err) {
+ if (err.code === 'NetworkingError' && err.errno === 'ENOTFOUND') {
+ var message = 'Inaccessible host: `' + err.hostname +
+ '\'. This service may not be available in the `' + err.region +
+ '\' region.';
+ this.response.error = AWS.util.error(new Error(message), {
+ code: 'UnknownEndpoint',
+ region: err.region,
+ hostname: err.hostname,
+ retryable: true,
+ originalError: err
+ });
+ }
+ });
+ }),
+
+ Logger: new SequentialExecutor().addNamedListeners(function(add) {
+ add('LOG_REQUEST', 'complete', function LOG_REQUEST(resp) {
+ var req = resp.request;
+ var logger = req.service.config.logger;
+ if (!logger) return;
+
+ function buildMessage() {
+ var time = AWS.util.date.getDate().getTime();
+ var delta = (time - req.startTime.getTime()) / 1000;
+ var ansi = logger.isTTY ? true : false;
+ var status = resp.httpResponse.statusCode;
+ var params = require('util').inspect(req.params, true, null);
+
+ var message = '';
+ if (ansi) message += '\x1B[33m';
+ message += '[AWS ' + req.service.serviceIdentifier + ' ' + status;
+ message += ' ' + delta.toString() + 's ' + resp.retryCount + ' retries]';
+ if (ansi) message += '\x1B[0;1m';
+ message += ' ' + AWS.util.string.lowerFirst(req.operation);
+ message += '(' + params + ')';
+ if (ansi) message += '\x1B[0m';
+ return message;
+ }
+
+ var line = buildMessage();
+ if (typeof logger.log === 'function') {
+ logger.log(line);
+ } else if (typeof logger.write === 'function') {
+ logger.write(line + '\n');
+ }
+ });
+ }),
+
+ Json: new SequentialExecutor().addNamedListeners(function(add) {
+ var svc = require('./protocol/json');
+ add('BUILD', 'build', svc.buildRequest);
+ add('EXTRACT_DATA', 'extractData', svc.extractData);
+ add('EXTRACT_ERROR', 'extractError', svc.extractError);
+ }),
+
+ Rest: new SequentialExecutor().addNamedListeners(function(add) {
+ var svc = require('./protocol/rest');
+ add('BUILD', 'build', svc.buildRequest);
+ add('EXTRACT_DATA', 'extractData', svc.extractData);
+ add('EXTRACT_ERROR', 'extractError', svc.extractError);
+ }),
+
+ RestJson: new SequentialExecutor().addNamedListeners(function(add) {
+ var svc = require('./protocol/rest_json');
+ add('BUILD', 'build', svc.buildRequest);
+ add('EXTRACT_DATA', 'extractData', svc.extractData);
+ add('EXTRACT_ERROR', 'extractError', svc.extractError);
+ }),
+
+ RestXml: new SequentialExecutor().addNamedListeners(function(add) {
+ var svc = require('./protocol/rest_xml');
+ add('BUILD', 'build', svc.buildRequest);
+ add('EXTRACT_DATA', 'extractData', svc.extractData);
+ add('EXTRACT_ERROR', 'extractError', svc.extractError);
+ }),
+
+ Query: new SequentialExecutor().addNamedListeners(function(add) {
+ var svc = require('./protocol/query');
+ add('BUILD', 'build', svc.buildRequest);
+ add('EXTRACT_DATA', 'extractData', svc.extractData);
+ add('EXTRACT_ERROR', 'extractError', svc.extractError);
+ })
+};
+
+},{"./core":3,"./protocol/json":22,"./protocol/query":23,"./protocol/rest":24,"./protocol/rest_json":25,"./protocol/rest_xml":26,"./sequential_executor":34,"util":72}],11:[function(require,module,exports){
+var AWS = require('./core');
+var inherit = AWS.util.inherit;
+
+
+AWS.Endpoint = inherit({
+
+
+ constructor: function Endpoint(endpoint, config) {
+ AWS.util.hideProperties(this, ['slashes', 'auth', 'hash', 'search', 'query']);
+
+ if (typeof endpoint === 'undefined' || endpoint === null) {
+ throw new Error('Invalid endpoint: ' + endpoint);
+ } else if (typeof endpoint !== 'string') {
+ return AWS.util.copy(endpoint);
+ }
+
+ if (!endpoint.match(/^http/)) {
+ var useSSL = config && config.sslEnabled !== undefined ?
+ config.sslEnabled : AWS.config.sslEnabled;
+ endpoint = (useSSL ? 'https' : 'http') + '://' + endpoint;
+ }
+
+ AWS.util.update(this, AWS.util.urlParse(endpoint));
+
+ if (this.port) {
+ this.port = parseInt(this.port, 10);
+ } else {
+ this.port = this.protocol === 'https:' ? 443 : 80;
+ }
+ }
+
+});
+
+
+AWS.HttpRequest = inherit({
+
+
+ constructor: function HttpRequest(endpoint, region) {
+ endpoint = new AWS.Endpoint(endpoint);
+ this.method = 'POST';
+ this.path = endpoint.path || '/';
+ this.headers = {};
+ this.body = '';
+ this.endpoint = endpoint;
+ this.region = region;
+ this.setUserAgent();
+ },
+
+
+ setUserAgent: function setUserAgent() {
+ var prefix = AWS.util.isBrowser() ? 'X-Amz-' : '';
+ this.headers[prefix + 'User-Agent'] = AWS.util.userAgent();
+ },
+
+
+ pathname: function pathname() {
+ return this.path.split('?', 1)[0];
+ },
+
+
+ search: function search() {
+ var query = this.path.split('?', 2)[1];
+ if (query) {
+ query = AWS.util.queryStringParse(query);
+ return AWS.util.queryParamsToString(query);
+ }
+ return '';
+ }
+
+});
+
+
+AWS.HttpResponse = inherit({
+
+
+ constructor: function HttpResponse() {
+ this.statusCode = undefined;
+ this.headers = {};
+ this.body = undefined;
+ this.streaming = false;
+ this.stream = null;
+ },
+
+
+ createUnbufferedStream: function createUnbufferedStream() {
+ this.streaming = true;
+ return this.stream;
+ }
+});
+
+
+AWS.HttpClient = inherit({});
+
+
+AWS.HttpClient.getInstance = function getInstance() {
+ if (this.singleton === undefined) {
+ this.singleton = new this();
+ }
+ return this.singleton;
+};
+
+},{"./core":3}],12:[function(require,module,exports){
+var AWS = require('../core');
+var EventEmitter = require('events').EventEmitter;
+require('../http');
+
+
+AWS.XHRClient = AWS.util.inherit({
+ handleRequest: function handleRequest(httpRequest, httpOptions, callback, errCallback) {
+ var self = this;
+ var endpoint = httpRequest.endpoint;
+ var emitter = new EventEmitter();
+ var href = endpoint.protocol + '//' + endpoint.hostname;
+ if (endpoint.port !== 80 && endpoint.port !== 443) {
+ href += ':' + endpoint.port;
+ }
+ href += httpRequest.path;
+
+ var xhr = new XMLHttpRequest(), headersEmitted = false;
+ httpRequest.stream = xhr;
+
+ xhr.addEventListener('readystatechange', function() {
+ try {
+ if (xhr.status === 0) return; // 0 code is invalid
+ } catch (e) { return; }
+
+ if (this.readyState >= this.HEADERS_RECEIVED && !headersEmitted) {
+ try { xhr.responseType = 'arraybuffer'; } catch (e) {}
+ emitter.statusCode = xhr.status;
+ emitter.headers = self.parseHeaders(xhr.getAllResponseHeaders());
+ emitter.emit('headers', emitter.statusCode, emitter.headers);
+ headersEmitted = true;
+ }
+ if (this.readyState === this.DONE) {
+ self.finishRequest(xhr, emitter);
+ }
+ }, false);
+ xhr.upload.addEventListener('progress', function (evt) {
+ emitter.emit('sendProgress', evt);
+ });
+ xhr.addEventListener('progress', function (evt) {
+ emitter.emit('receiveProgress', evt);
+ }, false);
+ xhr.addEventListener('timeout', function () {
+ errCallback(AWS.util.error(new Error('Timeout'), {code: 'TimeoutError'}));
+ }, false);
+ xhr.addEventListener('error', function () {
+ errCallback(AWS.util.error(new Error('Network Failure'), {
+ code: 'NetworkingError'
+ }));
+ }, false);
+
+ callback(emitter);
+ xhr.open(httpRequest.method, href, httpOptions.xhrAsync !== false);
+ AWS.util.each(httpRequest.headers, function (key, value) {
+ if (key !== 'Content-Length' && key !== 'User-Agent' && key !== 'Host') {
+ xhr.setRequestHeader(key, value);
+ }
+ });
+
+ if (httpOptions.timeout && httpOptions.xhrAsync !== false) {
+ xhr.timeout = httpOptions.timeout;
+ }
+
+ if (httpOptions.xhrWithCredentials) {
+ xhr.withCredentials = true;
+ }
+
+ try {
+ xhr.send(httpRequest.body);
+ } catch (err) {
+ if (httpRequest.body && typeof httpRequest.body.buffer === 'object') {
+ xhr.send(httpRequest.body.buffer); // send ArrayBuffer directly
+ } else {
+ throw err;
+ }
+ }
+
+ return emitter;
+ },
+
+ parseHeaders: function parseHeaders(rawHeaders) {
+ var headers = {};
+ AWS.util.arrayEach(rawHeaders.split(/\r?\n/), function (line) {
+ var key = line.split(':', 1)[0];
+ var value = line.substring(key.length + 2);
+ if (key.length > 0) headers[key.toLowerCase()] = value;
+ });
+ return headers;
+ },
+
+ finishRequest: function finishRequest(xhr, emitter) {
+ var buffer;
+ if (xhr.responseType === 'arraybuffer' && xhr.response) {
+ var ab = xhr.response;
+ buffer = new AWS.util.Buffer(ab.byteLength);
+ var view = new Uint8Array(ab);
+ for (var i = 0; i < buffer.length; ++i) {
+ buffer[i] = view[i];
+ }
+ }
+
+ try {
+ if (!buffer && typeof xhr.responseText === 'string') {
+ buffer = new AWS.util.Buffer(xhr.responseText);
+ }
+ } catch (e) {}
+
+ if (buffer) emitter.emit('data', buffer);
+ emitter.emit('end');
+ }
+});
+
+
+AWS.HttpClient.prototype = AWS.XHRClient.prototype;
+
+
+AWS.HttpClient.streamsApiVersion = 1;
+
+},{"../core":3,"../http":11,"events":63}],13:[function(require,module,exports){
+var util = require('../util');
+
+function JsonBuilder() { }
+
+JsonBuilder.prototype.build = function(value, shape) {
+ return JSON.stringify(translate(value, shape));
+};
+
+function translate(value, shape) {
+ if (!shape || value === undefined || value === null) return undefined;
+
+ switch (shape.type) {
+ case 'structure': return translateStructure(value, shape);
+ case 'map': return translateMap(value, shape);
+ case 'list': return translateList(value, shape);
+ default: return translateScalar(value, shape);
+ }
+}
+
+function translateStructure(structure, shape) {
+ var struct = {};
+ util.each(structure, function(name, value) {
+ var memberShape = shape.members[name];
+ if (memberShape) {
+ if (memberShape.location !== 'body') return;
+
+ var result = translate(value, memberShape);
+ if (result !== undefined) struct[name] = result;
+ }
+ });
+ return struct;
+}
+
+function translateList(list, shape) {
+ var out = [];
+ util.arrayEach(list, function(value) {
+ var result = translate(value, shape.member);
+ if (result !== undefined) out.push(result);
+ });
+ return out;
+}
+
+function translateMap(map, shape) {
+ var out = {};
+ util.each(map, function(key, value) {
+ var result = translate(value, shape.value);
+ if (result !== undefined) out[key] = result;
+ });
+ return out;
+}
+
+function translateScalar(value, shape) {
+ return shape.toWireFormat(value);
+}
+
+module.exports = JsonBuilder;
+
+},{"../util":51}],14:[function(require,module,exports){
+var util = require('../util');
+
+function JsonParser() { }
+
+JsonParser.prototype.parse = function(value, shape) {
+ return translate(JSON.parse(value), shape);
+};
+
+function translate(value, shape) {
+ if (!shape || value === undefined) return undefined;
+
+ switch (shape.type) {
+ case 'structure': return translateStructure(value, shape);
+ case 'map': return translateMap(value, shape);
+ case 'list': return translateList(value, shape);
+ default: return translateScalar(value, shape);
+ }
+}
+
+function translateStructure(structure, shape) {
+ if (structure == null) return undefined;
+
+ var struct = {};
+ util.each(structure, function(name, value) {
+ var memberShape = shape.members[name];
+ if (memberShape) {
+ var result = translate(value, memberShape);
+ if (result !== undefined) struct[name] = result;
+ }
+ });
+ return struct;
+}
+
+function translateList(list, shape) {
+ if (list == null) return undefined;
+
+ var out = [];
+ util.arrayEach(list, function(value) {
+ var result = translate(value, shape.member);
+ if (result === undefined) out.push(null);
+ else out.push(result);
+ });
+ return out;
+}
+
+function translateMap(map, shape) {
+ if (map == null) return undefined;
+
+ var out = {};
+ util.each(map, function(key, value) {
+ var result = translate(value, shape.value);
+ if (result === undefined) out[key] = null;
+ else out[key] = result;
+ });
+ return out;
+}
+
+function translateScalar(value, shape) {
+ return shape.toType(value);
+}
+
+module.exports = JsonParser;
+
+},{"../util":51}],15:[function(require,module,exports){
+var Collection = require('./collection');
+var Operation = require('./operation');
+var Shape = require('./shape');
+var Paginator = require('./paginator');
+var ResourceWaiter = require('./resource_waiter');
+
+var util = require('../util');
+var property = util.property;
+var memoizedProperty = util.memoizedProperty;
+
+function Api(api, options) {
+ api = api || {};
+ options = options || {};
+ options.api = this;
+
+ api.metadata = api.metadata || {};
+
+ property(this, 'isApi', true, false);
+ property(this, 'apiVersion', api.metadata.apiVersion);
+ property(this, 'endpointPrefix', api.metadata.endpointPrefix);
+ property(this, 'signingName', api.metadata.signingName);
+ property(this, 'globalEndpoint', api.metadata.globalEndpoint);
+ property(this, 'signatureVersion', api.metadata.signatureVersion);
+ property(this, 'jsonVersion', api.metadata.jsonVersion);
+ property(this, 'targetPrefix', api.metadata.targetPrefix);
+ property(this, 'protocol', api.metadata.protocol);
+ property(this, 'timestampFormat', api.metadata.timestampFormat);
+ property(this, 'xmlNamespaceUri', api.metadata.xmlNamespace);
+ property(this, 'abbreviation', api.metadata.serviceAbbreviation);
+ property(this, 'fullName', api.metadata.serviceFullName);
+
+ memoizedProperty(this, 'className', function() {
+ var name = api.metadata.serviceAbbreviation || api.metadata.serviceFullName;
+ if (!name) return null;
+
+ name = name.replace(/^Amazon|AWS\s*|\(.*|\s+|\W+/g, '');
+ if (name === 'ElasticLoadBalancing') name = 'ELB';
+ return name;
+ });
+
+ property(this, 'operations', new Collection(api.operations, options, function(name, operation) {
+ return new Operation(name, operation, options);
+ }, util.string.lowerFirst));
+
+ property(this, 'shapes', new Collection(api.shapes, options, function(name, shape) {
+ return Shape.create(shape, options);
+ }));
+
+ property(this, 'paginators', new Collection(api.paginators, options, function(name, paginator) {
+ return new Paginator(name, paginator, options);
+ }));
+
+ property(this, 'waiters', new Collection(api.waiters, options, function(name, waiter) {
+ return new ResourceWaiter(name, waiter, options);
+ }, util.string.lowerFirst));
+
+ if (options.documentation) {
+ property(this, 'documentation', api.documentation);
+ property(this, 'documentationUrl', api.documentationUrl);
+ }
+}
+
+module.exports = Api;
+
+},{"../util":51,"./collection":16,"./operation":17,"./paginator":18,"./resource_waiter":19,"./shape":20}],16:[function(require,module,exports){
+var memoizedProperty = require('../util').memoizedProperty;
+
+function memoize(name, value, fn, nameTr) {
+ memoizedProperty(this, nameTr(name), function() {
+ return fn(name, value);
+ });
+}
+
+function Collection(iterable, options, fn, nameTr) {
+ nameTr = nameTr || String;
+ var self = this;
+
+ for (var id in iterable) {
+ if (iterable.hasOwnProperty(id)) {
+ memoize.call(self, id, iterable[id], fn, nameTr);
+ }
+ }
+}
+
+module.exports = Collection;
+
+},{"../util":51}],17:[function(require,module,exports){
+var Shape = require('./shape');
+
+var util = require('../util');
+var property = util.property;
+var memoizedProperty = util.memoizedProperty;
+
+function Operation(name, operation, options) {
+ options = options || {};
+
+ property(this, 'name', operation.name || name);
+ property(this, 'api', options.api, false);
+
+ operation.http = operation.http || {};
+ property(this, 'httpMethod', operation.http.method || 'POST');
+ property(this, 'httpPath', operation.http.requestUri || '/');
+
+ memoizedProperty(this, 'input', function() {
+ if (!operation.input) {
+ return new Shape.create({type: 'structure'}, options);
+ }
+ return Shape.create(operation.input, options);
+ });
+
+ memoizedProperty(this, 'output', function() {
+ if (!operation.output) {
+ return new Shape.create({type: 'structure'}, options);
+ }
+ return Shape.create(operation.output, options);
+ });
+
+ memoizedProperty(this, 'errors', function() {
+ var list = [];
+ if (!operation.errors) return null;
+
+ for (var i = 0; i < operation.errors.length; i++) {
+ list.push(Shape.create(operation.errors[i], options));
+ }
+
+ return list;
+ });
+
+ memoizedProperty(this, 'paginator', function() {
+ return options.api.paginators[name];
+ });
+
+ if (options.documentation) {
+ property(this, 'documentation', operation.documentation);
+ property(this, 'documentationUrl', operation.documentationUrl);
+ }
+}
+
+module.exports = Operation;
+
+},{"../util":51,"./shape":20}],18:[function(require,module,exports){
+var property = require('../util').property;
+
+function Paginator(name, paginator) {
+ property(this, 'inputToken', paginator.input_token);
+ property(this, 'limitKey', paginator.limit_key);
+ property(this, 'moreResults', paginator.more_results);
+ property(this, 'outputToken', paginator.output_token);
+ property(this, 'resultKey', paginator.result_key);
+}
+
+module.exports = Paginator;
+
+},{"../util":51}],19:[function(require,module,exports){
+var util = require('../util');
+var property = util.property;
+
+function ResourceWaiter(name, waiter, options) {
+ options = options || {};
+
+ function InnerResourceWaiter() {
+ property(this, 'name', name);
+ property(this, 'api', options.api, false);
+
+ if (waiter.operation) {
+ property(this, 'operation', util.string.lowerFirst(waiter.operation));
+ }
+
+ var self = this, map = {
+ ignoreErrors: 'ignore_errors',
+ successType: 'success_type',
+ successValue: 'success_value',
+ successPath: 'success_path',
+ acceptorType: 'acceptor_type',
+ acceptorValue: 'acceptor_value',
+ acceptorPath: 'acceptor_path',
+ failureType: 'failure_type',
+ failureValue: 'failure_value',
+ failurePath: 'success_path',
+ interval: 'interval',
+ maxAttempts: 'max_attempts'
+ };
+ Object.keys(map).forEach(function(key) {
+ var value = waiter[map[key]];
+ if (value) property(self, key, value);
+ });
+ }
+
+ if (options.api) {
+ var proto = null;
+ if (waiter['extends']) {
+ proto = options.api.waiters[waiter['extends']];
+ } else if (name !== '__default__') {
+ proto = options.api.waiters['__default__'];
+ }
+
+ if (proto) InnerResourceWaiter.prototype = proto;
+ }
+
+ return new InnerResourceWaiter();
+}
+
+module.exports = ResourceWaiter;
+
+},{"../util":51}],20:[function(require,module,exports){
+var Collection = require('./collection');
+
+var util = require('../util');
+
+function property(obj, name, value) {
+ if (value !== null && value !== undefined) {
+ util.property.apply(this, arguments);
+ }
+}
+
+function memoizedProperty(obj, name) {
+ if (!obj.constructor.prototype[name]) {
+ util.memoizedProperty.apply(this, arguments);
+ }
+}
+
+function Shape(shape, options, memberName) {
+ options = options || {};
+
+ property(this, 'shape', shape.shape);
+ property(this, 'api', options.api, false);
+ property(this, 'type', shape.type);
+ property(this, 'location', shape.location || this.location || 'body');
+ property(this, 'name', this.name || shape.xmlName || shape.queryName ||
+ shape.locationName || memberName);
+ property(this, 'isStreaming', shape.streaming || this.isStreaming || false);
+ property(this, 'isComposite', shape.isComposite || false);
+ property(this, 'isShape', true, false);
+ property(this, 'isQueryName', shape.queryName ? true : false, false);
+ property(this, 'isLocationName', shape.locationName ? true : false, false);
+
+ if (options.documentation) {
+ property(this, 'documentation', shape.documentation);
+ property(this, 'documentationUrl', shape.documentationUrl);
+ }
+
+ if (shape.xmlAttribute) {
+ property(this, 'isXmlAttribute', shape.xmlAttribute || false);
+ }
+
+ property(this, 'defaultValue', null);
+ this.toWireFormat = function(value) {
+ if (value === null || value === undefined) return '';
+ return value;
+ };
+ this.toType = function(value) { return value; };
+}
+
+
+Shape.normalizedTypes = {
+ character: 'string',
+ double: 'float',
+ long: 'integer',
+ short: 'integer',
+ biginteger: 'integer',
+ bigdecimal: 'float',
+ blob: 'binary'
+};
+
+
+Shape.types = {
+ 'structure': StructureShape,
+ 'list': ListShape,
+ 'map': MapShape,
+ 'boolean': BooleanShape,
+ 'timestamp': TimestampShape,
+ 'float': FloatShape,
+ 'integer': IntegerShape,
+ 'string': StringShape,
+ 'base64': Base64Shape,
+ 'binary': BinaryShape
+};
+
+Shape.resolve = function resolve(shape, options) {
+ if (shape.shape) {
+ var refShape = options.api.shapes[shape.shape];
+ if (!refShape) {
+ throw new Error('Cannot find shape reference: ' + shape.shape);
+ }
+
+ return refShape;
+ } else {
+ return null;
+ }
+};
+
+Shape.create = function create(shape, options, memberName) {
+ if (shape.isShape) return shape;
+
+ var refShape = Shape.resolve(shape, options);
+ if (refShape) {
+ var filteredKeys = Object.keys(shape);
+ if (!options.documentation) {
+ filteredKeys = filteredKeys.filter(function(name) {
+ return !name.match(/documentation/);
+ });
+ }
+ if (filteredKeys === ['shape']) { // no inline customizations
+ return refShape;
+ }
+
+ var InlineShape = function() {
+ refShape.constructor.call(this, shape, options, memberName);
+ };
+ InlineShape.prototype = refShape;
+ return new InlineShape();
+ } else {
+ if (!shape.type) {
+ if (shape.members) shape.type = 'structure';
+ else if (shape.member) shape.type = 'list';
+ else if (shape.key) shape.type = 'map';
+ else shape.type = 'string';
+ }
+
+ var origType = shape.type;
+ if (Shape.normalizedTypes[shape.type]) {
+ shape.type = Shape.normalizedTypes[shape.type];
+ }
+
+ if (Shape.types[shape.type]) {
+ return new Shape.types[shape.type](shape, options, memberName);
+ } else {
+ throw new Error('Unrecognized shape type: ' + origType);
+ }
+ }
+};
+
+function CompositeShape(shape) {
+ Shape.apply(this, arguments);
+ property(this, 'isComposite', true);
+
+ if (shape.flattened) {
+ property(this, 'flattened', shape.flattened || false);
+ }
+}
+
+function StructureShape(shape, options) {
+ var requiredMap = null, firstInit = !this.isShape;
+
+ CompositeShape.apply(this, arguments);
+
+ if (firstInit) {
+ property(this, 'defaultValue', function() { return {}; });
+ property(this, 'members', {});
+ property(this, 'memberNames', []);
+ property(this, 'required', []);
+ property(this, 'isRequired', function() { return false; });
+ }
+
+ if (shape.members) {
+ property(this, 'members', new Collection(shape.members, options, function(name, member) {
+ return Shape.create(member, options, name);
+ }));
+ memoizedProperty(this, 'memberNames', function() {
+ return shape.xmlOrder || Object.keys(shape.members);
+ });
+ }
+
+ if (shape.required) {
+ property(this, 'required', shape.required);
+ property(this, 'isRequired', function(name) {
+ if (!requiredMap) {
+ requiredMap = {};
+ for (var i = 0; i < shape.required.length; i++) {
+ requiredMap[shape.required[i]] = true;
+ }
+ }
+
+ return requiredMap[name];
+ }, false, true);
+ }
+
+ property(this, 'resultWrapper', shape.resultWrapper || null);
+
+ if (shape.payload) {
+ property(this, 'payload', shape.payload);
+ }
+
+ if (typeof shape.xmlNamespace === 'string') {
+ property(this, 'xmlNamespaceUri', shape.xmlNamespace);
+ } else if (typeof shape.xmlNamespace === 'object') {
+ property(this, 'xmlNamespacePrefix', shape.xmlNamespace.prefix);
+ property(this, 'xmlNamespaceUri', shape.xmlNamespace.uri);
+ }
+}
+
+function ListShape(shape, options) {
+ var self = this, firstInit = !this.isShape;
+ CompositeShape.apply(this, arguments);
+
+ if (firstInit) {
+ property(this, 'defaultValue', function() { return []; });
+ }
+
+ if (shape.member) {
+ memoizedProperty(this, 'member', function() {
+ return Shape.create(shape.member, options);
+ });
+ }
+
+ if (this.flattened) {
+ var oldName = this.name;
+ memoizedProperty(this, 'name', function() {
+ return self.member.name || oldName;
+ });
+ }
+}
+
+function MapShape(shape, options) {
+ var firstInit = !this.isShape;
+ CompositeShape.apply(this, arguments);
+
+ if (firstInit) {
+ property(this, 'defaultValue', function() { return {}; });
+ property(this, 'key', Shape.create({type: 'string'}, options));
+ property(this, 'value', Shape.create({type: 'string'}, options));
+ }
+
+ if (shape.key) {
+ memoizedProperty(this, 'key', function() {
+ return Shape.create(shape.key, options);
+ });
+ }
+ if (shape.value) {
+ memoizedProperty(this, 'value', function() {
+ return Shape.create(shape.value, options);
+ });
+ }
+}
+
+function TimestampShape(shape) {
+ var self = this;
+ Shape.apply(this, arguments);
+
+ if (this.location === 'header') {
+ property(this, 'timestampFormat', 'rfc822');
+ } else if (shape.timestampFormat) {
+ property(this, 'timestampFormat', shape.timestampFormat);
+ } else if (this.api) {
+ if (this.api.timestampFormat) {
+ property(this, 'timestampFormat', this.api.timestampFormat);
+ } else {
+ switch (this.api.protocol) {
+ case 'json':
+ case 'rest-json':
+ property(this, 'timestampFormat', 'unixTimestamp');
+ break;
+ case 'rest-xml':
+ case 'query':
+ case 'ec2':
+ property(this, 'timestampFormat', 'iso8601');
+ break;
+ }
+ }
+ }
+
+ this.toType = function(value) {
+ if (value === null || value === undefined) return null;
+ if (typeof value.toUTCString === 'function') return value;
+ return typeof value === 'string' || typeof value === 'number' ?
+ util.date.parseTimestamp(value) : null;
+ };
+
+ this.toWireFormat = function(value) {
+ return util.date.format(value, self.timestampFormat);
+ };
+}
+
+function StringShape() {
+ Shape.apply(this, arguments);
+
+ if (this.api) {
+ switch (this.api.protocol) {
+ case 'rest-xml':
+ case 'query':
+ case 'ec2':
+ this.toType = function(value) { return value || ''; };
+ }
+ }
+}
+
+function FloatShape() {
+ Shape.apply(this, arguments);
+
+ this.toType = function(value) {
+ if (value === null || value === undefined) return null;
+ return parseFloat(value);
+ };
+ this.toWireFormat = this.toType;
+}
+
+function IntegerShape() {
+ Shape.apply(this, arguments);
+
+ this.toType = function(value) {
+ if (value === null || value === undefined) return null;
+ return parseInt(value, 10);
+ };
+ this.toWireFormat = this.toType;
+}
+
+function BinaryShape() {
+ Shape.apply(this, arguments);
+ this.toType = util.base64.decode;
+ this.toWireFormat = util.base64.encode;
+}
+
+function Base64Shape() {
+ BinaryShape.apply(this, arguments);
+}
+
+function BooleanShape() {
+ Shape.apply(this, arguments);
+
+ this.toType = function(value) {
+ if (typeof value === 'boolean') return value;
+ if (value === null || value === undefined) return null;
+ return value === 'true';
+ };
+}
+
+
+Shape.shapes = {
+ StructureShape: StructureShape,
+ ListShape: ListShape,
+ MapShape: MapShape,
+ StringShape: StringShape,
+ BooleanShape: BooleanShape,
+ Base64Shape: Base64Shape
+};
+
+module.exports = Shape;
+
+},{"../util":51,"./collection":16}],21:[function(require,module,exports){
+var AWS = require('./core');
+
+
+AWS.ParamValidator = AWS.util.inherit({
+ validate: function validate(shape, params, context) {
+ this.errors = [];
+ this.validateMember(shape, params || {}, context || 'params');
+
+ if (this.errors.length > 1) {
+ var msg = this.errors.join('\n* ');
+ if (this.errors.length > 1) {
+ msg = 'There were ' + this.errors.length +
+ ' validation errors:\n* ' + msg;
+ throw AWS.util.error(new Error(msg),
+ {code: 'MultipleValidationErrors', errors: this.errors});
+ }
+ } else if (this.errors.length === 1) {
+ throw this.errors[0];
+ } else {
+ return true;
+ }
+ },
+
+ validateStructure: function validateStructure(shape, params, context) {
+ this.validateType(context, params, ['object'], 'structure');
+
+ var paramName;
+ for (var i = 0; shape.required && i < shape.required.length; i++) {
+ paramName = shape.required[i];
+ var value = params[paramName];
+ if (value === undefined || value === null) {
+ this.fail('MissingRequiredParameter',
+ 'Missing required key \'' + paramName + '\' in ' + context);
+ }
+ }
+
+ for (paramName in params) {
+ if (!params.hasOwnProperty(paramName)) continue;
+
+ var paramValue = params[paramName],
+ memberShape = shape.members[paramName];
+
+ if (memberShape !== undefined) {
+ var memberContext = [context, paramName].join('.');
+ this.validateMember(memberShape, paramValue, memberContext);
+ } else {
+ this.fail('UnexpectedParameter',
+ 'Unexpected key \'' + paramName + '\' found in ' + context);
+ }
+ }
+
+ return true;
+ },
+
+ validateMember: function validateMember(shape, param, context) {
+ switch (shape.type) {
+ case 'structure':
+ return this.validateStructure(shape, param, context);
+ case 'list':
+ return this.validateList(shape, param, context);
+ case 'map':
+ return this.validateMap(shape, param, context);
+ default:
+ return this.validateScalar(shape, param, context);
+ }
+ },
+
+ validateList: function validateList(shape, params, context) {
+ this.validateType(context, params, [Array]);
+
+ for (var i = 0; i < params.length; i++) {
+ this.validateMember(shape.member, params[i], context + '[' + i + ']');
+ }
+ },
+
+ validateMap: function validateMap(shape, params, context) {
+ this.validateType(context, params, ['object'], 'map');
+
+ for (var param in params) {
+ if (!params.hasOwnProperty(param)) continue;
+ this.validateMember(shape.value, params[param],
+ context + '[\'' + param + '\']');
+ }
+ },
+
+ validateScalar: function validateScalar(shape, value, context) {
+ switch (shape.type) {
+ case null:
+ case undefined:
+ case 'string':
+ return this.validateType(context, value, ['string']);
+ case 'base64':
+ case 'binary':
+ return this.validatePayload(context, value);
+ case 'integer':
+ case 'float':
+ return this.validateNumber(context, value);
+ case 'boolean':
+ return this.validateType(context, value, ['boolean']);
+ case 'timestamp':
+ return this.validateType(context, value, [Date,
+ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/, 'number'],
+ 'Date object, ISO-8601 string, or a UNIX timestamp');
+ default:
+ return this.fail('UnkownType', 'Unhandled type ' +
+ shape.type + ' for ' + context);
+ }
+ },
+
+ fail: function fail(code, message) {
+ this.errors.push(AWS.util.error(new Error(message), {code: code}));
+ },
+
+ validateType: function validateType(context, value, acceptedTypes, type) {
+ if (value === null || value === undefined) return;
+
+ var foundInvalidType = false;
+ for (var i = 0; i < acceptedTypes.length; i++) {
+ if (typeof acceptedTypes[i] === 'string') {
+ if (typeof value === acceptedTypes[i]) return;
+ } else if (acceptedTypes[i] instanceof RegExp) {
+ if ((value || '').toString().match(acceptedTypes[i])) return;
+ } else {
+ if (value instanceof acceptedTypes[i]) return;
+ if (AWS.util.isType(value, acceptedTypes[i])) return;
+ if (!type && !foundInvalidType) acceptedTypes = acceptedTypes.slice();
+ acceptedTypes[i] = AWS.util.typeName(acceptedTypes[i]);
+ }
+ foundInvalidType = true;
+ }
+
+ var acceptedType = type;
+ if (!acceptedType) {
+ acceptedType = acceptedTypes.join(', ').replace(/,([^,]+)$/, ', or$1');
+ }
+
+ var vowel = acceptedType.match(/^[aeiou]/i) ? 'n' : '';
+ this.fail('InvalidParameterType', 'Expected ' + context + ' to be a' +
+ vowel + ' ' + acceptedType);
+ },
+
+ validateNumber: function validateNumber(context, value) {
+ if (value === null || value === undefined) return;
+ if (typeof value === 'string') {
+ var castedValue = parseFloat(value);
+ if (castedValue.toString() === value) value = castedValue;
+ }
+ this.validateType(context, value, ['number']);
+ },
+
+ validatePayload: function validatePayload(context, value) {
+ if (value === null || value === undefined) return;
+ if (typeof value === 'string') return;
+ if (value && typeof value.byteLength === 'number') return; // typed arrays
+ if (AWS.util.isNode()) { // special check for buffer/stream in Node.js
+ var Stream = AWS.util.nodeRequire('stream').Stream;
+ if (AWS.util.Buffer.isBuffer(value) || value instanceof Stream) return;
+ }
+
+ var types = ['Buffer', 'Stream', 'File', 'Blob', 'ArrayBuffer', 'DataView'];
+ if (value) {
+ for (var i = 0; i < types.length; i++) {
+ if (AWS.util.isType(value, types[i])) return;
+ if (AWS.util.typeName(value.constructor) === types[i]) return;
+ }
+ }
+
+ this.fail('InvalidParameterType', 'Expected ' + context + ' to be a ' +
+ 'string, Buffer, Stream, Blob, or typed array object');
+ }
+});
+
+},{"./core":3}],22:[function(require,module,exports){
+var util = require('../util');
+var JsonBuilder = require('../json/builder');
+var JsonParser = require('../json/parser');
+
+function buildRequest(req) {
+ var httpRequest = req.httpRequest;
+ var api = req.service.api;
+ var target = api.targetPrefix + '.' + api.operations[req.operation].name;
+ var version = api.jsonVersion || '1.0';
+ var input = api.operations[req.operation].input;
+ var builder = new JsonBuilder();
+
+ if (version === 1) version = '1.0';
+ httpRequest.body = builder.build(req.params || {}, input);
+ httpRequest.headers['Content-Type'] = 'application/x-amz-json-' + version;
+ httpRequest.headers['X-Amz-Target'] = target;
+}
+
+function extractError(resp) {
+ var error = {};
+ var httpResponse = resp.httpResponse;
+
+ error.code = httpResponse.headers['x-amzn-errortype'] || 'UnknownError';
+ if (typeof error.code === 'string') {
+ error.code = error.code.split(':')[0];
+ }
+
+ if (httpResponse.body.length > 0) {
+ var e = JSON.parse(httpResponse.body.toString());
+ if (e.__type || e.code) {
+ error.code = (e.__type || e.code).split('#').pop();
+ }
+ if (error.code === 'RequestEntityTooLarge') {
+ error.message = 'Request body must be less than 1 MB';
+ } else {
+ error.message = (e.message || e.Message || null);
+ }
+ } else {
+ error.statusCode = httpResponse.statusCode;
+ error.message = httpResponse.statusCode.toString();
+ }
+
+ resp.error = util.error(new Error(), error);
+}
+
+function extractData(resp) {
+ var body = resp.httpResponse.body.toString() || '{}';
+ if (resp.request.service.config.convertResponseTypes === false) {
+ resp.data = JSON.parse(body);
+ } else {
+ var operation = resp.request.service.api.operations[resp.request.operation];
+ var shape = operation.output || {};
+ var parser = new JsonParser();
+ resp.data = parser.parse(body, shape);
+ }
+}
+
+module.exports = {
+ buildRequest: buildRequest,
+ extractError: extractError,
+ extractData: extractData
+};
+
+},{"../json/builder":13,"../json/parser":14,"../util":51}],23:[function(require,module,exports){
+var AWS = require('../core');
+var util = require('../util');
+var QueryParamSerializer = require('../query/query_param_serializer');
+var Shape = require('../model/shape');
+
+function buildRequest(req) {
+ var operation = req.service.api.operations[req.operation];
+ var httpRequest = req.httpRequest;
+ httpRequest.headers['Content-Type'] =
+ 'application/x-www-form-urlencoded; charset=utf-8';
+ httpRequest.params = {
+ Version: req.service.api.apiVersion,
+ Action: operation.name
+ };
+
+ var builder = new QueryParamSerializer();
+ builder.serialize(req.params, operation.input, function(name, value) {
+ httpRequest.params[name] = value;
+ });
+ httpRequest.body = util.queryParamsToString(httpRequest.params);
+}
+
+function extractError(resp) {
+ var data, body = resp.httpResponse.body.toString();
+ if (body.match('= 0 ? '&' : '?');
+ var parts = [];
+ util.arrayEach(Object.keys(queryString).sort(), function(key) {
+ if (!Array.isArray(queryString[key])) {
+ queryString[key] = [queryString[key]];
+ }
+ for (var i = 0; i < queryString[key].length; i++) {
+ parts.push(util.uriEscape(String(key)) + '=' + queryString[key][i]);
+ }
+ });
+ uri += parts.join('&');
+ }
+
+ req.httpRequest.path = uri;
+}
+
+function populateHeaders(req) {
+ var operation = req.service.api.operations[req.operation];
+ util.each(operation.input.members, function (name, member) {
+ var value = req.params[name];
+ if (value === null || value === undefined) return;
+
+ if (member.location === 'headers' && member.type === 'map') {
+ util.each(value, function(key, memberValue) {
+ req.httpRequest.headers[member.name + key] = memberValue;
+ });
+ } else if (member.location === 'header') {
+ value = member.toWireFormat(value).toString();
+ req.httpRequest.headers[member.name] = value;
+ }
+ });
+}
+
+function buildRequest(req) {
+ populateMethod(req);
+ populateURI(req);
+ populateHeaders(req);
+}
+
+function extractError() {
+}
+
+function extractData(resp) {
+ var req = resp.request;
+ var data = {};
+ var r = resp.httpResponse;
+ var operation = req.service.api.operations[req.operation];
+ var output = operation.output;
+
+ var headers = {};
+ util.each(r.headers, function (k, v) {
+ headers[k.toLowerCase()] = v;
+ });
+
+ util.each(output.members, function(name, member) {
+ var header = (member.name || name).toLowerCase();
+ if (member.location === 'headers' && member.type === 'map') {
+ data[name] = {};
+ var location = member.isLocationName ? member.name : '';
+ var pattern = new RegExp('^' + location + '(.+)', 'i');
+ util.each(r.headers, function (k, v) {
+ var result = k.match(pattern);
+ if (result !== null) {
+ data[name][result[1]] = v;
+ }
+ });
+ } else if (member.location === 'header') {
+ if (headers[header] !== undefined) {
+ data[name] = headers[header];
+ }
+ } else if (member.location === 'statusCode') {
+ data[name] = parseInt(r.statusCode, 10);
+ }
+ });
+
+ resp.data = data;
+}
+
+module.exports = {
+ buildRequest: buildRequest,
+ extractError: extractError,
+ extractData: extractData
+};
+
+},{"../util":51}],25:[function(require,module,exports){
+var util = require('../util');
+var Rest = require('./rest');
+var Json = require('./json');
+var JsonBuilder = require('../json/builder');
+var JsonParser = require('../json/parser');
+
+function populateBody(req) {
+ var builder = new JsonBuilder();
+ var input = req.service.api.operations[req.operation].input;
+
+ if (input.payload) {
+ var params = {};
+ var payloadShape = input.members[input.payload];
+ params = req.params[input.payload];
+ if (params === undefined) return;
+
+ if (payloadShape.type === 'structure') {
+ req.httpRequest.body = builder.build(params, payloadShape);
+ } else { // non-JSON payload
+ req.httpRequest.body = params;
+ }
+ } else {
+ req.httpRequest.body = builder.build(req.params, input);
+ }
+}
+
+function buildRequest(req) {
+ Rest.buildRequest(req);
+
+ if (['GET', 'HEAD'].indexOf(req.httpRequest.method) < 0) {
+ populateBody(req);
+ }
+}
+
+function extractError(resp) {
+ Json.extractError(resp);
+}
+
+function extractData(resp) {
+ Rest.extractData(resp);
+
+ var req = resp.request;
+ var rules = req.service.api.operations[req.operation].output || {};
+ if (rules.payload) {
+ var payloadMember = rules.members[rules.payload];
+ var body = resp.httpResponse.body;
+ if (payloadMember.isStreaming) {
+ resp.data[rules.payload] = body;
+ } else if (payloadMember.type === 'structure') {
+ var parser = new JsonParser();
+ resp.data[rules.payload] = parser.parse(body, payloadMember);
+ } else {
+ resp.data[rules.payload] = body.toString();
+ }
+ } else {
+ var data = resp.data;
+ Json.extractData(resp);
+ resp.data = util.merge(data, resp.data);
+ }
+}
+
+module.exports = {
+ buildRequest: buildRequest,
+ extractError: extractError,
+ extractData: extractData
+};
+
+},{"../json/builder":13,"../json/parser":14,"../util":51,"./json":22,"./rest":24}],26:[function(require,module,exports){
+var AWS = require('../core');
+var util = require('../util');
+var Rest = require('./rest');
+
+function populateBody(req) {
+ var input = req.service.api.operations[req.operation].input;
+ var builder = new AWS.XML.Builder();
+ var params = req.params;
+
+ var payload = input.payload;
+ if (payload) {
+ var payloadMember = input.members[payload];
+ params = params[payload];
+ if (params === undefined) return;
+
+ if (payloadMember.type === 'structure') {
+ var rootElement = payloadMember.name;
+ req.httpRequest.body = builder.toXML(params, payloadMember, rootElement, true);
+ } else { // non-xml payload
+ req.httpRequest.body = params;
+ }
+ } else {
+ req.httpRequest.body = builder.toXML(params, input, input.name ||
+ input.shape || util.string.upperFirst(req.operation) + 'Request');
+ }
+}
+
+function buildRequest(req) {
+ Rest.buildRequest(req);
+
+ if (['GET', 'HEAD'].indexOf(req.httpRequest.method) < 0) {
+ populateBody(req);
+ }
+}
+
+function extractError(resp) {
+ Rest.extractError(resp);
+
+ var data = new AWS.XML.Parser().parse(resp.httpResponse.body.toString());
+ if (data.Errors) data = data.Errors;
+ if (data.Error) data = data.Error;
+ if (data.Code) {
+ resp.error = util.error(new Error(), {
+ code: data.Code,
+ message: data.Message
+ });
+ } else {
+ resp.error = util.error(new Error(), {
+ code: resp.httpResponse.statusCode,
+ message: null
+ });
+ }
+}
+
+function extractData(resp) {
+ Rest.extractData(resp);
+
+ var parser;
+ var req = resp.request;
+ var body = resp.httpResponse.body;
+ var operation = req.service.api.operations[req.operation];
+ var output = operation.output;
+
+ var payload = output.payload;
+ if (payload) {
+ var payloadMember = output.members[payload];
+ if (payloadMember.isStreaming) {
+ resp.data[payload] = body;
+ } else if (payloadMember.type === 'structure') {
+ parser = new AWS.XML.Parser();
+ resp.data[payload] = parser.parse(body.toString(), payloadMember);
+ } else {
+ resp.data[payload] = body.toString();
+ }
+ } else if (body.length > 0) {
+ parser = new AWS.XML.Parser();
+ var data = parser.parse(body.toString(), output);
+ util.update(resp.data, data);
+ }
+}
+
+module.exports = {
+ buildRequest: buildRequest,
+ extractError: extractError,
+ extractData: extractData
+};
+
+},{"../core":3,"../util":51,"./rest":24}],27:[function(require,module,exports){
+var util = require('../util');
+
+function QueryParamSerializer() {
+}
+
+QueryParamSerializer.prototype.serialize = function(params, shape, fn) {
+ serializeStructure('', params, shape, fn);
+};
+
+function ucfirst(shape) {
+ if (shape.isQueryName || shape.api.protocol !== 'ec2') {
+ return shape.name;
+ } else {
+ return shape.name[0].toUpperCase() + shape.name.substr(1);
+ }
+}
+
+function serializeStructure(prefix, struct, rules, fn) {
+ util.each(rules.members, function(name, member) {
+ var value = struct[name];
+ if (value === null || value === undefined) return;
+
+ var memberName = ucfirst(member);
+ memberName = prefix ? prefix + '.' + memberName : memberName;
+ serializeMember(memberName, value, member, fn);
+ });
+}
+
+function serializeMap(name, map, rules, fn) {
+ var i = 1;
+ util.each(map, function (key, value) {
+ var prefix = rules.flattened ? '.' : '.entry.';
+ var position = prefix + (i++) + '.';
+ var keyName = position + (rules.key.name || 'key');
+ var valueName = position + (rules.value.name || 'value');
+ serializeMember(name + keyName, key, rules.key, fn);
+ serializeMember(name + valueName, value, rules.value, fn);
+ });
+}
+
+function serializeList(name, list, rules, fn) {
+ var memberRules = rules.member || {};
+
+ if (list.length === 0) {
+ fn.call(this, name, null);
+ return;
+ }
+
+ util.arrayEach(list, function (v, n) {
+ var suffix = '.' + (n + 1);
+ if (rules.api.protocol === 'ec2') {
+ suffix = suffix + ''; // make linter happy
+ } else if (rules.flattened) {
+ if (memberRules.name) {
+ var parts = name.split('.');
+ parts.pop();
+ parts.push(ucfirst(memberRules));
+ name = parts.join('.');
+ }
+ } else {
+ suffix = '.member' + suffix;
+ }
+ serializeMember(name + suffix, v, memberRules, fn);
+ });
+}
+
+function serializeMember(name, value, rules, fn) {
+ if (value === null || value === undefined) return;
+ if (rules.type === 'structure') {
+ serializeStructure(name, value, rules, fn);
+ } else if (rules.type === 'list') {
+ serializeList(name, value, rules, fn);
+ } else if (rules.type === 'map') {
+ serializeMap(name, value, rules, fn);
+ } else {
+ fn(name, rules.toWireFormat(value).toString());
+ }
+}
+
+module.exports = QueryParamSerializer;
+
+},{"../util":51}],28:[function(require,module,exports){
+var util = require('./util');
+var regionConfig = require('./region_config.json');
+
+function generateRegionPrefix(region) {
+ if (!region) return null;
+
+ var parts = region.split('-');
+ if (parts.length < 3) return null;
+ return parts.slice(0, parts.length - 2).join('-') + '-*';
+}
+
+function derivedKeys(service) {
+ var region = service.config.region;
+ var regionPrefix = generateRegionPrefix(region);
+ var endpointPrefix = service.api.endpointPrefix;
+
+ return [
+ [region, endpointPrefix],
+ [regionPrefix, endpointPrefix],
+ [region, '*'],
+ [regionPrefix, '*'],
+ ['*', endpointPrefix],
+ ['*', '*']
+ ].map(function(item) {
+ return item[0] && item[1] ? item.join('/') : null;
+ });
+}
+
+function applyConfig(service, config) {
+ util.each(config, function(key, value) {
+ if (key === 'globalEndpoint') return;
+ if (service.config[key] === undefined || service.config[key] === null) {
+ service.config[key] = value;
+ }
+ });
+}
+
+function configureEndpoint(service) {
+ var keys = derivedKeys(service);
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ if (!key) continue;
+
+ if (regionConfig.rules.hasOwnProperty(key)) {
+ var config = regionConfig.rules[key];
+ if (typeof config === 'string') {
+ config = regionConfig.patterns[config];
+ }
+
+ service.isGlobalEndpoint = !!config.globalEndpoint;
+
+ if (!config.signatureVersion) config.signatureVersion = 'v4';
+
+ applyConfig(service, config);
+ return;
+ }
+ }
+}
+
+module.exports = configureEndpoint;
+
+},{"./region_config.json":29,"./util":51}],29:[function(require,module,exports){
+module.exports={
+ "rules": {
+ "*/*": {
+ "endpoint": "{service}.{region}.amazonaws.com"
+ },
+ "cn-*/*": {
+ "endpoint": "{service}.{region}.amazonaws.com.cn"
+ },
+ "*/cloudfront": "globalSSL",
+ "*/iam": "globalSSL",
+ "*/sts": "globalSSL",
+ "*/importexport": {
+ "endpoint": "{service}.amazonaws.com",
+ "signatureVersion": "v2",
+ "globalEndpoint": true
+ },
+ "*/route53": {
+ "endpoint": "https://{service}.amazonaws.com",
+ "signatureVersion": "v3https",
+ "globalEndpoint": true
+ },
+ "us-gov-*/iam": "globalGovCloud",
+ "us-gov-*/sts": {
+ "endpoint": "{service}.{region}.amazonaws.com"
+ },
+ "us-gov-west-1/s3": "s3dash",
+ "us-west-1/s3": "s3dash",
+ "us-west-2/s3": "s3dash",
+ "eu-west-1/s3": "s3dash",
+ "ap-southeast-1/s3": "s3dash",
+ "ap-southeast-2/s3": "s3dash",
+ "ap-northeast-1/s3": "s3dash",
+ "sa-east-1/s3": "s3dash",
+ "us-east-1/s3": {
+ "endpoint": "{service}.amazonaws.com",
+ "signatureVersion": "s3"
+ },
+ "us-east-1/sdb": {
+ "endpoint": "{service}.amazonaws.com",
+ "signatureVersion": "v2"
+ },
+ "*/sdb": {
+ "endpoint": "{service}.{region}.amazonaws.com",
+ "signatureVersion": "v2"
+ }
+ },
+
+ "patterns": {
+ "globalSSL": {
+ "endpoint": "https://{service}.amazonaws.com",
+ "globalEndpoint": true
+ },
+ "globalGovCloud": {
+ "endpoint": "{service}.us-gov.amazonaws.com"
+ },
+ "s3dash": {
+ "endpoint": "{service}-{region}.amazonaws.com",
+ "signatureVersion": "s3"
+ }
+ }
+}
+
+},{}],30:[function(require,module,exports){
+(function (process){
+var AWS = require('./core');
+var AcceptorStateMachine = require('./state_machine');
+var inherit = AWS.util.inherit;
+var domain = AWS.util.nodeRequire('domain');
+
+
+var hardErrorStates = {success: 1, error: 1, complete: 1};
+
+function isTerminalState(machine) {
+ return hardErrorStates.hasOwnProperty(machine._asm.currentState);
+}
+
+var fsm = new AcceptorStateMachine();
+fsm.setupStates = function() {
+ var transition = function(_, done) {
+ var self = this;
+ self._haltHandlersOnError = false;
+
+ self.emit(self._asm.currentState, function(err) {
+ if (err) {
+ if (isTerminalState(self)) {
+ if (domain && self.domain instanceof domain.Domain) {
+ err.domainEmitter = self;
+ err.domain = self.domain;
+ err.domainThrown = false;
+ self.domain.emit('error', err);
+ } else {
+ throw err;
+ }
+ } else {
+ self.response.error = err;
+ done(err);
+ }
+ } else {
+ done(self.response.error);
+ }
+ });
+
+ };
+
+ this.addState('validate', 'build', 'error', transition);
+ this.addState('build', 'afterBuild', 'restart', transition);
+ this.addState('afterBuild', 'sign', 'restart', transition);
+ this.addState('sign', 'send', 'retry', transition);
+ this.addState('retry', 'afterRetry', 'afterRetry', transition);
+ this.addState('afterRetry', 'sign', 'error', transition);
+ this.addState('send', 'validateResponse', 'retry', transition);
+ this.addState('validateResponse', 'extractData', 'extractError', transition);
+ this.addState('extractError', 'extractData', 'retry', transition);
+ this.addState('extractData', 'success', 'retry', transition);
+ this.addState('restart', 'build', 'error', transition);
+ this.addState('success', 'complete', 'complete', transition);
+ this.addState('error', 'complete', 'complete', transition);
+ this.addState('complete', null, null, transition);
+};
+fsm.setupStates();
+
+
+AWS.Request = inherit({
+
+
+ constructor: function Request(service, operation, params) {
+ var endpoint = service.endpoint;
+ var region = service.config.region;
+
+ if (service.isGlobalEndpoint) region = 'us-east-1';
+
+ this.domain = domain && domain.active;
+ this.service = service;
+ this.operation = operation;
+ this.params = params || {};
+ this.httpRequest = new AWS.HttpRequest(endpoint, region);
+ this.startTime = AWS.util.date.getDate();
+
+ this.response = new AWS.Response(this);
+ this._asm = new AcceptorStateMachine(fsm.states, 'validate');
+ this._haltHandlersOnError = false;
+
+ AWS.SequentialExecutor.call(this);
+ this.emit = this.emitEvent;
+ },
+
+
+
+
+ send: function send(callback) {
+ if (callback) {
+ this.on('complete', function (resp) {
+ callback.call(resp, resp.error, resp.data);
+ });
+ }
+ this.runTo();
+
+ return this.response;
+ },
+
+
+ build: function build(callback) {
+ return this.runTo('send', callback);
+ },
+
+
+ runTo: function runTo(state, done) {
+ this._asm.runTo(state, done, this);
+ return this;
+ },
+
+
+ abort: function abort() {
+ this.removeAllListeners('validateResponse');
+ this.removeAllListeners('extractError');
+ this.on('validateResponse', function addAbortedError(resp) {
+ resp.error = AWS.util.error(new Error('Request aborted by user'), {
+ code: 'RequestAbortedError', retryable: false
+ });
+ });
+
+ if (this.httpRequest.stream) { // abort HTTP stream
+ this.httpRequest.stream.abort();
+ if (this.httpRequest._abortCallback) {
+ this.httpRequest._abortCallback();
+ } else {
+ this.removeAllListeners('send'); // haven't sent yet, so let's not
+ }
+ }
+
+ return this;
+ },
+
+
+ eachPage: function eachPage(callback) {
+ callback = AWS.util.fn.makeAsync(callback, 3);
+
+ function wrappedCallback(response) {
+ callback.call(response, response.error, response.data, function (result) {
+ if (result === false) return;
+
+ if (response.hasNextPage()) {
+ response.nextPage().on('complete', wrappedCallback).send();
+ } else {
+ callback.call(response, null, null, AWS.util.fn.noop);
+ }
+ });
+ }
+
+ this.on('complete', wrappedCallback).send();
+ },
+
+
+ eachItem: function eachItem(callback) {
+ var self = this;
+ function wrappedCallback(err, data) {
+ if (err) return callback(err, null);
+ if (data === null) return callback(null, null);
+
+ var config = self.service.paginationConfig(self.operation);
+ var resultKey = config.resultKey;
+ if (Array.isArray(resultKey)) resultKey = resultKey[0];
+ var results = AWS.util.jamespath.query(resultKey, data);
+ AWS.util.arrayEach(results, function(result) {
+ AWS.util.arrayEach(result, function(item) { callback(null, item); });
+ });
+ }
+
+ this.eachPage(wrappedCallback);
+ },
+
+
+ isPageable: function isPageable() {
+ return this.service.paginationConfig(this.operation) ? true : false;
+ },
+
+
+ createReadStream: function createReadStream() {
+ var streams = AWS.util.nodeRequire('stream');
+ var req = this;
+ var stream = null;
+
+ if (AWS.HttpClient.streamsApiVersion === 2) {
+ stream = new streams.PassThrough();
+ req.send();
+ } else {
+ stream = new streams.Stream();
+ stream.readable = true;
+
+ stream.sent = false;
+ stream.on('newListener', function(event) {
+ if (!stream.sent && event === 'data') {
+ stream.sent = true;
+ process.nextTick(function() { req.send(); });
+ }
+ });
+ }
+
+ this.on('httpHeaders', function streamHeaders(statusCode, headers, resp) {
+ if (statusCode < 300) {
+ req.removeListener('httpData', AWS.EventListeners.Core.HTTP_DATA);
+ req.removeListener('httpError', AWS.EventListeners.Core.HTTP_ERROR);
+ req.on('httpError', function streamHttpError(error) {
+ resp.error = error;
+ resp.error.retryable = false;
+ });
+
+ var httpStream = resp.httpResponse.createUnbufferedStream();
+ if (AWS.HttpClient.streamsApiVersion === 2) {
+ httpStream.pipe(stream);
+ } else {
+ httpStream.on('data', function(arg) {
+ stream.emit('data', arg);
+ });
+ httpStream.on('end', function() {
+ stream.emit('end');
+ });
+ }
+
+ httpStream.on('error', function(err) {
+ stream.emit('error', err);
+ });
+ }
+ });
+
+ this.on('error', function(err) {
+ stream.emit('error', err);
+ });
+
+ return stream;
+ },
+
+
+ emitEvent: function emit(eventName, args, done) {
+ if (typeof args === 'function') { done = args; args = null; }
+ if (!done) done = function() { };
+ if (!args) args = this.eventParameters(eventName, this.response);
+
+ var origEmit = AWS.SequentialExecutor.prototype.emit;
+ origEmit.call(this, eventName, args, function (err) {
+ if (err) this.response.error = err;
+ done.call(this, err);
+ });
+ },
+
+
+ eventParameters: function eventParameters(eventName) {
+ switch (eventName) {
+ case 'restart':
+ case 'validate':
+ case 'sign':
+ case 'build':
+ case 'afterValidate':
+ case 'afterBuild':
+ return [this];
+ case 'error':
+ return [this.response.error, this.response];
+ default:
+ return [this.response];
+ }
+ },
+
+
+ presign: function presign(expires, callback) {
+ if (!callback && typeof expires === 'function') {
+ callback = expires;
+ expires = null;
+ }
+ return new AWS.Signers.Presign().sign(this.toGet(), expires, callback);
+ },
+
+
+ toUnauthenticated: function toUnauthenticated() {
+ this.removeListener('validate', AWS.EventListeners.Core.VALIDATE_CREDENTIALS);
+ this.removeListener('sign', AWS.EventListeners.Core.SIGN);
+ return this.toGet();
+ },
+
+
+ toGet: function toGet() {
+ if (this.service.api.protocol === 'query' ||
+ this.service.api.protocol === 'ec2') {
+ this.removeListener('build', this.buildAsGet);
+ this.addListener('build', this.buildAsGet);
+ }
+ return this;
+ },
+
+
+ buildAsGet: function buildAsGet(request) {
+ request.httpRequest.method = 'GET';
+ request.httpRequest.path = request.service.endpoint.path +
+ '?' + request.httpRequest.body;
+ request.httpRequest.body = '';
+
+ delete request.httpRequest.headers['Content-Length'];
+ delete request.httpRequest.headers['Content-Type'];
+ },
+
+
+ haltHandlersOnError: function haltHandlersOnError() {
+ this._haltHandlersOnError = true;
+ }
+});
+
+AWS.util.mixin(AWS.Request, AWS.SequentialExecutor);
+
+}).call(this,require("FWaASH"))
+},{"./core":3,"./state_machine":50,"FWaASH":65}],31:[function(require,module,exports){
+
+
+var AWS = require('./core');
+var inherit = AWS.util.inherit;
+
+
+AWS.ResourceWaiter = inherit({
+
+ constructor: function constructor(service, state) {
+ this.service = service;
+ this.state = state;
+
+ if (typeof this.state === 'object') {
+ AWS.util.each.call(this, this.state, function (key, value) {
+ this.state = key;
+ this.expectedValue = value;
+ });
+ }
+
+ this.loadWaiterConfig(this.state);
+ if (!this.expectedValue) {
+ this.expectedValue = this.config.successValue;
+ }
+ },
+
+ service: null,
+
+ state: null,
+
+ expectedValue: null,
+
+ config: null,
+
+ waitDone: false,
+
+ Listeners: {
+ retry: new AWS.SequentialExecutor().addNamedListeners(function(add) {
+ add('RETRY_CHECK', 'retry', function(resp) {
+ var waiter = resp.request._waiter;
+ if (resp.error && resp.error.code === 'ResourceNotReady') {
+ resp.error.retryDelay = waiter.config.interval * 1000;
+ }
+ });
+ }),
+
+ output: new AWS.SequentialExecutor().addNamedListeners(function(add) {
+ add('CHECK_OUT_ERROR', 'extractError', function CHECK_OUT_ERROR(resp) {
+ if (resp.error) {
+ resp.request._waiter.setError(resp, true);
+ }
+ });
+
+ add('CHECK_OUTPUT', 'extractData', function CHECK_OUTPUT(resp) {
+ var waiter = resp.request._waiter;
+ var success = waiter.checkSuccess(resp);
+ if (!success) {
+ waiter.setError(resp, success === null ? false : true);
+ } else {
+ resp.error = null;
+ }
+ });
+ }),
+
+ error: new AWS.SequentialExecutor().addNamedListeners(function(add) {
+ add('CHECK_ERROR', 'extractError', function CHECK_ERROR(resp) {
+ var waiter = resp.request._waiter;
+ var success = waiter.checkError(resp);
+ if (!success) {
+ waiter.setError(resp, success === null ? false : true);
+ } else {
+ resp.error = null;
+ resp.data = {};
+ resp.request.removeAllListeners('extractData');
+ }
+ });
+
+ add('CHECK_ERR_OUTPUT', 'extractData', function CHECK_ERR_OUTPUT(resp) {
+ resp.request._waiter.setError(resp, true);
+ });
+ })
+ },
+
+
+ wait: function wait(params, callback) {
+ if (typeof params === 'function') {
+ callback = params; params = undefined;
+ }
+
+ var request = this.service.makeRequest(this.config.operation, params);
+ var listeners = this.Listeners[this.config.successType];
+ request._waiter = this;
+ request.response.maxRetries = this.config.maxAttempts;
+ request.addListeners(this.Listeners.retry);
+ if (listeners) request.addListeners(listeners);
+
+ if (callback) request.send(callback);
+ return request;
+ },
+
+ setError: function setError(resp, retryable) {
+ resp.data = null;
+ resp.error = AWS.util.error(resp.error || new Error(), {
+ code: 'ResourceNotReady',
+ message: 'Resource is not in the state ' + this.state,
+ retryable: retryable
+ });
+ },
+
+
+ checkSuccess: function checkSuccess(resp) {
+ if (!this.config.successPath) {
+ return resp.httpResponse.statusCode < 300;
+ }
+
+ var r = AWS.util.jamespath.find(this.config.successPath, resp.data);
+
+ if (this.config.failureValue &&
+ this.config.failureValue.indexOf(r) >= 0) {
+ return null; // fast fail
+ }
+
+ if (this.expectedValue) {
+ return r === this.expectedValue;
+ } else {
+ return r ? true : false;
+ }
+ },
+
+
+ checkError: function checkError(resp) {
+ var value = this.config.successValue;
+ if (typeof value === 'number') {
+ return resp.httpResponse.statusCode === value;
+ } else {
+ return resp.error && resp.error.code === value;
+ }
+ },
+
+
+ loadWaiterConfig: function loadWaiterConfig(state, noException) {
+ if (!this.service.api.waiters[state]) {
+ if (noException) return;
+ throw new AWS.util.error(new Error(), {
+ code: 'StateNotFoundError',
+ message: 'State ' + state + ' not found.'
+ });
+ }
+
+ this.config = this.service.api.waiters[state];
+ var config = this.config;
+
+ (function () { // anonymous function to avoid max complexity count
+ config.successType = config.successType || config.acceptorType;
+ config.successPath = config.successPath || config.acceptorPath;
+ config.successValue = config.successValue || config.acceptorValue;
+ config.failureType = config.failureType || config.acceptorType;
+ config.failurePath = config.failurePath || config.acceptorPath;
+ config.failureValue = config.failureValue || config.acceptorValue;
+ })();
+ }
+});
+
+},{"./core":3}],32:[function(require,module,exports){
+var AWS = require('./core');
+var inherit = AWS.util.inherit;
+
+
+AWS.Response = inherit({
+
+
+ constructor: function Response(request) {
+ this.request = request;
+ this.data = null;
+ this.error = null;
+ this.retryCount = 0;
+ this.redirectCount = 0;
+ this.httpResponse = new AWS.HttpResponse();
+ if (request) {
+ this.maxRetries = request.service.numRetries();
+ this.maxRedirects = request.service.config.maxRedirects;
+ }
+ },
+
+
+ nextPage: function nextPage(callback) {
+ var config;
+ var service = this.request.service;
+ var operation = this.request.operation;
+ try {
+ config = service.paginationConfig(operation, true);
+ } catch (e) { this.error = e; }
+
+ if (!this.hasNextPage()) {
+ if (callback) callback(this.error, null);
+ else if (this.error) throw this.error;
+ return null;
+ }
+
+ var params = AWS.util.copy(this.request.params);
+ if (!this.nextPageTokens) {
+ return callback ? callback(null, null) : null;
+ } else {
+ var inputTokens = config.inputToken;
+ if (typeof inputTokens === 'string') inputTokens = [inputTokens];
+ for (var i = 0; i < inputTokens.length; i++) {
+ params[inputTokens[i]] = this.nextPageTokens[i];
+ }
+ return service.makeRequest(this.request.operation, params, callback);
+ }
+ },
+
+
+ hasNextPage: function hasNextPage() {
+ this.cacheNextPageTokens();
+ if (this.nextPageTokens) return true;
+ if (this.nextPageTokens === undefined) return undefined;
+ else return false;
+ },
+
+
+ cacheNextPageTokens: function cacheNextPageTokens() {
+ if (this.hasOwnProperty('nextPageTokens')) return this.nextPageTokens;
+ this.nextPageTokens = undefined;
+
+ var config = this.request.service.paginationConfig(this.request.operation);
+ if (!config) return this.nextPageTokens;
+
+ this.nextPageTokens = null;
+ if (config.moreResults) {
+ if (!AWS.util.jamespath.find(config.moreResults, this.data)) {
+ return this.nextPageTokens;
+ }
+ }
+
+ var exprs = config.outputToken;
+ if (typeof exprs === 'string') exprs = [exprs];
+ AWS.util.arrayEach.call(this, exprs, function (expr) {
+ var output = AWS.util.jamespath.find(expr, this.data);
+ if (output) {
+ this.nextPageTokens = this.nextPageTokens || [];
+ this.nextPageTokens.push(output);
+ }
+ });
+
+ return this.nextPageTokens;
+ }
+
+});
+
+},{"./core":3}],33:[function(require,module,exports){
+(function (Buffer){
+var AWS = require('../core');
+var byteLength = AWS.util.string.byteLength;
+
+
+AWS.S3.ManagedUpload = AWS.util.inherit({
+
+ constructor: function ManagedUpload(options) {
+ var self = this;
+ AWS.SequentialExecutor.call(self);
+ self.body = null;
+ self.sliceFn = null;
+ self.callback = null;
+ self.parts = {};
+ self.completeInfo = [];
+ self.fillQueue = function() {
+ self.callback(new Error('Unsupported body payload ' + typeof self.body));
+ };
+
+ self.configure(options);
+ },
+
+
+ configure: function configure(options) {
+ options = options || {};
+ this.partSize = this.minPartSize;
+
+ if (options.queueSize) this.queueSize = options.queueSize;
+ if (options.partSize) this.partSize = options.partSize;
+ if (options.leavePartsOnError) this.leavePartsOnError = true;
+
+ if (this.partSize < this.minPartSize) {
+ throw new Error('partSize must be greater than ' +
+ this.minPartSize);
+ }
+
+ this.service = options.service;
+ this.bindServiceObject(options.params);
+ this.validateBody();
+ this.adjustTotalBytes();
+ },
+
+
+ leavePartsOnError: false,
+
+
+ queueSize: 4,
+
+
+ partSize: null,
+
+
+ minPartSize: 1024 * 1024 * 5,
+
+
+ maxTotalParts: 10000,
+
+
+ send: function(callback) {
+ var self = this;
+ self.callback = callback || function(err) { if (err) throw err; };
+
+ var runFill = true;
+ if (self.sliceFn) {
+ self.fillQueue = self.fillBuffer;
+ } else if (AWS.util.isNode()) {
+ var Stream = AWS.util.nodeRequire('stream').Stream;
+ if (self.body instanceof Stream) {
+ runFill = false;
+ self.fillQueue = self.fillStream;
+ self.partBuffers = [];
+ self.body.
+ on('readable', function() { self.fillQueue(); }).
+ on('end', function() {
+ self.isDoneChunking = true;
+ self.numParts = self.totalPartNumbers;
+ self.fillQueue.call(self);
+ });
+ }
+ }
+
+ if (runFill) self.fillQueue.call(self);
+ },
+
+
+ abort: function() {
+ this.cleanup(AWS.util.error(new Error('Request aborted by user'), {
+ code: 'RequestAbortedError', retryable: false
+ }));
+ },
+
+
+ validateBody: function validateBody() {
+ var self = this;
+ self.body = self.service.config.params.Body;
+ if (!self.body) throw new Error('params.Body is required');
+ if (typeof self.body === 'string') {
+ self.body = new AWS.util.Buffer(self.body);
+ }
+ self.sliceFn = AWS.util.arraySliceFn(self.body);
+ },
+
+
+ bindServiceObject: function bindServiceObject(params) {
+ params = params || {};
+ var self = this;
+
+ if (!self.service) {
+ self.service = new AWS.S3({params: params});
+ } else {
+ var config = AWS.util.copy(self.service.config);
+ self.service = new self.service.constructor.__super__(config);
+ self.service.config.params =
+ AWS.util.merge(self.service.config.params || {}, params);
+ }
+ },
+
+
+ adjustTotalBytes: function adjustTotalBytes() {
+ var self = this;
+ try { // try to get totalBytes
+ self.totalBytes = byteLength(self.body);
+ } catch (e) { }
+
+ if (self.totalBytes) {
+ var newPartSize = Math.ceil(self.totalBytes / self.maxTotalParts);
+ if (newPartSize > self.partSize) self.partSize = newPartSize;
+ } else {
+ self.totalBytes = undefined;
+ }
+ },
+
+
+ isDoneChunking: false,
+
+
+ partPos: 0,
+
+
+ totalChunkedBytes: 0,
+
+
+ totalUploadedBytes: 0,
+
+
+ totalBytes: undefined,
+
+
+ numParts: 0,
+
+
+ totalPartNumbers: 0,
+
+
+ activeParts: 0,
+
+
+ doneParts: 0,
+
+
+ parts: null,
+
+
+ completeInfo: null,
+
+
+ failed: false,
+
+
+ multipartReq: null,
+
+
+ partBuffers: null,
+
+
+ partBufferLength: 0,
+
+
+ fillBuffer: function fillBuffer() {
+ var self = this;
+ var bodyLen = byteLength(self.body);
+
+ if (bodyLen === 0) {
+ self.isDoneChunking = true;
+ self.numParts = 1;
+ self.nextChunk(self.body);
+ return;
+ }
+
+ while (self.activeParts < self.queueSize && self.partPos < bodyLen) {
+ var endPos = Math.min(self.partPos + self.partSize, bodyLen);
+ var buf = self.sliceFn.call(self.body, self.partPos, endPos);
+ self.partPos += self.partSize;
+
+ if (byteLength(buf) < self.partSize || self.partPos === bodyLen) {
+ self.isDoneChunking = true;
+ self.numParts = self.totalPartNumbers + 1;
+ }
+ self.nextChunk(buf);
+ }
+ },
+
+
+ fillStream: function fillStream() {
+ var self = this;
+ if (self.activeParts >= self.queueSize) return;
+
+ var buf = self.body.read(self.partSize - self.partBufferLength) ||
+ self.body.read();
+ if (buf) {
+ self.partBuffers.push(buf);
+ self.partBufferLength += buf.length;
+ self.totalChunkedBytes += buf.length;
+ }
+
+ if (self.partBufferLength >= self.partSize) {
+ var pbuf = Buffer.concat(self.partBuffers);
+ self.partBuffers = [];
+ self.partBufferLength = 0;
+
+ if (pbuf.length > self.partSize) {
+ var rest = pbuf.slice(self.partSize);
+ self.partBuffers.push(rest);
+ self.partBufferLength += rest.length;
+ pbuf = pbuf.slice(0, self.partSize);
+ }
+
+ self.nextChunk(pbuf);
+ }
+
+ if (self.isDoneChunking && !self.isDoneSending) {
+ pbuf = Buffer.concat(self.partBuffers);
+ self.partBuffers = [];
+ self.partBufferLength = 0;
+ self.totalBytes = self.totalChunkedBytes;
+ self.isDoneSending = true;
+
+ if (self.numParts === 0 || pbuf.length > 0) {
+ self.numParts++;
+ self.nextChunk(pbuf);
+ }
+ }
+
+ self.body.read(0);
+ },
+
+
+ nextChunk: function nextChunk(chunk) {
+ var self = this;
+ if (self.failed) return null;
+
+ var partNumber = ++self.totalPartNumbers;
+ if (self.isDoneChunking && partNumber === 1) {
+ var req = self.service.putObject({Body: chunk});
+ req._managedUpload = self;
+ req.on('httpUploadProgress', self.progress).send(self.finishSinglePart);
+ return null;
+ }
+
+ self.activeParts++;
+ if (!self.service.config.params.UploadId) {
+
+ if (!self.multipartReq) { // create multipart
+ self.multipartReq = self.service.createMultipartUpload();
+ self.multipartReq.on('success', function(resp) {
+ self.service.config.params.UploadId = resp.data.UploadId;
+ self.multipartReq = null;
+ });
+ self.queueChunks(chunk, partNumber);
+ self.multipartReq.on('error', function(err) {
+ self.cleanup(err);
+ });
+ self.multipartReq.send();
+ } else {
+ self.queueChunks(chunk, partNumber);
+ }
+ } else { // multipart is created, just send
+ self.uploadPart(chunk, partNumber);
+ }
+ },
+
+
+ uploadPart: function uploadPart(chunk, partNumber) {
+ var self = this;
+ var partParams = {
+ Body: chunk,
+ ContentLength: AWS.util.string.byteLength(chunk),
+ PartNumber: partNumber
+ };
+
+ var partInfo = {ETag: null, PartNumber: partNumber};
+ self.completeInfo.push(partInfo);
+
+ var req = self.service.uploadPart(partParams);
+ self.parts[partNumber] = req;
+ req._lastUploadedBytes = 0;
+ req._managedUpload = self;
+ req.on('httpUploadProgress', self.progress);
+ req.send(function(err, data) {
+ delete self.parts[partParams.PartNumber];
+ self.activeParts--;
+
+ if (!err && (!data || !data.ETag)) {
+ var message = 'No access to ETag property on response.';
+ if (AWS.util.isBrowser()) {
+ message += ' Check CORS configuration to expose ETag header.';
+ }
+
+ err = AWS.util.error(new Error(message), {
+ code: 'ETagMissing', retryable: false
+ });
+ }
+ if (err) return self.cleanup(err);
+
+ partInfo.ETag = data.ETag;
+ self.doneParts++;
+ if (self.isDoneChunking && self.doneParts === self.numParts) {
+ self.finishMultiPart();
+ } else {
+ self.fillQueue.call(self);
+ }
+ });
+ },
+
+
+ queueChunks: function queueChunks(chunk, partNumber) {
+ var self = this;
+ self.multipartReq.on('success', function() {
+ self.uploadPart(chunk, partNumber);
+ });
+ },
+
+
+ cleanup: function cleanup(err) {
+ var self = this;
+ if (self.failed) return;
+
+ if (typeof self.body.removeAllListeners === 'function' &&
+ typeof self.body.resume === 'function') {
+ self.body.removeAllListeners('readable');
+ self.body.removeAllListeners('end');
+ self.body.resume();
+ }
+
+ if (self.service.config.params.UploadId && !self.leavePartsOnError) {
+ self.service.abortMultipartUpload().send();
+ }
+
+ AWS.util.each(self.parts, function(partNumber, part) {
+ part.removeAllListeners('complete');
+ part.abort();
+ });
+
+ self.parts = {};
+ self.callback(err);
+ self.failed = true;
+ },
+
+
+ finishMultiPart: function finishMultiPart() {
+ var self = this;
+ var completeParams = { MultipartUpload: { Parts: self.completeInfo } };
+ self.service.completeMultipartUpload(completeParams, function(err, data) {
+ if (err) return self.cleanup(err);
+ else self.callback(err, data);
+ });
+ },
+
+
+ finishSinglePart: function finishSinglePart(err, data) {
+ var upload = this.request._managedUpload;
+ var httpReq = this.request.httpRequest;
+ var url = AWS.util.urlFormat(httpReq.endpoint);
+ if (err) return upload.callback(err);
+ data.Location = url.substr(0, url.length - 1) + httpReq.path;
+ upload.callback(err, data);
+ },
+
+
+ progress: function progress(info) {
+ var upload = this._managedUpload;
+ if (this.operation === 'putObject') {
+ info.part = 1;
+ } else {
+ upload.totalUploadedBytes += info.loaded - this._lastUploadedBytes;
+ this._lastUploadedBytes = info.loaded;
+ info = {
+ loaded: upload.totalUploadedBytes,
+ total: upload.totalBytes,
+ part: this.params.PartNumber
+ };
+ }
+ upload.emit('httpUploadProgress', [info]);
+ }
+});
+
+AWS.util.mixin(AWS.S3.ManagedUpload, AWS.SequentialExecutor);
+module.exports = AWS.S3.ManagedUpload;
+
+}).call(this,require("buffer").Buffer)
+},{"../core":3,"buffer":54}],34:[function(require,module,exports){
+var AWS = require('./core');
+
+
+AWS.SequentialExecutor = AWS.util.inherit({
+
+ constructor: function SequentialExecutor() {
+ this._events = {};
+ },
+
+
+ listeners: function listeners(eventName) {
+ return this._events[eventName] ? this._events[eventName].slice(0) : [];
+ },
+
+ on: function on(eventName, listener) {
+ if (this._events[eventName]) {
+ this._events[eventName].push(listener);
+ } else {
+ this._events[eventName] = [listener];
+ }
+ return this;
+ },
+
+
+ onAsync: function onAsync(eventName, listener) {
+ listener._isAsync = true;
+ return this.on(eventName, listener);
+ },
+
+ removeListener: function removeListener(eventName, listener) {
+ var listeners = this._events[eventName];
+ if (listeners) {
+ var length = listeners.length;
+ var position = -1;
+ for (var i = 0; i < length; ++i) {
+ if (listeners[i] === listener) {
+ position = i;
+ }
+ }
+ if (position > -1) {
+ listeners.splice(position, 1);
+ }
+ }
+ return this;
+ },
+
+ removeAllListeners: function removeAllListeners(eventName) {
+ if (eventName) {
+ delete this._events[eventName];
+ } else {
+ this._events = {};
+ }
+ return this;
+ },
+
+
+ emit: function emit(eventName, eventArgs, doneCallback) {
+ if (!doneCallback) doneCallback = function() { };
+ var listeners = this.listeners(eventName);
+ var count = listeners.length;
+ this.callListeners(listeners, eventArgs, doneCallback);
+ return count > 0;
+ },
+
+
+ callListeners: function callListeners(listeners, args, doneCallback, prevError) {
+ var self = this;
+ var error = prevError || null;
+
+ function callNextListener(err) {
+ if (err) {
+ error = AWS.util.error(error || new Error(), err);
+ if (self._haltHandlersOnError) {
+ return doneCallback.call(self, error);
+ }
+ }
+ self.callListeners(listeners, args, doneCallback, error);
+ }
+
+ while (listeners.length > 0) {
+ var listener = listeners.shift();
+ if (listener._isAsync) { // asynchronous listener
+ listener.apply(self, args.concat([callNextListener]));
+ return; // stop here, callNextListener will continue
+ } else { // synchronous listener
+ try {
+ listener.apply(self, args);
+ } catch (err) {
+ error = AWS.util.error(error || new Error(), err);
+ }
+ if (error && self._haltHandlersOnError) {
+ doneCallback.call(self, error);
+ return;
+ }
+ }
+ }
+ doneCallback.call(self, error);
+ },
+
+
+ addListeners: function addListeners(listeners) {
+ var self = this;
+
+ if (listeners._events) listeners = listeners._events;
+
+ AWS.util.each(listeners, function(event, callbacks) {
+ if (typeof callbacks === 'function') callbacks = [callbacks];
+ AWS.util.arrayEach(callbacks, function(callback) {
+ self.on(event, callback);
+ });
+ });
+
+ return self;
+ },
+
+
+ addNamedListener: function addNamedListener(name, eventName, callback) {
+ this[name] = callback;
+ this.addListener(eventName, callback);
+ return this;
+ },
+
+
+ addNamedAsyncListener: function addNamedAsyncListener(name, eventName, callback) {
+ callback._isAsync = true;
+ return this.addNamedListener(name, eventName, callback);
+ },
+
+
+ addNamedListeners: function addNamedListeners(callback) {
+ var self = this;
+ callback(
+ function() {
+ self.addNamedListener.apply(self, arguments);
+ },
+ function() {
+ self.addNamedAsyncListener.apply(self, arguments);
+ }
+ );
+ return this;
+ }
+});
+
+
+AWS.SequentialExecutor.prototype.addListener = AWS.SequentialExecutor.prototype.on;
+
+module.exports = AWS.SequentialExecutor;
+
+},{"./core":3}],35:[function(require,module,exports){
+var AWS = require('./core');
+var Api = require('./model/api');
+var regionConfig = require('./region_config');
+var inherit = AWS.util.inherit;
+
+
+AWS.Service = inherit({
+
+ constructor: function Service(config) {
+ if (!this.loadServiceClass) {
+ throw AWS.util.error(new Error(),
+ 'Service must be constructed with `new\' operator');
+ }
+ var ServiceClass = this.loadServiceClass(config || {});
+ if (ServiceClass) return new ServiceClass(config);
+ this.initialize(config);
+ },
+
+
+ initialize: function initialize(config) {
+ var svcConfig = AWS.config[this.serviceIdentifier];
+
+ this.config = new AWS.Config(AWS.config);
+ if (svcConfig) this.config.update(svcConfig, true);
+ if (config) this.config.update(config, true);
+
+ this.validateService();
+ if (!this.config.endpoint) regionConfig(this);
+
+ this.config.endpoint = this.endpointFromTemplate(this.config.endpoint);
+ this.setEndpoint(this.config.endpoint);
+ },
+
+
+ validateService: function validateService() {
+ },
+
+
+ loadServiceClass: function loadServiceClass(serviceConfig) {
+ var config = serviceConfig;
+ if (!AWS.util.isEmpty(this.api)) {
+ return null;
+ } else if (config.apiConfig) {
+ return AWS.Service.defineServiceApi(this.constructor, config.apiConfig);
+ } else if (!this.constructor.services) {
+ return null;
+ } else {
+ config = new AWS.Config(AWS.config);
+ config.update(serviceConfig, true);
+ var version = config.apiVersions[this.constructor.serviceIdentifier];
+ version = version || config.apiVersion;
+ return this.getLatestServiceClass(version);
+ }
+ },
+
+
+ getLatestServiceClass: function getLatestServiceClass(version) {
+ version = this.getLatestServiceVersion(version);
+ if (this.constructor.services[version] === null) {
+ AWS.Service.defineServiceApi(this.constructor, version);
+ }
+
+ return this.constructor.services[version];
+ },
+
+
+ getLatestServiceVersion: function getLatestServiceVersion(version) {
+ if (!this.constructor.services || this.constructor.services.length === 0) {
+ throw new Error('No services defined on ' +
+ this.constructor.serviceIdentifier);
+ }
+
+ if (!version) {
+ version = 'latest';
+ } else if (AWS.util.isType(version, Date)) {
+ version = AWS.util.date.iso8601(version).split('T')[0];
+ }
+
+ if (Object.hasOwnProperty(this.constructor.services, version)) {
+ return version;
+ }
+
+ var keys = Object.keys(this.constructor.services).sort();
+ var selectedVersion = null;
+ for (var i = keys.length - 1; i >= 0; i--) {
+ if (keys[i][keys[i].length - 1] !== '*') {
+ selectedVersion = keys[i];
+ }
+ if (keys[i].substr(0, 10) <= version) {
+ return selectedVersion;
+ }
+ }
+
+ throw new Error('Could not find ' + this.constructor.serviceIdentifier +
+ ' API to satisfy version constraint `' + version + '\'');
+ },
+
+
+ api: {},
+
+
+ defaultRetryCount: 3,
+
+
+ makeRequest: function makeRequest(operation, params, callback) {
+ if (typeof params === 'function') {
+ callback = params;
+ params = null;
+ }
+
+ params = params || {};
+ if (this.config.params) { // copy only toplevel bound params
+ var rules = this.api.operations[operation];
+ if (rules) {
+ params = AWS.util.copy(params);
+ AWS.util.each(this.config.params, function(key, value) {
+ if (rules.input.members[key]) {
+ if (params[key] === undefined || params[key] === null) {
+ params[key] = value;
+ }
+ }
+ });
+ }
+ }
+
+ var request = new AWS.Request(this, operation, params);
+ this.addAllRequestListeners(request);
+
+ if (callback) request.send(callback);
+ return request;
+ },
+
+
+ makeUnauthenticatedRequest: function makeUnauthenticatedRequest(operation, params, callback) {
+ if (typeof params === 'function') {
+ callback = params;
+ params = {};
+ }
+
+ var request = this.makeRequest(operation, params).toUnauthenticated();
+ return callback ? request.send(callback) : request;
+ },
+
+
+ waitFor: function waitFor(state, params, callback) {
+ var waiter = new AWS.ResourceWaiter(this, state);
+ return waiter.wait(params, callback);
+ },
+
+
+ addAllRequestListeners: function addAllRequestListeners(request) {
+ var list = [AWS.events, AWS.EventListeners.Core, this.serviceInterface(),
+ AWS.EventListeners.CorePost];
+ for (var i = 0; i < list.length; i++) {
+ if (list[i]) request.addListeners(list[i]);
+ }
+
+ if (!this.config.paramValidation) {
+ request.removeListener('validate',
+ AWS.EventListeners.Core.VALIDATE_PARAMETERS);
+ }
+
+ if (this.config.logger) { // add logging events
+ request.addListeners(AWS.EventListeners.Logger);
+ }
+
+ this.setupRequestListeners(request);
+ },
+
+
+ setupRequestListeners: function setupRequestListeners() {
+ },
+
+
+ getSignerClass: function getSignerClass() {
+ var version;
+ if (this.config.signatureVersion) {
+ version = this.config.signatureVersion;
+ } else {
+ version = this.api.signatureVersion;
+ }
+ return AWS.Signers.RequestSigner.getVersion(version);
+ },
+
+
+ serviceInterface: function serviceInterface() {
+ switch (this.api.protocol) {
+ case 'ec2': return AWS.EventListeners.Query;
+ case 'query': return AWS.EventListeners.Query;
+ case 'json': return AWS.EventListeners.Json;
+ case 'rest-json': return AWS.EventListeners.RestJson;
+ case 'rest-xml': return AWS.EventListeners.RestXml;
+ }
+ if (this.api.protocol) {
+ throw new Error('Invalid service `protocol\' ' +
+ this.api.protocol + ' in API config');
+ }
+ },
+
+
+ successfulResponse: function successfulResponse(resp) {
+ return resp.httpResponse.statusCode < 300;
+ },
+
+
+ numRetries: function numRetries() {
+ if (this.config.maxRetries !== undefined) {
+ return this.config.maxRetries;
+ } else {
+ return this.defaultRetryCount;
+ }
+ },
+
+
+ retryDelays: function retryDelays() {
+ var retryCount = this.numRetries();
+ var delays = [];
+ for (var i = 0; i < retryCount; ++i) {
+ delays[i] = Math.pow(2, i) * 30;
+ }
+ return delays;
+ },
+
+
+ retryableError: function retryableError(error) {
+ if (this.networkingError(error)) return true;
+ if (this.expiredCredentialsError(error)) return true;
+ if (this.throttledError(error)) return true;
+ if (error.statusCode >= 500) return true;
+ return false;
+ },
+
+
+ networkingError: function networkingError(error) {
+ return error.code === 'NetworkingError';
+ },
+
+
+ expiredCredentialsError: function expiredCredentialsError(error) {
+ return (error.code === 'ExpiredTokenException');
+ },
+
+
+ throttledError: function throttledError(error) {
+ switch (error.code) {
+ case 'ProvisionedThroughputExceededException':
+ case 'Throttling':
+ case 'ThrottlingException':
+ case 'RequestLimitExceeded':
+ case 'RequestThrottled':
+ return true;
+ default:
+ return false;
+ }
+ },
+
+
+ endpointFromTemplate: function endpointFromTemplate(endpoint) {
+ if (typeof endpoint !== 'string') return endpoint;
+
+ var e = endpoint;
+ e = e.replace(/\{service\}/g, this.api.endpointPrefix);
+ e = e.replace(/\{region\}/g, this.config.region);
+ e = e.replace(/\{scheme\}/g, this.config.sslEnabled ? 'https' : 'http');
+ return e;
+ },
+
+
+ setEndpoint: function setEndpoint(endpoint) {
+ this.endpoint = new AWS.Endpoint(endpoint, this.config);
+ },
+
+
+ paginationConfig: function paginationConfig(operation, throwException) {
+ var paginator = this.api.operations[operation].paginator;
+ if (!paginator) {
+ if (throwException) {
+ var e = new Error();
+ throw AWS.util.error(e, 'No pagination configuration for ' + operation);
+ }
+ return null;
+ }
+
+ return paginator;
+ }
+});
+
+AWS.util.update(AWS.Service, {
+
+
+ defineMethods: function defineMethods(svc) {
+ AWS.util.each(svc.prototype.api.operations, function iterator(method) {
+ if (svc.prototype[method]) return;
+ svc.prototype[method] = function (params, callback) {
+ return this.makeRequest(method, params, callback);
+ };
+ });
+ },
+
+
+ defineService: function defineService(serviceIdentifier, versions, features) {
+ AWS.Service._serviceMap[serviceIdentifier] = true;
+ if (!Array.isArray(versions)) {
+ features = versions;
+ versions = [];
+ }
+
+ var svc = inherit(AWS.Service, features || {});
+
+ if (typeof serviceIdentifier === 'string') {
+ AWS.Service.addVersions(svc, versions);
+
+ var identifier = svc.serviceIdentifier || serviceIdentifier;
+ svc.serviceIdentifier = identifier;
+ } else { // defineService called with an API
+ svc.prototype.api = serviceIdentifier;
+ AWS.Service.defineMethods(svc);
+ }
+
+ return svc;
+ },
+
+
+ addVersions: function addVersions(svc, versions) {
+ if (!Array.isArray(versions)) versions = [versions];
+
+ svc.services = svc.services || {};
+ for (var i = 0; i < versions.length; i++) {
+ if (svc.services[versions[i]] === undefined) {
+ svc.services[versions[i]] = null;
+ }
+ }
+
+ svc.apiVersions = Object.keys(svc.services).sort();
+ },
+
+
+ defineServiceApi: function defineServiceApi(superclass, version, apiConfig) {
+ var svc = inherit(superclass, {
+ serviceIdentifier: superclass.serviceIdentifier
+ });
+
+ function setApi(api) {
+ if (api.isApi) {
+ svc.prototype.api = api;
+ } else {
+ svc.prototype.api = new Api(api);
+ }
+ }
+
+ if (typeof version === 'string') {
+ if (apiConfig) {
+ setApi(apiConfig);
+ } else {
+ try {
+ setApi(AWS.apiLoader(superclass.serviceIdentifier, version));
+ } catch (err) {
+ throw AWS.util.error(err, {
+ message: 'Could not find API configuration ' +
+ superclass.serviceIdentifier + '-' + version
+ });
+ }
+ }
+ if (!superclass.services.hasOwnProperty(version)) {
+ superclass.apiVersions = superclass.apiVersions.concat(version).sort();
+ }
+ superclass.services[version] = svc;
+ } else {
+ setApi(version);
+ }
+
+ AWS.Service.defineMethods(svc);
+ return svc;
+ },
+
+
+ hasService: function(identifier) {
+ return AWS.Service._serviceMap.hasOwnProperty(identifier);
+ },
+
+
+ _serviceMap: {}
+});
+
+},{"./core":3,"./model/api":15,"./region_config":28}],36:[function(require,module,exports){
+var AWS = require('../core');
+
+AWS.util.update(AWS.CognitoIdentity.prototype, {
+ getOpenIdToken: function getOpenIdToken(params, callback) {
+ return this.makeUnauthenticatedRequest('getOpenIdToken', params, callback);
+ },
+
+ getId: function getId(params, callback) {
+ return this.makeUnauthenticatedRequest('getId', params, callback);
+ },
+
+ getCredentialsForIdentity: function getCredentialsForIdentity(params, callback) {
+ return this.makeUnauthenticatedRequest('getCredentialsForIdentity', params, callback);
+ }
+});
+
+},{"../core":3}],37:[function(require,module,exports){
+var AWS = require('../core');
+
+AWS.util.update(AWS.DynamoDB.prototype, {
+
+ setupRequestListeners: function setupRequestListeners(request) {
+ if (request.service.config.dynamoDbCrc32) {
+ request.addListener('extractData', this.checkCrc32);
+ }
+ },
+
+
+ checkCrc32: function checkCrc32(resp) {
+ if (!resp.httpResponse.streaming && !resp.request.service.crc32IsValid(resp)) {
+ resp.error = AWS.util.error(new Error(), {
+ code: 'CRC32CheckFailed',
+ message: 'CRC32 integrity check failed',
+ retryable: true
+ });
+ }
+ },
+
+
+ crc32IsValid: function crc32IsValid(resp) {
+ var crc = resp.httpResponse.headers['x-amz-crc32'];
+ if (!crc) return true; // no (valid) CRC32 header
+ return parseInt(crc, 10) === AWS.util.crypto.crc32(resp.httpResponse.body);
+ },
+
+
+ defaultRetryCount: 10,
+
+
+ retryDelays: function retryDelays() {
+ var retryCount = this.numRetries();
+ var delays = [];
+ for (var i = 0; i < retryCount; ++i) {
+ if (i === 0) {
+ delays.push(0);
+ } else {
+ delays.push(50 * Math.pow(2, i - 1));
+ }
+ }
+ return delays;
+ }
+});
+
+},{"../core":3}],38:[function(require,module,exports){
+var AWS = require('../core');
+
+AWS.util.update(AWS.EC2.prototype, {
+
+ setupRequestListeners: function setupRequestListeners(request) {
+ request.removeListener('extractError', AWS.EventListeners.Query.EXTRACT_ERROR);
+ request.addListener('extractError', this.extractError);
+
+ if (request.operation === 'copySnapshot') {
+ request.onAsync('validate', this.buildCopySnapshotPresignedUrl);
+ }
+ },
+
+
+ buildCopySnapshotPresignedUrl: function buildCopySnapshotPresignedUrl(req, done) {
+ if (req.params.PresignedUrl || req._subRequest) {
+ return done();
+ }
+
+ req.params = AWS.util.copy(req.params);
+ req.params.DestinationRegion = req.service.config.region;
+
+ var config = AWS.util.copy(req.service.config);
+ delete config.endpoint;
+ config.region = req.params.SourceRegion;
+ var svc = new req.service.constructor(config);
+ var newReq = svc[req.operation](req.params);
+ newReq._subRequest = true;
+ newReq.presign(function(err, url) {
+ if (err) done(err);
+ else {
+ req.params.PresignedUrl = url;
+ done();
+ }
+ });
+ },
+
+
+ extractError: function extractError(resp) {
+ var httpResponse = resp.httpResponse;
+ var data = new AWS.XML.Parser().parse(httpResponse.body.toString() || '');
+ if (data.Errors)
+ resp.error = AWS.util.error(new Error(), {
+ code: data.Errors.Error.Code,
+ message: data.Errors.Error.Message
+ });
+ else
+ resp.error = AWS.util.error(new Error(), {
+ code: httpResponse.statusCode,
+ message: null
+ });
+ }
+});
+
+},{"../core":3}],39:[function(require,module,exports){
+var AWS = require('../core');
+
+AWS.util.update(AWS.MachineLearning.prototype, {
+
+ setupRequestListeners: function setupRequestListeners(request) {
+ if (request.operation === 'predict') {
+ request.addListener('build', this.buildEndpoint);
+ }
+ },
+
+
+ buildEndpoint: function buildEndpoint(request) {
+ var url = request.params.PredictEndpoint;
+ if (url) {
+ request.httpRequest.endpoint = new AWS.Endpoint(url);
+ }
+ }
+
+});
+
+},{"../core":3}],40:[function(require,module,exports){
+var AWS = require('../core');
+
+require('../s3/managed_upload');
+
+AWS.util.update(AWS.S3.prototype, {
+
+ validateService: function validateService() {
+ if (!this.config.region) this.config.region = 'us-east-1';
+
+ if (!this.config.endpoint && this.config.s3BucketEndpoint) {
+ var msg = 'An endpoint must be provided when configuring ' +
+ '`s3BucketEndpoint` to true.';
+ throw AWS.util.error(new Error(),
+ {name: 'InvalidEndpoint', message: msg});
+ }
+ },
+
+
+ setupRequestListeners: function setupRequestListeners(request) {
+ request.addListener('validate', this.validateScheme);
+ request.addListener('validate', this.validateBucketEndpoint);
+ request.addListener('build', this.addContentType);
+ request.addListener('build', this.populateURI);
+ request.addListener('build', this.computeContentMd5);
+ request.addListener('build', this.computeSseCustomerKeyMd5);
+ request.addListener('afterBuild', this.addExpect100Continue);
+ request.removeListener('validate',
+ AWS.EventListeners.Core.VALIDATE_REGION);
+ request.addListener('extractError', this.extractError);
+ request.addListener('extractData', this.extractData);
+ request.addListener('extractData', AWS.util.hoistPayloadMember);
+ request.addListener('beforePresign', this.prepareSignedUrl);
+ },
+
+
+ validateScheme: function(req) {
+ var params = req.params,
+ scheme = req.httpRequest.endpoint.protocol,
+ sensitive = params.SSECustomerKey || params.CopySourceSSECustomerKey;
+ if (sensitive && scheme !== 'https:') {
+ var msg = 'Cannot send SSE keys over HTTP. Set \'sslEnabled\'' +
+ 'to \'true\' in your configuration';
+ throw AWS.util.error(new Error(),
+ { code: 'ConfigError', message: msg });
+ }
+ },
+
+
+ validateBucketEndpoint: function(req) {
+ if (!req.params.Bucket && req.service.config.s3BucketEndpoint) {
+ var msg = 'Cannot send requests to root API with `s3BucketEndpoint` set.';
+ throw AWS.util.error(new Error(),
+ { code: 'ConfigError', message: msg });
+ }
+ },
+
+
+ populateURI: function populateURI(req) {
+ var httpRequest = req.httpRequest;
+ var b = req.params.Bucket;
+
+ if (b) {
+ if (!req.service.pathStyleBucketName(b)) {
+ if (!req.service.config.s3BucketEndpoint) {
+ httpRequest.endpoint.hostname =
+ b + '.' + httpRequest.endpoint.hostname;
+
+ var port = httpRequest.endpoint.port;
+ if (port !== 80 && port !== 443) {
+ httpRequest.endpoint.host = httpRequest.endpoint.hostname + ':' +
+ httpRequest.endpoint.port;
+ } else {
+ httpRequest.endpoint.host = httpRequest.endpoint.hostname;
+ }
+ }
+
+ httpRequest.virtualHostedBucket = b; // needed for signing the request
+ httpRequest.path = httpRequest.path.replace(new RegExp('/' + b), '');
+ if (httpRequest.path[0] !== '/') {
+ httpRequest.path = '/' + httpRequest.path;
+ }
+ }
+ }
+ },
+
+
+ addExpect100Continue: function addExpect100Continue(req) {
+ var len = req.httpRequest.headers['Content-Length'];
+ if (AWS.util.isNode() && len >= 1024 * 1024) {
+ req.httpRequest.headers['Expect'] = '100-continue';
+ }
+ },
+
+
+ addContentType: function addContentType(req) {
+ var httpRequest = req.httpRequest;
+ if (httpRequest.method === 'GET' || httpRequest.method === 'HEAD') {
+ delete httpRequest.headers['Content-Type'];
+ return;
+ }
+
+ if (!httpRequest.headers['Content-Type']) { // always have a Content-Type
+ httpRequest.headers['Content-Type'] = 'application/octet-stream';
+ }
+
+ var contentType = httpRequest.headers['Content-Type'];
+ if (AWS.util.isBrowser()) {
+ if (typeof httpRequest.body === 'string' && !contentType.match(/;\s*charset=/)) {
+ var charset = '; charset=UTF-8';
+ httpRequest.headers['Content-Type'] += charset;
+ } else {
+ var replaceFn = function(_, prefix, charsetName) {
+ return prefix + charsetName.toUpperCase();
+ };
+
+ httpRequest.headers['Content-Type'] =
+ contentType.replace(/(;\s*charset=)(.+)$/, replaceFn);
+ }
+ }
+ },
+
+
+ computableChecksumOperations: {
+ putBucketCors: true,
+ putBucketLifecycle: true,
+ putBucketTagging: true,
+ deleteObjects: true
+ },
+
+
+ willComputeChecksums: function willComputeChecksums(req) {
+ if (this.computableChecksumOperations[req.operation]) return true;
+ if (!this.config.computeChecksums) return false;
+
+ if (!AWS.util.Buffer.isBuffer(req.httpRequest.body) &&
+ typeof req.httpRequest.body !== 'string') {
+ return false;
+ }
+
+ var rules = req.service.api.operations[req.operation].input.members;
+
+ if (req.service.getSignerClass(req) === AWS.Signers.V4) {
+ if (rules.ContentMD5 && !rules.ContentMD5.required) return false;
+ }
+
+ if (rules.ContentMD5 && !req.params.ContentMD5) return true;
+ },
+
+
+ computeContentMd5: function computeContentMd5(req) {
+ if (req.service.willComputeChecksums(req)) {
+ var md5 = AWS.util.crypto.md5(req.httpRequest.body, 'base64');
+ req.httpRequest.headers['Content-MD5'] = md5;
+ }
+ },
+
+
+ computeSseCustomerKeyMd5: function computeSseCustomerKeyMd5(req) {
+ var keys = {
+ SSECustomerKey: 'x-amz-server-side-encryption-customer-key-MD5',
+ CopySourceSSECustomerKey: 'x-amz-copy-source-server-side-encryption-customer-key-MD5'
+ };
+ AWS.util.each(keys, function(key, header) {
+ if (req.params[key]) {
+ var value = AWS.util.crypto.md5(req.params[key], 'base64');
+ req.httpRequest.headers[header] = value;
+ }
+ });
+ },
+
+
+ pathStyleBucketName: function pathStyleBucketName(bucketName) {
+ if (this.config.s3ForcePathStyle) return true;
+ if (this.config.s3BucketEndpoint) return false;
+
+ if (this.dnsCompatibleBucketName(bucketName)) {
+ return (this.config.sslEnabled && bucketName.match(/\./)) ? true : false;
+ } else {
+ return true; // not dns compatible names must always use path style
+ }
+ },
+
+
+ dnsCompatibleBucketName: function dnsCompatibleBucketName(bucketName) {
+ var b = bucketName;
+ var domain = new RegExp(/^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/);
+ var ipAddress = new RegExp(/(\d+\.){3}\d+/);
+ var dots = new RegExp(/\.\./);
+ return (b.match(domain) && !b.match(ipAddress) && !b.match(dots)) ? true : false;
+ },
+
+
+ successfulResponse: function successfulResponse(resp) {
+ var req = resp.request;
+ var httpResponse = resp.httpResponse;
+ if (req.operation === 'completeMultipartUpload' &&
+ httpResponse.body.toString().match(''))
+ return false;
+ else
+ return httpResponse.statusCode < 300;
+ },
+
+
+ retryableError: function retryableError(error, request) {
+ if (request.operation === 'completeMultipartUpload' &&
+ error.statusCode === 200) {
+ return true;
+ } else if (error && error.code === 'RequestTimeout') {
+ return true;
+ } else {
+ var _super = AWS.Service.prototype.retryableError;
+ return _super.call(this, error, request);
+ }
+ },
+
+
+ extractData: function extractData(resp) {
+ var req = resp.request;
+ if (req.operation === 'getBucketLocation') {
+ var match = resp.httpResponse.body.toString().match(/>(.+)<\/Location/);
+ delete resp.data['_'];
+ if (match) {
+ resp.data.LocationConstraint = match[1];
+ } else {
+ resp.data.LocationConstraint = '';
+ }
+ }
+ },
+
+
+ extractError: function extractError(resp) {
+ var codes = {
+ 304: 'NotModified',
+ 403: 'Forbidden',
+ 400: 'BadRequest',
+ 404: 'NotFound'
+ };
+
+ var code = resp.httpResponse.statusCode;
+ var body = resp.httpResponse.body || '';
+ if (codes[code] && body.length === 0) {
+ resp.error = AWS.util.error(new Error(), {
+ code: codes[resp.httpResponse.statusCode],
+ message: null
+ });
+ } else {
+ var data = new AWS.XML.Parser().parse(body.toString());
+ resp.error = AWS.util.error(new Error(), {
+ code: data.Code || code,
+ message: data.Message || null
+ });
+ }
+ },
+
+
+ getSignedUrl: function getSignedUrl(operation, params, callback) {
+ params = AWS.util.copy(params || {});
+ var expires = params.Expires || 900;
+ delete params.Expires; // we can't validate this
+ var request = this.makeRequest(operation, params);
+ return request.presign(expires, callback);
+ },
+
+
+ prepareSignedUrl: function prepareSignedUrl(request) {
+ request.addListener('validate', request.service.noPresignedContentLength);
+ request.removeListener('build', request.service.addContentType);
+ if (!request.params.Body) {
+ request.removeListener('build', request.service.computeContentMd5);
+ } else {
+ request.addListener('afterBuild', AWS.EventListeners.Core.COMPUTE_SHA256);
+ }
+ },
+
+ noPresignedContentLength: function noPresignedContentLength(request) {
+ if (request.params.ContentLength !== undefined) {
+ throw AWS.util.error(new Error(), {code: 'UnexpectedParameter',
+ message: 'ContentLength is not supported in pre-signed URLs.'});
+ }
+ },
+
+ createBucket: function createBucket(params, callback) {
+ if (!params) params = {};
+ var hostname = this.endpoint.hostname;
+ if (hostname !== this.api.globalEndpoint && !params.CreateBucketConfiguration) {
+ params.CreateBucketConfiguration = { LocationConstraint: this.config.region };
+ }
+ return this.makeRequest('createBucket', params, callback);
+ },
+
+
+ upload: function upload(params, options, callback) {
+ if (typeof options === 'function' && callback === undefined) {
+ callback = options;
+ options = null;
+ }
+
+ options = options || {};
+ options = AWS.util.merge(options || {}, {service: this, params: params});
+
+ var uploader = new AWS.S3.ManagedUpload(options);
+ if (typeof callback === 'function') uploader.send(callback);
+ return uploader;
+ }
+});
+
+},{"../core":3,"../s3/managed_upload":33}],41:[function(require,module,exports){
+var AWS = require('../core');
+
+AWS.util.update(AWS.SQS.prototype, {
+
+ setupRequestListeners: function setupRequestListeners(request) {
+ request.addListener('build', this.buildEndpoint);
+
+ if (request.service.config.computeChecksums) {
+ if (request.operation === 'sendMessage') {
+ request.addListener('extractData', this.verifySendMessageChecksum);
+ } else if (request.operation === 'sendMessageBatch') {
+ request.addListener('extractData', this.verifySendMessageBatchChecksum);
+ } else if (request.operation === 'receiveMessage') {
+ request.addListener('extractData', this.verifyReceiveMessageChecksum);
+ }
+ }
+ },
+
+
+ verifySendMessageChecksum: function verifySendMessageChecksum(response) {
+ if (!response.data) return;
+
+ var md5 = response.data.MD5OfMessageBody;
+ var body = this.params.MessageBody;
+ var calculatedMd5 = this.service.calculateChecksum(body);
+ if (calculatedMd5 !== md5) {
+ var msg = 'Got "' + response.data.MD5OfMessageBody +
+ '", expecting "' + calculatedMd5 + '".';
+ this.service.throwInvalidChecksumError(response,
+ [response.data.MessageId], msg);
+ }
+ },
+
+
+ verifySendMessageBatchChecksum: function verifySendMessageBatchChecksum(response) {
+ if (!response.data) return;
+
+ var service = this.service;
+ var entries = {};
+ var errors = [];
+ var messageIds = [];
+ AWS.util.arrayEach(response.data.Successful, function (entry) {
+ entries[entry.Id] = entry;
+ });
+ AWS.util.arrayEach(this.params.Entries, function (entry) {
+ if (entries[entry.Id]) {
+ var md5 = entries[entry.Id].MD5OfMessageBody;
+ var body = entry.MessageBody;
+ if (!service.isChecksumValid(md5, body)) {
+ errors.push(entry.Id);
+ messageIds.push(entries[entry.Id].MessageId);
+ }
+ }
+ });
+
+ if (errors.length > 0) {
+ service.throwInvalidChecksumError(response, messageIds,
+ 'Invalid messages: ' + errors.join(', '));
+ }
+ },
+
+
+ verifyReceiveMessageChecksum: function verifyReceiveMessageChecksum(response) {
+ if (!response.data) return;
+
+ var service = this.service;
+ var messageIds = [];
+ AWS.util.arrayEach(response.data.Messages, function(message) {
+ var md5 = message.MD5OfBody;
+ var body = message.Body;
+ if (!service.isChecksumValid(md5, body)) {
+ messageIds.push(message.MessageId);
+ }
+ });
+
+ if (messageIds.length > 0) {
+ service.throwInvalidChecksumError(response, messageIds,
+ 'Invalid messages: ' + messageIds.join(', '));
+ }
+ },
+
+
+ throwInvalidChecksumError: function throwInvalidChecksumError(response, ids, message) {
+ response.error = AWS.util.error(new Error(), {
+ retryable: true,
+ code: 'InvalidChecksum',
+ messageIds: ids,
+ message: response.request.operation +
+ ' returned an invalid MD5 response. ' + message
+ });
+ },
+
+
+ isChecksumValid: function isChecksumValid(checksum, data) {
+ return this.calculateChecksum(data) === checksum;
+ },
+
+
+ calculateChecksum: function calculateChecksum(data) {
+ return AWS.util.crypto.md5(data, 'hex');
+ },
+
+
+ buildEndpoint: function buildEndpoint(request) {
+ var url = request.httpRequest.params.QueueUrl;
+ if (url) {
+ request.httpRequest.endpoint = new AWS.Endpoint(url);
+
+ var matches = request.httpRequest.endpoint.host.match(/^sqs\.(.+?)\./);
+ if (matches) request.httpRequest.region = matches[1];
+ }
+ }
+});
+
+},{"../core":3}],42:[function(require,module,exports){
+var AWS = require('../core');
+
+AWS.util.update(AWS.STS.prototype, {
+
+ credentialsFrom: function credentialsFrom(data, credentials) {
+ if (!data) return null;
+ if (!credentials) credentials = new AWS.TemporaryCredentials();
+ credentials.expired = false;
+ credentials.accessKeyId = data.Credentials.AccessKeyId;
+ credentials.secretAccessKey = data.Credentials.SecretAccessKey;
+ credentials.sessionToken = data.Credentials.SessionToken;
+ credentials.expireTime = data.Credentials.Expiration;
+ return credentials;
+ },
+
+ assumeRoleWithWebIdentity: function assumeRoleWithWebIdentity(params, callback) {
+ return this.makeUnauthenticatedRequest('assumeRoleWithWebIdentity', params, callback);
+ },
+
+ assumeRoleWithSAML: function assumeRoleWithSAML(params, callback) {
+ return this.makeUnauthenticatedRequest('assumeRoleWithSAML', params, callback);
+ }
+});
+
+},{"../core":3}],43:[function(require,module,exports){
+var AWS = require('../core');
+var inherit = AWS.util.inherit;
+
+
+var expiresHeader = 'presigned-expires';
+
+
+function signedUrlBuilder(request) {
+ var expires = request.httpRequest.headers[expiresHeader];
+
+ delete request.httpRequest.headers['User-Agent'];
+ delete request.httpRequest.headers['X-Amz-User-Agent'];
+
+ if (request.service.getSignerClass() === AWS.Signers.V4) {
+ if (expires > 604800) { // one week expiry is invalid
+ var message = 'Presigning does not support expiry time greater ' +
+ 'than a week with SigV4 signing.';
+ throw AWS.util.error(new Error(), {
+ code: 'InvalidExpiryTime', message: message, retryable: false
+ });
+ }
+ request.httpRequest.headers[expiresHeader] = expires;
+ } else if (request.service.getSignerClass() === AWS.Signers.S3) {
+ request.httpRequest.headers[expiresHeader] = parseInt(
+ AWS.util.date.unixTimestamp() + expires, 10).toString();
+ } else {
+ throw AWS.util.error(new Error(), {
+ message: 'Presigning only supports S3 or SigV4 signing.',
+ code: 'UnsupportedSigner', retryable: false
+ });
+ }
+}
+
+
+function signedUrlSigner(request) {
+ var endpoint = request.httpRequest.endpoint;
+ var parsedUrl = AWS.util.urlParse(request.httpRequest.path);
+ var queryParams = {};
+
+ if (parsedUrl.search) {
+ queryParams = AWS.util.queryStringParse(parsedUrl.search.substr(1));
+ }
+
+ AWS.util.each(request.httpRequest.headers, function (key, value) {
+ if (key === expiresHeader) key = 'Expires';
+ queryParams[key] = value;
+ });
+ delete request.httpRequest.headers[expiresHeader];
+
+ var auth = queryParams['Authorization'].split(' ');
+ if (auth[0] === 'AWS') {
+ auth = auth[1].split(':');
+ queryParams['AWSAccessKeyId'] = auth[0];
+ queryParams['Signature'] = auth[1];
+ } else if (auth[0] === 'AWS4-HMAC-SHA256') { // SigV4 signing
+ auth.shift();
+ var rest = auth.join(' ');
+ var signature = rest.match(/Signature=(.*?)(?:,|\s|\r?\n|$)/)[1];
+ queryParams['X-Amz-Signature'] = signature;
+ delete queryParams['Expires'];
+ }
+ delete queryParams['Authorization'];
+ delete queryParams['Host'];
+
+ endpoint.pathname = parsedUrl.pathname;
+ endpoint.search = AWS.util.queryParamsToString(queryParams);
+}
+
+
+AWS.Signers.Presign = inherit({
+
+ sign: function sign(request, expireTime, callback) {
+ request.httpRequest.headers[expiresHeader] = expireTime || 3600;
+ request.on('build', signedUrlBuilder);
+ request.on('sign', signedUrlSigner);
+ request.removeListener('afterBuild',
+ AWS.EventListeners.Core.SET_CONTENT_LENGTH);
+ request.removeListener('afterBuild',
+ AWS.EventListeners.Core.COMPUTE_SHA256);
+
+ request.emit('beforePresign', [request]);
+
+ if (callback) {
+ request.build(function() {
+ if (this.response.error) callback(this.response.error);
+ else {
+ callback(null, AWS.util.urlFormat(request.httpRequest.endpoint));
+ }
+ });
+ } else {
+ request.build();
+ if (request.response.error) throw request.response.error;
+ return AWS.util.urlFormat(request.httpRequest.endpoint);
+ }
+ }
+});
+
+module.exports = AWS.Signers.Presign;
+
+},{"../core":3}],44:[function(require,module,exports){
+var AWS = require('../core');
+var inherit = AWS.util.inherit;
+
+
+AWS.Signers.RequestSigner = inherit({
+ constructor: function RequestSigner(request) {
+ this.request = request;
+ }
+});
+
+AWS.Signers.RequestSigner.getVersion = function getVersion(version) {
+ switch (version) {
+ case 'v2': return AWS.Signers.V2;
+ case 'v3': return AWS.Signers.V3;
+ case 'v4': return AWS.Signers.V4;
+ case 's3': return AWS.Signers.S3;
+ case 'v3https': return AWS.Signers.V3Https;
+ }
+ throw new Error('Unknown signing version ' + version);
+};
+
+require('./v2');
+require('./v3');
+require('./v3https');
+require('./v4');
+require('./s3');
+require('./presign');
+
+},{"../core":3,"./presign":43,"./s3":45,"./v2":46,"./v3":47,"./v3https":48,"./v4":49}],45:[function(require,module,exports){
+var AWS = require('../core');
+var inherit = AWS.util.inherit;
+
+
+AWS.Signers.S3 = inherit(AWS.Signers.RequestSigner, {
+
+ subResources: {
+ 'acl': 1,
+ 'cors': 1,
+ 'lifecycle': 1,
+ 'delete': 1,
+ 'location': 1,
+ 'logging': 1,
+ 'notification': 1,
+ 'partNumber': 1,
+ 'policy': 1,
+ 'requestPayment': 1,
+ 'restore': 1,
+ 'tagging': 1,
+ 'torrent': 1,
+ 'uploadId': 1,
+ 'uploads': 1,
+ 'versionId': 1,
+ 'versioning': 1,
+ 'versions': 1,
+ 'website': 1
+ },
+
+ responseHeaders: {
+ 'response-content-type': 1,
+ 'response-content-language': 1,
+ 'response-expires': 1,
+ 'response-cache-control': 1,
+ 'response-content-disposition': 1,
+ 'response-content-encoding': 1
+ },
+
+ addAuthorization: function addAuthorization(credentials, date) {
+ if (!this.request.headers['presigned-expires']) {
+ this.request.headers['X-Amz-Date'] = AWS.util.date.rfc822(date);
+ }
+
+ if (credentials.sessionToken) {
+ this.request.headers['x-amz-security-token'] = credentials.sessionToken;
+ }
+
+ var signature = this.sign(credentials.secretAccessKey, this.stringToSign());
+ var auth = 'AWS ' + credentials.accessKeyId + ':' + signature;
+
+ this.request.headers['Authorization'] = auth;
+ },
+
+ stringToSign: function stringToSign() {
+ var r = this.request;
+
+ var parts = [];
+ parts.push(r.method);
+ parts.push(r.headers['Content-MD5'] || '');
+ parts.push(r.headers['Content-Type'] || '');
+
+ parts.push(r.headers['presigned-expires'] || '');
+
+ var headers = this.canonicalizedAmzHeaders();
+ if (headers) parts.push(headers);
+ parts.push(this.canonicalizedResource());
+
+ return parts.join('\n');
+
+ },
+
+ canonicalizedAmzHeaders: function canonicalizedAmzHeaders() {
+
+ var amzHeaders = [];
+
+ AWS.util.each(this.request.headers, function (name) {
+ if (name.match(/^x-amz-/i))
+ amzHeaders.push(name);
+ });
+
+ amzHeaders.sort(function (a, b) {
+ return a.toLowerCase() < b.toLowerCase() ? -1 : 1;
+ });
+
+ var parts = [];
+ AWS.util.arrayEach.call(this, amzHeaders, function (name) {
+ parts.push(name.toLowerCase() + ':' + String(this.request.headers[name]));
+ });
+
+ return parts.join('\n');
+
+ },
+
+ canonicalizedResource: function canonicalizedResource() {
+
+ var r = this.request;
+
+ var parts = r.path.split('?');
+ var path = parts[0];
+ var querystring = parts[1];
+
+ var resource = '';
+
+ if (r.virtualHostedBucket)
+ resource += '/' + r.virtualHostedBucket;
+
+ resource += path;
+
+ if (querystring) {
+
+ var resources = [];
+
+ AWS.util.arrayEach.call(this, querystring.split('&'), function (param) {
+ var name = param.split('=')[0];
+ var value = param.split('=')[1];
+ if (this.subResources[name] || this.responseHeaders[name]) {
+ var subresource = { name: name };
+ if (value !== undefined) {
+ if (this.subResources[name]) {
+ subresource.value = value;
+ } else {
+ subresource.value = decodeURIComponent(value);
+ }
+ }
+ resources.push(subresource);
+ }
+ });
+
+ resources.sort(function (a, b) { return a.name < b.name ? -1 : 1; });
+
+ if (resources.length) {
+
+ querystring = [];
+ AWS.util.arrayEach(resources, function (res) {
+ if (res.value === undefined)
+ querystring.push(res.name);
+ else
+ querystring.push(res.name + '=' + res.value);
+ });
+
+ resource += '?' + querystring.join('&');
+ }
+
+ }
+
+ return resource;
+
+ },
+
+ sign: function sign(secret, string) {
+ return AWS.util.crypto.hmac(secret, string, 'base64', 'sha1');
+ }
+});
+
+module.exports = AWS.Signers.S3;
+
+},{"../core":3}],46:[function(require,module,exports){
+var AWS = require('../core');
+var inherit = AWS.util.inherit;
+
+
+AWS.Signers.V2 = inherit(AWS.Signers.RequestSigner, {
+ addAuthorization: function addAuthorization(credentials, date) {
+
+ if (!date) date = AWS.util.date.getDate();
+
+ var r = this.request;
+
+ r.params.Timestamp = AWS.util.date.iso8601(date);
+ r.params.SignatureVersion = '2';
+ r.params.SignatureMethod = 'HmacSHA256';
+ r.params.AWSAccessKeyId = credentials.accessKeyId;
+
+ if (credentials.sessionToken) {
+ r.params.SecurityToken = credentials.sessionToken;
+ }
+
+ delete r.params.Signature; // delete old Signature for re-signing
+ r.params.Signature = this.signature(credentials);
+
+ r.body = AWS.util.queryParamsToString(r.params);
+ r.headers['Content-Length'] = r.body.length;
+ },
+
+ signature: function signature(credentials) {
+ return AWS.util.crypto.hmac(credentials.secretAccessKey, this.stringToSign(), 'base64');
+ },
+
+ stringToSign: function stringToSign() {
+ var parts = [];
+ parts.push(this.request.method);
+ parts.push(this.request.endpoint.host.toLowerCase());
+ parts.push(this.request.pathname());
+ parts.push(AWS.util.queryParamsToString(this.request.params));
+ return parts.join('\n');
+ }
+
+});
+
+module.exports = AWS.Signers.V2;
+
+},{"../core":3}],47:[function(require,module,exports){
+var AWS = require('../core');
+var inherit = AWS.util.inherit;
+
+
+AWS.Signers.V3 = inherit(AWS.Signers.RequestSigner, {
+ addAuthorization: function addAuthorization(credentials, date) {
+
+ var datetime = AWS.util.date.rfc822(date);
+
+ this.request.headers['X-Amz-Date'] = datetime;
+
+ if (credentials.sessionToken) {
+ this.request.headers['x-amz-security-token'] = credentials.sessionToken;
+ }
+
+ this.request.headers['X-Amzn-Authorization'] =
+ this.authorization(credentials, datetime);
+
+ },
+
+ authorization: function authorization(credentials) {
+ return 'AWS3 ' +
+ 'AWSAccessKeyId=' + credentials.accessKeyId + ',' +
+ 'Algorithm=HmacSHA256,' +
+ 'SignedHeaders=' + this.signedHeaders() + ',' +
+ 'Signature=' + this.signature(credentials);
+ },
+
+ signedHeaders: function signedHeaders() {
+ var headers = [];
+ AWS.util.arrayEach(this.headersToSign(), function iterator(h) {
+ headers.push(h.toLowerCase());
+ });
+ return headers.sort().join(';');
+ },
+
+ canonicalHeaders: function canonicalHeaders() {
+ var headers = this.request.headers;
+ var parts = [];
+ AWS.util.arrayEach(this.headersToSign(), function iterator(h) {
+ parts.push(h.toLowerCase().trim() + ':' + String(headers[h]).trim());
+ });
+ return parts.sort().join('\n') + '\n';
+ },
+
+ headersToSign: function headersToSign() {
+ var headers = [];
+ AWS.util.each(this.request.headers, function iterator(k) {
+ if (k === 'Host' || k === 'Content-Encoding' || k.match(/^X-Amz/i)) {
+ headers.push(k);
+ }
+ });
+ return headers;
+ },
+
+ signature: function signature(credentials) {
+ return AWS.util.crypto.hmac(credentials.secretAccessKey, this.stringToSign(), 'base64');
+ },
+
+ stringToSign: function stringToSign() {
+ var parts = [];
+ parts.push(this.request.method);
+ parts.push('/');
+ parts.push('');
+ parts.push(this.canonicalHeaders());
+ parts.push(this.request.body);
+ return AWS.util.crypto.sha256(parts.join('\n'));
+ }
+
+});
+
+module.exports = AWS.Signers.V3;
+
+},{"../core":3}],48:[function(require,module,exports){
+var AWS = require('../core');
+var inherit = AWS.util.inherit;
+
+require('./v3');
+
+
+AWS.Signers.V3Https = inherit(AWS.Signers.V3, {
+ authorization: function authorization(credentials) {
+ return 'AWS3-HTTPS ' +
+ 'AWSAccessKeyId=' + credentials.accessKeyId + ',' +
+ 'Algorithm=HmacSHA256,' +
+ 'Signature=' + this.signature(credentials);
+ },
+
+ stringToSign: function stringToSign() {
+ return this.request.headers['X-Amz-Date'];
+ }
+});
+
+module.exports = AWS.Signers.V3Https;
+
+},{"../core":3,"./v3":47}],49:[function(require,module,exports){
+var AWS = require('../core');
+var inherit = AWS.util.inherit;
+
+
+var cachedSecret = {};
+
+
+var expiresHeader = 'presigned-expires';
+
+
+AWS.Signers.V4 = inherit(AWS.Signers.RequestSigner, {
+ constructor: function V4(request, serviceName) {
+ AWS.Signers.RequestSigner.call(this, request);
+ this.serviceName = serviceName;
+ },
+
+ algorithm: 'AWS4-HMAC-SHA256',
+
+ addAuthorization: function addAuthorization(credentials, date) {
+ var datetime = AWS.util.date.iso8601(date).replace(/[:\-]|\.\d{3}/g, '');
+
+ if (this.isPresigned()) {
+ this.updateForPresigned(credentials, datetime);
+ } else {
+ this.addHeaders(credentials, datetime);
+ }
+
+ this.request.headers['Authorization'] =
+ this.authorization(credentials, datetime);
+ },
+
+ addHeaders: function addHeaders(credentials, datetime) {
+ this.request.headers['X-Amz-Date'] = datetime;
+ if (credentials.sessionToken) {
+ this.request.headers['x-amz-security-token'] = credentials.sessionToken;
+ }
+ },
+
+ updateForPresigned: function updateForPresigned(credentials, datetime) {
+ var credString = this.credentialString(datetime);
+ var qs = {
+ 'X-Amz-Date': datetime,
+ 'X-Amz-Algorithm': this.algorithm,
+ 'X-Amz-Credential': credentials.accessKeyId + '/' + credString,
+ 'X-Amz-Expires': this.request.headers[expiresHeader],
+ 'X-Amz-SignedHeaders': this.signedHeaders()
+ };
+
+ if (credentials.sessionToken) {
+ qs['X-Amz-Security-Token'] = credentials.sessionToken;
+ }
+
+ if (this.request.headers['Content-Type']) {
+ qs['Content-Type'] = this.request.headers['Content-Type'];
+ }
+
+ AWS.util.each.call(this, this.request.headers, function(key, value) {
+ if (key === expiresHeader) return;
+ if (this.isSignableHeader(key) &&
+ key.toLowerCase().indexOf('x-amz-') === 0) {
+ qs[key] = value;
+ }
+ });
+
+ var sep = this.request.path.indexOf('?') >= 0 ? '&' : '?';
+ this.request.path += sep + AWS.util.queryParamsToString(qs);
+ },
+
+ authorization: function authorization(credentials, datetime) {
+ var parts = [];
+ var credString = this.credentialString(datetime);
+ parts.push(this.algorithm + ' Credential=' +
+ credentials.accessKeyId + '/' + credString);
+ parts.push('SignedHeaders=' + this.signedHeaders());
+ parts.push('Signature=' + this.signature(credentials, datetime));
+ return parts.join(', ');
+ },
+
+ signature: function signature(credentials, datetime) {
+ var cache = cachedSecret[this.serviceName];
+ var date = datetime.substr(0, 8);
+ if (!cache ||
+ cache.akid !== credentials.accessKeyId ||
+ cache.region !== this.request.region ||
+ cache.date !== date) {
+ var kSecret = credentials.secretAccessKey;
+ var kDate = AWS.util.crypto.hmac('AWS4' + kSecret, date, 'buffer');
+ var kRegion = AWS.util.crypto.hmac(kDate, this.request.region, 'buffer');
+ var kService = AWS.util.crypto.hmac(kRegion, this.serviceName, 'buffer');
+ var kCredentials = AWS.util.crypto.hmac(kService, 'aws4_request', 'buffer');
+ cachedSecret[this.serviceName] = {
+ region: this.request.region, date: date,
+ key: kCredentials, akid: credentials.accessKeyId
+ };
+ }
+
+ var key = cachedSecret[this.serviceName].key;
+ return AWS.util.crypto.hmac(key, this.stringToSign(datetime), 'hex');
+ },
+
+ stringToSign: function stringToSign(datetime) {
+ var parts = [];
+ parts.push('AWS4-HMAC-SHA256');
+ parts.push(datetime);
+ parts.push(this.credentialString(datetime));
+ parts.push(this.hexEncodedHash(this.canonicalString()));
+ return parts.join('\n');
+ },
+
+ canonicalString: function canonicalString() {
+ var parts = [], pathname = this.request.pathname();
+ if (this.serviceName !== 's3') pathname = AWS.util.uriEscapePath(pathname);
+
+ parts.push(this.request.method);
+ parts.push(pathname);
+ parts.push(this.request.search());
+ parts.push(this.canonicalHeaders() + '\n');
+ parts.push(this.signedHeaders());
+ parts.push(this.hexEncodedBodyHash());
+ return parts.join('\n');
+ },
+
+ canonicalHeaders: function canonicalHeaders() {
+ var headers = [];
+ AWS.util.each.call(this, this.request.headers, function (key, item) {
+ headers.push([key, item]);
+ });
+ headers.sort(function (a, b) {
+ return a[0].toLowerCase() < b[0].toLowerCase() ? -1 : 1;
+ });
+ var parts = [];
+ AWS.util.arrayEach.call(this, headers, function (item) {
+ var key = item[0].toLowerCase();
+ if (this.isSignableHeader(key)) {
+ parts.push(key + ':' +
+ this.canonicalHeaderValues(item[1].toString()));
+ }
+ });
+ return parts.join('\n');
+ },
+
+ canonicalHeaderValues: function canonicalHeaderValues(values) {
+ return values.replace(/\s+/g, ' ').replace(/^\s+|\s+$/g, '');
+ },
+
+ signedHeaders: function signedHeaders() {
+ var keys = [];
+ AWS.util.each.call(this, this.request.headers, function (key) {
+ key = key.toLowerCase();
+ if (this.isSignableHeader(key)) keys.push(key);
+ });
+ return keys.sort().join(';');
+ },
+
+ credentialString: function credentialString(datetime) {
+ var parts = [];
+ parts.push(datetime.substr(0, 8));
+ parts.push(this.request.region);
+ parts.push(this.serviceName);
+ parts.push('aws4_request');
+ return parts.join('/');
+ },
+
+ hexEncodedHash: function hash(string) {
+ return AWS.util.crypto.sha256(string, 'hex');
+ },
+
+ hexEncodedBodyHash: function hexEncodedBodyHash() {
+ if (this.isPresigned() && this.serviceName === 's3') {
+ return 'UNSIGNED-PAYLOAD';
+ } else if (this.request.headers['X-Amz-Content-Sha256']) {
+ return this.request.headers['X-Amz-Content-Sha256'];
+ } else {
+ return this.hexEncodedHash(this.request.body || '');
+ }
+ },
+
+ unsignableHeaders: ['authorization', 'content-type', 'content-length',
+ 'user-agent', expiresHeader],
+
+ isSignableHeader: function isSignableHeader(key) {
+ if (key.toLowerCase().indexOf('x-amz-') === 0) return true;
+ return this.unsignableHeaders.indexOf(key) < 0;
+ },
+
+ isPresigned: function isPresigned() {
+ return this.request.headers[expiresHeader] ? true : false;
+ }
+
+});
+
+module.exports = AWS.Signers.V4;
+
+},{"../core":3}],50:[function(require,module,exports){
+function AcceptorStateMachine(states, state) {
+ this.currentState = state || null;
+ this.states = states || {};
+}
+
+AcceptorStateMachine.prototype.runTo = function runTo(finalState, done, bindObject, inputError) {
+ if (typeof finalState === 'function') {
+ inputError = bindObject; bindObject = done;
+ done = finalState; finalState = null;
+ }
+
+ var self = this;
+ var state = self.states[self.currentState];
+ state.fn.call(bindObject || self, inputError, function(err) {
+ if (err) {
+ if (state.fail) self.currentState = state.fail;
+ else return done ? done.call(bindObject, err) : null;
+ } else {
+ if (state.accept) self.currentState = state.accept;
+ else return done ? done.call(bindObject) : null;
+ }
+ if (self.currentState === finalState) {
+ return done ? done.call(bindObject, err) : null;
+ }
+
+ self.runTo(finalState, done, bindObject, err);
+ });
+};
+
+AcceptorStateMachine.prototype.addState = function addState(name, acceptState, failState, fn) {
+ if (typeof acceptState === 'function') {
+ fn = acceptState; acceptState = null; failState = null;
+ } else if (typeof failState === 'function') {
+ fn = failState; failState = null;
+ }
+
+ if (!this.currentState) this.currentState = name;
+ this.states[name] = { accept: acceptState, fail: failState, fn: fn };
+ return this;
+};
+
+module.exports = AcceptorStateMachine;
+
+},{}],51:[function(require,module,exports){
+(function (process){
+
+
+var cryptoLib = require('crypto');
+var Buffer = require('buffer').Buffer;
+var AWS;
+
+
+var util = {
+ engine: function engine() {
+ if (util.isBrowser() && typeof navigator !== 'undefined') {
+ return navigator.userAgent;
+ } else {
+ return process.platform + '/' + process.version;
+ }
+ },
+
+ userAgent: function userAgent() {
+ var name = util.isBrowser() ? 'js' : 'nodejs';
+ var agent = 'aws-sdk-' + name + '/' + require('./core').VERSION;
+ if (name === 'nodejs') agent += ' ' + util.engine();
+ return agent;
+ },
+
+ isBrowser: function isBrowser() { return process && process.browser; },
+ isNode: function isNode() { return !util.isBrowser(); },
+ nodeRequire: function nodeRequire(module) {
+ if (util.isNode()) return require(module);
+ },
+ multiRequire: function multiRequire(module1, module2) {
+ return require(util.isNode() ? module1 : module2);
+ },
+
+ uriEscape: function uriEscape(string) {
+ var output = encodeURIComponent(string);
+ output = output.replace(/[^A-Za-z0-9_.~\-%]+/g, escape);
+
+ output = output.replace(/[*]/g, function(ch) {
+ return '%' + ch.charCodeAt(0).toString(16).toUpperCase();
+ });
+
+ return output;
+ },
+
+ uriEscapePath: function uriEscapePath(string) {
+ var parts = [];
+ util.arrayEach(string.split('/'), function (part) {
+ parts.push(util.uriEscape(part));
+ });
+ return parts.join('/');
+ },
+
+ urlParse: function urlParse(url) {
+ return require('url').parse(url);
+ },
+
+ urlFormat: function urlFormat(url) {
+ return require('url').format(url);
+ },
+
+ queryStringParse: function queryStringParse(qs) {
+ return require('querystring').parse(qs);
+ },
+
+ queryParamsToString: function queryParamsToString(params) {
+ var items = [];
+ var escape = util.uriEscape;
+ var sortedKeys = Object.keys(params).sort();
+
+ util.arrayEach(sortedKeys, function(name) {
+ var value = params[name];
+ var ename = escape(name);
+ var result = ename + '=';
+ if (Array.isArray(value)) {
+ var vals = [];
+ util.arrayEach(value, function(item) { vals.push(escape(item)); });
+ result = ename + '=' + vals.sort().join('&' + ename + '=');
+ } else if (value !== undefined && value !== null) {
+ result = ename + '=' + escape(value);
+ }
+ items.push(result);
+ });
+
+ return items.join('&');
+ },
+
+ readFileSync: function readFileSync(path) {
+ if (typeof window !== 'undefined') return null;
+ return util.nodeRequire('fs').readFileSync(path, 'utf-8');
+ },
+
+ base64: {
+
+ encode: function encode64(string) {
+ return new Buffer(string).toString('base64');
+ },
+
+ decode: function decode64(string) {
+ return new Buffer(string, 'base64');
+ }
+
+ },
+
+ Buffer: Buffer,
+
+ buffer: {
+ toStream: function toStream(buffer) {
+ if (!util.Buffer.isBuffer(buffer)) buffer = new util.Buffer(buffer);
+
+ var readable = new (util.nodeRequire('stream').Readable)();
+ var pos = 0;
+ readable._read = function(size) {
+ if (pos >= buffer.length) return readable.push(null);
+
+ var end = pos + size;
+ if (end > buffer.length) end = buffer.length;
+ readable.push(buffer.slice(pos, end));
+ pos = end;
+ };
+
+ return readable;
+ },
+
+
+ concat: function(buffers) {
+ var length = 0,
+ offset = 0,
+ buffer = null, i;
+
+ for (i = 0; i < buffers.length; i++) {
+ length += buffers[i].length;
+ }
+
+ buffer = new Buffer(length);
+
+ for (i = 0; i < buffers.length; i++) {
+ buffers[i].copy(buffer, offset);
+ offset += buffers[i].length;
+ }
+
+ return buffer;
+ }
+ },
+
+ string: {
+ byteLength: function byteLength(string) {
+ if (string === null || string === undefined) return 0;
+ if (typeof string === 'string') string = new Buffer(string);
+
+ if (typeof string.byteLength === 'number') {
+ return string.byteLength;
+ } else if (typeof string.length === 'number') {
+ return string.length;
+ } else if (typeof string.size === 'number') {
+ return string.size;
+ } else if (typeof string.path === 'string') {
+ return util.nodeRequire('fs').lstatSync(string.path).size;
+ } else {
+ throw util.error(new Error('Cannot determine length of ' + string),
+ { object: string });
+ }
+ },
+
+ upperFirst: function upperFirst(string) {
+ return string[0].toUpperCase() + string.substr(1);
+ },
+
+ lowerFirst: function lowerFirst(string) {
+ return string[0].toLowerCase() + string.substr(1);
+ }
+ },
+
+ ini: {
+ parse: function string(ini) {
+ var currentSection, map = {};
+ util.arrayEach(ini.split(/\r?\n/), function(line) {
+ line = line.split(/(^|\s);/)[0]; // remove comments
+ var section = line.match(/^\s*\[([^\[\]]+)\]\s*$/);
+ if (section) {
+ currentSection = section[1];
+ } else if (currentSection) {
+ var item = line.match(/^\s*(.+?)\s*=\s*(.+?)\s*$/);
+ if (item) {
+ map[currentSection] = map[currentSection] || {};
+ map[currentSection][item[1]] = item[2];
+ }
+ }
+ });
+
+ return map;
+ }
+ },
+
+ fn: {
+ noop: function() {},
+
+
+ makeAsync: function makeAsync(fn, expectedArgs) {
+ if (expectedArgs && expectedArgs <= fn.length) {
+ return fn;
+ }
+
+ return function() {
+ var args = Array.prototype.slice.call(arguments, 0);
+ var callback = args.pop();
+ var result = fn.apply(null, args);
+ callback(result);
+ };
+ }
+ },
+
+ jamespath: {
+ query: function query(expression, data) {
+ if (!data) return [];
+
+ var results = [];
+ var expressions = expression.split(/\s+\|\|\s+/);
+ util.arrayEach.call(this, expressions, function (expr) {
+ var objects = [data];
+ var tokens = expr.split('.');
+ util.arrayEach.call(this, tokens, function (token) {
+ var match = token.match('^(.+?)(?:\\[(-?\\d+|\\*|)\\])?$');
+ var newObjects = [];
+ util.arrayEach.call(this, objects, function (obj) {
+ if (match[1] === '*') {
+ util.arrayEach.call(this, obj, function (value) {
+ newObjects.push(value);
+ });
+ } else if (obj.hasOwnProperty(match[1])) {
+ newObjects.push(obj[match[1]]);
+ }
+ });
+ objects = newObjects;
+
+ if (match[2] !== undefined) {
+ newObjects = [];
+ util.arrayEach.call(this, objects, function (obj) {
+ if (Array.isArray(obj)) {
+ if (match[2] === '*' || match[2] === '') {
+ newObjects = newObjects.concat(obj);
+ } else {
+ var idx = parseInt(match[2], 10);
+ if (idx < 0) idx = obj.length + idx; // negative indexing
+ newObjects.push(obj[idx]);
+ }
+ }
+ });
+ objects = newObjects;
+ }
+
+ if (objects.length === 0) return util.abort;
+ });
+
+ if (objects.length > 0) {
+ results = objects;
+ return util.abort;
+ }
+ });
+
+ return results;
+ },
+
+ find: function find(expression, data) {
+ return util.jamespath.query(expression, data)[0];
+ }
+ },
+
+
+ date: {
+
+
+ getDate: function getDate() {
+ if (!AWS) AWS = require('./core');
+ if (AWS.config.systemClockOffset) { // use offset when non-zero
+ return new Date(new Date().getTime() + AWS.config.systemClockOffset);
+ } else {
+ return new Date();
+ }
+ },
+
+
+ iso8601: function iso8601(date) {
+ if (date === undefined) { date = util.date.getDate(); }
+ return date.toISOString().replace(/\.\d{3}Z$/, 'Z');
+ },
+
+
+ rfc822: function rfc822(date) {
+ if (date === undefined) { date = util.date.getDate(); }
+ return date.toUTCString();
+ },
+
+
+ unixTimestamp: function unixTimestamp(date) {
+ if (date === undefined) { date = util.date.getDate(); }
+ return date.getTime() / 1000;
+ },
+
+
+ from: function format(date) {
+ if (typeof date === 'number') {
+ return new Date(date * 1000); // unix timestamp
+ } else {
+ return new Date(date);
+ }
+ },
+
+
+ format: function format(date, formatter) {
+ if (!formatter) formatter = 'iso8601';
+ return util.date[formatter](util.date.from(date));
+ },
+
+ parseTimestamp: function parseTimestamp(value) {
+ if (typeof value === 'number') { // unix timestamp (number)
+ return new Date(value * 1000);
+ } else if (value.match(/^\d+$/)) { // unix timestamp
+ return new Date(value * 1000);
+ } else if (value.match(/^\d{4}/)) { // iso8601
+ return new Date(value);
+ } else if (value.match(/^\w{3},/)) { // rfc822
+ return new Date(value);
+ } else {
+ throw util.error(
+ new Error('unhandled timestamp format: ' + value),
+ {code: 'TimestampParserError'});
+ }
+ }
+
+ },
+
+ crypto: {
+ crc32Table: [
+ 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419,
+ 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4,
+ 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07,
+ 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
+ 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856,
+ 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
+ 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
+ 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+ 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3,
+ 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A,
+ 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599,
+ 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+ 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190,
+ 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
+ 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E,
+ 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+ 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED,
+ 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
+ 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3,
+ 0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
+ 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
+ 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
+ 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010,
+ 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+ 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17,
+ 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6,
+ 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615,
+ 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
+ 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344,
+ 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
+ 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A,
+ 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+ 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1,
+ 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C,
+ 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
+ 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+ 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE,
+ 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
+ 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C,
+ 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+ 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B,
+ 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
+ 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1,
+ 0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
+ 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278,
+ 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
+ 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66,
+ 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+ 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
+ 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8,
+ 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B,
+ 0x2D02EF8D],
+
+ crc32: function crc32(data) {
+ var tbl = util.crypto.crc32Table;
+ var crc = 0 ^ -1;
+
+ if (typeof data === 'string') {
+ data = new Buffer(data);
+ }
+
+ for (var i = 0; i < data.length; i++) {
+ var code = data.readUInt8(i);
+ crc = (crc >>> 8) ^ tbl[(crc ^ code) & 0xFF];
+ }
+ return (crc ^ -1) >>> 0;
+ },
+
+ hmac: function hmac(key, string, digest, fn) {
+ if (!digest) digest = 'binary';
+ if (digest === 'buffer') { digest = undefined; }
+ if (!fn) fn = 'sha256';
+ if (typeof string === 'string') string = new Buffer(string);
+ return cryptoLib.createHmac(fn, key).update(string).digest(digest);
+ },
+
+ md5: function md5(data, digest, callback) {
+ return util.crypto.hash('md5', data, digest, callback);
+ },
+
+ sha256: function sha256(data, digest, callback) {
+ return util.crypto.hash('sha256', data, digest, callback);
+ },
+
+ hash: function(algorithm, data, digest, callback) {
+ var hash = util.crypto.createHash(algorithm);
+ if (!digest) { digest = 'binary'; }
+ if (digest === 'buffer') { digest = undefined; }
+ if (typeof data === 'string') data = new Buffer(data);
+ var sliceFn = util.arraySliceFn(data);
+ var isBuffer = Buffer.isBuffer(data);
+
+ if (callback && typeof data === 'object' &&
+ typeof data.on === 'function' && !isBuffer) {
+ data.on('data', function(chunk) { hash.update(chunk); });
+ data.on('error', function(err) { callback(err); });
+ data.on('end', function() { callback(null, hash.digest(digest)); });
+ } else if (callback && sliceFn && !isBuffer &&
+ typeof FileReader !== 'undefined') {
+ var index = 0, size = 1024 * 512;
+ var reader = new FileReader();
+ reader.onerror = function() {
+ callback(new Error('Failed to read data.'));
+ };
+ reader.onload = function() {
+ var buf = new Buffer(new Uint8Array(reader.result));
+ hash.update(buf);
+ index += buf.length;
+ reader._continueReading();
+ };
+ reader._continueReading = function() {
+ if (index >= data.size) {
+ callback(null, hash.digest(digest));
+ return;
+ }
+
+ var back = index + size;
+ if (back > data.size) back = data.size;
+ reader.readAsArrayBuffer(sliceFn.call(data, index, back));
+ };
+
+ reader._continueReading();
+ } else {
+ if (util.isBrowser() && typeof data === 'object' && !isBuffer) {
+ data = new Buffer(new Uint8Array(data));
+ }
+ var out = hash.update(data).digest(digest);
+ if (callback) callback(null, out);
+ return out;
+ }
+ },
+
+ toHex: function toHex(data) {
+ var out = [];
+ for (var i = 0; i < data.length; i++) {
+ out.push(('0' + data.charCodeAt(i).toString(16)).substr(-2, 2));
+ }
+ return out.join('');
+ },
+
+ createHash: function createHash(algorithm) {
+ return cryptoLib.createHash(algorithm);
+ }
+
+ },
+
+
+
+
+ abort: {},
+
+ each: function each(object, iterFunction) {
+ for (var key in object) {
+ if (object.hasOwnProperty(key)) {
+ var ret = iterFunction.call(this, key, object[key]);
+ if (ret === util.abort) break;
+ }
+ }
+ },
+
+ arrayEach: function arrayEach(array, iterFunction) {
+ for (var idx in array) {
+ if (array.hasOwnProperty(idx)) {
+ var ret = iterFunction.call(this, array[idx], parseInt(idx, 10));
+ if (ret === util.abort) break;
+ }
+ }
+ },
+
+ update: function update(obj1, obj2) {
+ util.each(obj2, function iterator(key, item) {
+ obj1[key] = item;
+ });
+ return obj1;
+ },
+
+ merge: function merge(obj1, obj2) {
+ return util.update(util.copy(obj1), obj2);
+ },
+
+ copy: function copy(object) {
+ if (object === null || object === undefined) return object;
+ var dupe = {};
+ for (var key in object) {
+ dupe[key] = object[key];
+ }
+ return dupe;
+ },
+
+ isEmpty: function isEmpty(obj) {
+ for (var prop in obj) {
+ if (obj.hasOwnProperty(prop)) {
+ return false;
+ }
+ }
+ return true;
+ },
+
+ arraySliceFn: function arraySliceFn(obj) {
+ var fn = obj.slice || obj.webkitSlice || obj.mozSlice;
+ return typeof fn === 'function' ? fn : null;
+ },
+
+ isType: function isType(obj, type) {
+ if (typeof type === 'function') type = util.typeName(type);
+ return Object.prototype.toString.call(obj) === '[object ' + type + ']';
+ },
+
+ typeName: function typeName(type) {
+ if (type.hasOwnProperty('name')) return type.name;
+ var str = type.toString();
+ var match = str.match(/^\s*function (.+)\(/);
+ return match ? match[1] : str;
+ },
+
+ error: function error(err, options) {
+ var originalError = null;
+ if (typeof err.message === 'string' && err.message !== '') {
+ if (typeof options === 'string' || (options && options.message)) {
+ originalError = util.copy(err);
+ originalError.message = err.message;
+ }
+ }
+ err.message = err.message || null;
+
+ if (typeof options === 'string') {
+ err.message = options;
+ } else if (typeof options === 'object') {
+ util.update(err, options);
+ if (options.message)
+ err.message = options.message;
+ if (options.code || options.name)
+ err.code = options.code || options.name;
+ if (options.stack)
+ err.stack = options.stack;
+ }
+
+ if (typeof Object.defineProperty === 'function') {
+ Object.defineProperty(err, 'name', {writable: true, enumerable: false});
+ Object.defineProperty(err, 'message', {enumerable: true});
+ }
+
+ err.name = options && options.name || err.name || err.code || 'Error';
+ err.time = new Date();
+
+ if (originalError) err.originalError = originalError;
+
+ return err;
+ },
+
+
+ inherit: function inherit(klass, features) {
+ var newObject = null;
+ if (features === undefined) {
+ features = klass;
+ klass = Object;
+ newObject = {};
+ } else {
+ var ctor = function ConstructorWrapper() {};
+ ctor.prototype = klass.prototype;
+ newObject = new ctor();
+ }
+
+ if (features.constructor === Object) {
+ features.constructor = function() {
+ if (klass !== Object) {
+ return klass.apply(this, arguments);
+ }
+ };
+ }
+
+ features.constructor.prototype = newObject;
+ util.update(features.constructor.prototype, features);
+ features.constructor.__super__ = klass;
+ return features.constructor;
+ },
+
+
+ mixin: function mixin() {
+ var klass = arguments[0];
+ for (var i = 1; i < arguments.length; i++) {
+ for (var prop in arguments[i].prototype) {
+ var fn = arguments[i].prototype[prop];
+ if (prop !== 'constructor') {
+ klass.prototype[prop] = fn;
+ }
+ }
+ }
+ return klass;
+ },
+
+
+ hideProperties: function hideProperties(obj, props) {
+ if (typeof Object.defineProperty !== 'function') return;
+
+ util.arrayEach(props, function (key) {
+ Object.defineProperty(obj, key, {
+ enumerable: false, writable: true, configurable: true });
+ });
+ },
+
+
+ property: function property(obj, name, value, enumerable, isValue) {
+ var opts = {
+ configurable: true,
+ enumerable: enumerable !== undefined ? enumerable : true
+ };
+ if (typeof value === 'function' && !isValue) {
+ opts.get = value;
+ }
+ else {
+ opts.value = value; opts.writable = true;
+ }
+
+ Object.defineProperty(obj, name, opts);
+ },
+
+
+ memoizedProperty: function memoizedProperty(obj, name, get, enumerable) {
+ var cachedValue = null;
+
+ util.property(obj, name, function() {
+ if (cachedValue === null) {
+ cachedValue = get();
+ }
+ return cachedValue;
+ }, enumerable);
+ },
+
+
+ hoistPayloadMember: function hoistPayloadMember(resp) {
+ var req = resp.request;
+ var operation = req.operation;
+ var output = req.service.api.operations[operation].output;
+ if (output.payload) {
+ var payloadMember = output.members[output.payload];
+ var responsePayload = resp.data[output.payload];
+ if (payloadMember.type === 'structure') {
+ util.each(responsePayload, function(key, value) {
+ util.property(resp.data, key, value, false);
+ });
+ }
+ }
+ },
+
+
+ computeSha256: function computeSha256(body, done) {
+ if (util.isNode()) {
+ var Stream = util.nodeRequire('stream').Stream;
+ var fs = util.nodeRequire('fs');
+ if (body instanceof Stream) {
+ if (typeof body.path === 'string') { // assume file object
+ body = fs.createReadStream(body.path);
+ } else { // TODO support other stream types
+ return done(new Error('Non-file stream objects are ' +
+ 'not supported with SigV4'));
+ }
+ }
+ }
+
+ util.crypto.sha256(body, 'hex', function(err, sha) {
+ if (err) done(err);
+ else done(null, sha);
+ });
+ }
+
+};
+
+module.exports = util;
+
+}).call(this,require("FWaASH"))
+},{"./core":3,"FWaASH":65,"buffer":54,"crypto":58,"querystring":69,"url":70}],52:[function(require,module,exports){
+var util = require('../util');
+var Shape = require('../model/shape');
+
+function DomXmlParser() { }
+
+DomXmlParser.prototype.parse = function(xml, shape) {
+ if (xml.replace(/^\s+/, '') === '') return {};
+
+ var result, error;
+ try {
+ if (window.DOMParser) {
+ try {
+ var parser = new DOMParser();
+ result = parser.parseFromString(xml, 'text/xml');
+ } catch (syntaxError) {
+ throw util.error(new Error('Parse error in document'),
+ {originalError: syntaxError});
+ }
+
+ if (result.documentElement === null) {
+ throw new Error('Cannot parse empty document.');
+ }
+
+ var isError = result.getElementsByTagName('parsererror')[0];
+ if (isError && (isError.parentNode === result ||
+ isError.parentNode.nodeName === 'body')) {
+ throw new Error(isError.getElementsByTagName('div')[0].textContent);
+ }
+ } else if (window.ActiveXObject) {
+ result = new window.ActiveXObject('Microsoft.XMLDOM');
+ result.async = false;
+
+ if (!result.loadXML(xml)) {
+ throw new Error('Parse error in document');
+ }
+ } else {
+ throw new Error('Cannot load XML parser');
+ }
+ } catch (e) {
+ error = e;
+ }
+
+ if (result && result.documentElement && !error) {
+ var data = parseXml(result.documentElement, shape);
+ var metadata = result.getElementsByTagName('ResponseMetadata')[0];
+ if (metadata) {
+ data.ResponseMetadata = parseXml(metadata, {});
+ }
+ return data;
+ } else if (error) {
+ throw util.error(error || new Error(), {code: 'XMLParserError'});
+ } else { // empty xml document
+ return {};
+ }
+};
+
+function parseXml(xml, shape) {
+ if (!shape) shape = {};
+ switch (shape.type) {
+ case 'structure': return parseStructure(xml, shape);
+ case 'map': return parseMap(xml, shape);
+ case 'list': return parseList(xml, shape);
+ case undefined: case null: return parseUnknown(xml);
+ default: return parseScalar(xml, shape);
+ }
+}
+
+function parseStructure(xml, shape) {
+ var data = {};
+ if (xml === null) return data;
+
+ util.each(shape.members, function(memberName, memberShape) {
+ if (memberShape.isXmlAttribute) {
+ if (xml.attributes.hasOwnProperty(memberShape.name)) {
+ var value = xml.attributes[memberShape.name].value;
+ data[memberName] = parseXml({textContent: value}, memberShape);
+ }
+ } else {
+ var xmlChild = memberShape.flattened ? xml :
+ xml.getElementsByTagName(memberShape.name)[0];
+ if (xmlChild) {
+ data[memberName] = parseXml(xmlChild, memberShape);
+ } else if (!memberShape.flattened && memberShape.type === 'list') {
+ data[memberName] = memberShape.defaultValue;
+ }
+ }
+ });
+
+ return data;
+}
+
+function parseMap(xml, shape) {
+ var data = {};
+ var xmlKey = shape.key.name || 'key';
+ var xmlValue = shape.value.name || 'value';
+ var tagName = shape.flattened ? shape.name : 'entry';
+
+ var child = xml.firstElementChild;
+ while (child) {
+ if (child.nodeName === tagName) {
+ var key = child.getElementsByTagName(xmlKey)[0].textContent;
+ var value = child.getElementsByTagName(xmlValue)[0];
+ data[key] = parseXml(value, shape.value);
+ }
+ child = child.nextElementSibling;
+ }
+ return data;
+}
+
+function parseList(xml, shape) {
+ var data = [];
+ var tagName = shape.flattened ? shape.name : (shape.member.name || 'member');
+
+ var child = xml.firstElementChild;
+ while (child) {
+ if (child.nodeName === tagName) {
+ data.push(parseXml(child, shape.member));
+ }
+ child = child.nextElementSibling;
+ }
+ return data;
+}
+
+function parseScalar(xml, shape) {
+ if (xml.getAttribute) {
+ var encoding = xml.getAttribute('encoding');
+ if (encoding === 'base64') {
+ shape = new Shape.create({type: encoding});
+ }
+ }
+
+ var text = xml.textContent;
+ if (text === '') text = null;
+ if (typeof shape.toType === 'function') {
+ return shape.toType(text);
+ } else {
+ return text;
+ }
+}
+
+function parseUnknown(xml) {
+ if (xml === undefined || xml === null) return '';
+
+ if (!xml.firstElementChild) {
+ if (xml.parentNode.parentNode === null) return {};
+ if (xml.childNodes.length === 0) return '';
+ else return xml.textContent;
+ }
+
+ var shape = {type: 'structure', members: {}};
+ var child = xml.firstElementChild;
+ while (child) {
+ var tag = child.nodeName;
+ if (shape.members.hasOwnProperty(tag)) {
+ shape.members[tag].type = 'list';
+ } else {
+ shape.members[tag] = {name: tag};
+ }
+ child = child.nextElementSibling;
+ }
+ return parseStructure(xml, shape);
+}
+
+module.exports = DomXmlParser;
+
+},{"../model/shape":20,"../util":51}],53:[function(require,module,exports){
+var util = require('../util');
+var builder = require('xmlbuilder');
+
+function XmlBuilder() { }
+
+XmlBuilder.prototype.toXML = function(params, shape, rootElement, noEmpty) {
+ var xml = builder.create(rootElement);
+ applyNamespaces(xml, shape);
+ serialize(xml, params, shape);
+ return xml.children.length > 0 || noEmpty ? xml.root().toString() : '';
+};
+
+function serialize(xml, value, shape) {
+ switch (shape.type) {
+ case 'structure': return serializeStructure(xml, value, shape);
+ case 'map': return serializeMap(xml, value, shape);
+ case 'list': return serializeList(xml, value, shape);
+ default: return serializeScalar(xml, value, shape);
+ }
+}
+
+function serializeStructure(xml, params, shape) {
+ util.arrayEach(shape.memberNames, function(memberName) {
+ var memberShape = shape.members[memberName];
+ if (memberShape.location !== 'body') return;
+
+ var value = params[memberName];
+ var name = memberShape.name;
+ if (value !== undefined && value !== null) {
+ if (memberShape.isXmlAttribute) {
+ xml.att(name, value);
+ } else if (memberShape.flattened) {
+ serialize(xml, value, memberShape);
+ } else {
+ var element = xml.ele(name);
+ applyNamespaces(element, memberShape);
+ serialize(element, value, memberShape);
+ }
+ }
+ });
+}
+
+function serializeMap(xml, map, shape) {
+ var xmlKey = shape.key.name || 'key';
+ var xmlValue = shape.value.name || 'value';
+
+ util.each(map, function(key, value) {
+ var entry = xml.ele(shape.flattened ? shape.name : 'entry');
+ serialize(entry.ele(xmlKey), key, shape.key);
+ serialize(entry.ele(xmlValue), value, shape.value);
+ });
+}
+
+function serializeList(xml, list, shape) {
+ if (shape.flattened) {
+ util.arrayEach(list, function(value) {
+ var name = shape.member.name || shape.name;
+ var element = xml.ele(name);
+ serialize(element, value, shape.member);
+ });
+ } else {
+ util.arrayEach(list, function(value) {
+ var name = shape.member.name || 'member';
+ var element = xml.ele(name);
+ serialize(element, value, shape.member);
+ });
+ }
+}
+
+function serializeScalar(xml, value, shape) {
+ xml.txt(shape.toWireFormat(value));
+}
+
+function applyNamespaces(xml, shape) {
+ var uri, prefix = 'xmlns';
+ if (shape.xmlNamespaceUri) {
+ uri = shape.xmlNamespaceUri;
+ if (shape.xmlNamespacePrefix) prefix += ':' + shape.xmlNamespacePrefix;
+ } else if (xml.isRoot && shape.api.xmlNamespaceUri) {
+ uri = shape.api.xmlNamespaceUri;
+ }
+
+ if (uri) xml.att(prefix, uri);
+}
+
+module.exports = XmlBuilder;
+
+},{"../util":51,"xmlbuilder":75}],54:[function(require,module,exports){
+
+
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = Buffer
+exports.INSPECT_MAX_BYTES = 50
+Buffer.poolSize = 8192
+
+
+Buffer._useTypedArrays = (function () {
+ try {
+ var buf = new ArrayBuffer(0)
+ var arr = new Uint8Array(buf)
+ arr.foo = function () { return 42 }
+ return 42 === arr.foo() &&
+ typeof arr.subarray === 'function' // Chrome 9-10 lack `subarray`
+ } catch (e) {
+ return false
+ }
+})()
+
+
+function Buffer (subject, encoding, noZero) {
+ if (!(this instanceof Buffer))
+ return new Buffer(subject, encoding, noZero)
+
+ var type = typeof subject
+
+ if (encoding === 'base64' && type === 'string') {
+ subject = stringtrim(subject)
+ while (subject.length % 4 !== 0) {
+ subject = subject + '='
+ }
+ }
+
+ var length
+ if (type === 'number')
+ length = coerce(subject)
+ else if (type === 'string')
+ length = Buffer.byteLength(subject, encoding)
+ else if (type === 'object')
+ length = coerce(subject.length) // assume that object is array-like
+ else
+ throw new Error('First argument needs to be a number, array or string.')
+
+ var buf
+ if (Buffer._useTypedArrays) {
+ buf = Buffer._augment(new Uint8Array(length))
+ } else {
+ buf = this
+ buf.length = length
+ buf._isBuffer = true
+ }
+
+ var i
+ if (Buffer._useTypedArrays && typeof subject.byteLength === 'number') {
+ buf._set(subject)
+ } else if (isArrayish(subject)) {
+ for (i = 0; i < length; i++) {
+ if (Buffer.isBuffer(subject))
+ buf[i] = subject.readUInt8(i)
+ else
+ buf[i] = subject[i]
+ }
+ } else if (type === 'string') {
+ buf.write(subject, 0, encoding)
+ } else if (type === 'number' && !Buffer._useTypedArrays && !noZero) {
+ for (i = 0; i < length; i++) {
+ buf[i] = 0
+ }
+ }
+
+ return buf
+}
+
+
+Buffer.isEncoding = function (encoding) {
+ switch (String(encoding).toLowerCase()) {
+ case 'hex':
+ case 'utf8':
+ case 'utf-8':
+ case 'ascii':
+ case 'binary':
+ case 'base64':
+ case 'raw':
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return true
+ default:
+ return false
+ }
+}
+
+Buffer.isBuffer = function (b) {
+ return !!(b !== null && b !== undefined && b._isBuffer)
+}
+
+Buffer.byteLength = function (str, encoding) {
+ var ret
+ str = str + ''
+ switch (encoding || 'utf8') {
+ case 'hex':
+ ret = str.length / 2
+ break
+ case 'utf8':
+ case 'utf-8':
+ ret = utf8ToBytes(str).length
+ break
+ case 'ascii':
+ case 'binary':
+ case 'raw':
+ ret = str.length
+ break
+ case 'base64':
+ ret = base64ToBytes(str).length
+ break
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ ret = str.length * 2
+ break
+ default:
+ throw new Error('Unknown encoding')
+ }
+ return ret
+}
+
+Buffer.concat = function (list, totalLength) {
+ assert(isArray(list), 'Usage: Buffer.concat(list, [totalLength])\n' +
+ 'list should be an Array.')
+
+ if (list.length === 0) {
+ return new Buffer(0)
+ } else if (list.length === 1) {
+ return list[0]
+ }
+
+ var i
+ if (typeof totalLength !== 'number') {
+ totalLength = 0
+ for (i = 0; i < list.length; i++) {
+ totalLength += list[i].length
+ }
+ }
+
+ var buf = new Buffer(totalLength)
+ var pos = 0
+ for (i = 0; i < list.length; i++) {
+ var item = list[i]
+ item.copy(buf, pos)
+ pos += item.length
+ }
+ return buf
+}
+
+
+function _hexWrite (buf, string, offset, length) {
+ offset = Number(offset) || 0
+ var remaining = buf.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+
+ var strLen = string.length
+ assert(strLen % 2 === 0, 'Invalid hex string')
+
+ if (length > strLen / 2) {
+ length = strLen / 2
+ }
+ for (var i = 0; i < length; i++) {
+ var byte = parseInt(string.substr(i * 2, 2), 16)
+ assert(!isNaN(byte), 'Invalid hex string')
+ buf[offset + i] = byte
+ }
+ Buffer._charsWritten = i * 2
+ return i
+}
+
+function _utf8Write (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(utf8ToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _asciiWrite (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(asciiToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _binaryWrite (buf, string, offset, length) {
+ return _asciiWrite(buf, string, offset, length)
+}
+
+function _base64Write (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(base64ToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _utf16leWrite (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(utf16leToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+Buffer.prototype.write = function (string, offset, length, encoding) {
+ if (isFinite(offset)) {
+ if (!isFinite(length)) {
+ encoding = length
+ length = undefined
+ }
+ } else { // legacy
+ var swap = encoding
+ encoding = offset
+ offset = length
+ length = swap
+ }
+
+ offset = Number(offset) || 0
+ var remaining = this.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+ encoding = String(encoding || 'utf8').toLowerCase()
+
+ var ret
+ switch (encoding) {
+ case 'hex':
+ ret = _hexWrite(this, string, offset, length)
+ break
+ case 'utf8':
+ case 'utf-8':
+ ret = _utf8Write(this, string, offset, length)
+ break
+ case 'ascii':
+ ret = _asciiWrite(this, string, offset, length)
+ break
+ case 'binary':
+ ret = _binaryWrite(this, string, offset, length)
+ break
+ case 'base64':
+ ret = _base64Write(this, string, offset, length)
+ break
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ ret = _utf16leWrite(this, string, offset, length)
+ break
+ default:
+ throw new Error('Unknown encoding')
+ }
+ return ret
+}
+
+Buffer.prototype.toString = function (encoding, start, end) {
+ var self = this
+
+ encoding = String(encoding || 'utf8').toLowerCase()
+ start = Number(start) || 0
+ end = (end !== undefined)
+ ? Number(end)
+ : end = self.length
+
+ if (end === start)
+ return ''
+
+ var ret
+ switch (encoding) {
+ case 'hex':
+ ret = _hexSlice(self, start, end)
+ break
+ case 'utf8':
+ case 'utf-8':
+ ret = _utf8Slice(self, start, end)
+ break
+ case 'ascii':
+ ret = _asciiSlice(self, start, end)
+ break
+ case 'binary':
+ ret = _binarySlice(self, start, end)
+ break
+ case 'base64':
+ ret = _base64Slice(self, start, end)
+ break
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ ret = _utf16leSlice(self, start, end)
+ break
+ default:
+ throw new Error('Unknown encoding')
+ }
+ return ret
+}
+
+Buffer.prototype.toJSON = function () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
+
+Buffer.prototype.copy = function (target, target_start, start, end) {
+ var source = this
+
+ if (!start) start = 0
+ if (!end && end !== 0) end = this.length
+ if (!target_start) target_start = 0
+
+ if (end === start) return
+ if (target.length === 0 || source.length === 0) return
+
+ assert(end >= start, 'sourceEnd < sourceStart')
+ assert(target_start >= 0 && target_start < target.length,
+ 'targetStart out of bounds')
+ assert(start >= 0 && start < source.length, 'sourceStart out of bounds')
+ assert(end >= 0 && end <= source.length, 'sourceEnd out of bounds')
+
+ if (end > this.length)
+ end = this.length
+ if (target.length - target_start < end - start)
+ end = target.length - target_start + start
+
+ var len = end - start
+
+ if (len < 100 || !Buffer._useTypedArrays) {
+ for (var i = 0; i < len; i++)
+ target[i + target_start] = this[i + start]
+ } else {
+ target._set(this.subarray(start, start + len), target_start)
+ }
+}
+
+function _base64Slice (buf, start, end) {
+ if (start === 0 && end === buf.length) {
+ return base64.fromByteArray(buf)
+ } else {
+ return base64.fromByteArray(buf.slice(start, end))
+ }
+}
+
+function _utf8Slice (buf, start, end) {
+ var res = ''
+ var tmp = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; i++) {
+ if (buf[i] <= 0x7F) {
+ res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
+ tmp = ''
+ } else {
+ tmp += '%' + buf[i].toString(16)
+ }
+ }
+
+ return res + decodeUtf8Char(tmp)
+}
+
+function _asciiSlice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; i++)
+ ret += String.fromCharCode(buf[i])
+ return ret
+}
+
+function _binarySlice (buf, start, end) {
+ return _asciiSlice(buf, start, end)
+}
+
+function _hexSlice (buf, start, end) {
+ var len = buf.length
+
+ if (!start || start < 0) start = 0
+ if (!end || end < 0 || end > len) end = len
+
+ var out = ''
+ for (var i = start; i < end; i++) {
+ out += toHex(buf[i])
+ }
+ return out
+}
+
+function _utf16leSlice (buf, start, end) {
+ var bytes = buf.slice(start, end)
+ var res = ''
+ for (var i = 0; i < bytes.length; i += 2) {
+ res += String.fromCharCode(bytes[i] + bytes[i+1] * 256)
+ }
+ return res
+}
+
+Buffer.prototype.slice = function (start, end) {
+ var len = this.length
+ start = clamp(start, len, 0)
+ end = clamp(end, len, len)
+
+ if (Buffer._useTypedArrays) {
+ return Buffer._augment(this.subarray(start, end))
+ } else {
+ var sliceLen = end - start
+ var newBuf = new Buffer(sliceLen, undefined, true)
+ for (var i = 0; i < sliceLen; i++) {
+ newBuf[i] = this[i + start]
+ }
+ return newBuf
+ }
+}
+
+Buffer.prototype.get = function (offset) {
+ console.log('.get() is deprecated. Access using array indexes instead.')
+ return this.readUInt8(offset)
+}
+
+Buffer.prototype.set = function (v, offset) {
+ console.log('.set() is deprecated. Access using array indexes instead.')
+ return this.writeUInt8(v, offset)
+}
+
+Buffer.prototype.readUInt8 = function (offset, noAssert) {
+ if (!noAssert) {
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'Trying to read beyond buffer length')
+ }
+
+ if (offset >= this.length)
+ return
+
+ return this[offset]
+}
+
+function _readUInt16 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val
+ if (littleEndian) {
+ val = buf[offset]
+ if (offset + 1 < len)
+ val |= buf[offset + 1] << 8
+ } else {
+ val = buf[offset] << 8
+ if (offset + 1 < len)
+ val |= buf[offset + 1]
+ }
+ return val
+}
+
+Buffer.prototype.readUInt16LE = function (offset, noAssert) {
+ return _readUInt16(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readUInt16BE = function (offset, noAssert) {
+ return _readUInt16(this, offset, false, noAssert)
+}
+
+function _readUInt32 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val
+ if (littleEndian) {
+ if (offset + 2 < len)
+ val = buf[offset + 2] << 16
+ if (offset + 1 < len)
+ val |= buf[offset + 1] << 8
+ val |= buf[offset]
+ if (offset + 3 < len)
+ val = val + (buf[offset + 3] << 24 >>> 0)
+ } else {
+ if (offset + 1 < len)
+ val = buf[offset + 1] << 16
+ if (offset + 2 < len)
+ val |= buf[offset + 2] << 8
+ if (offset + 3 < len)
+ val |= buf[offset + 3]
+ val = val + (buf[offset] << 24 >>> 0)
+ }
+ return val
+}
+
+Buffer.prototype.readUInt32LE = function (offset, noAssert) {
+ return _readUInt32(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readUInt32BE = function (offset, noAssert) {
+ return _readUInt32(this, offset, false, noAssert)
+}
+
+Buffer.prototype.readInt8 = function (offset, noAssert) {
+ if (!noAssert) {
+ assert(offset !== undefined && offset !== null,
+ 'missing offset')
+ assert(offset < this.length, 'Trying to read beyond buffer length')
+ }
+
+ if (offset >= this.length)
+ return
+
+ var neg = this[offset] & 0x80
+ if (neg)
+ return (0xff - this[offset] + 1) * -1
+ else
+ return this[offset]
+}
+
+function _readInt16 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val = _readUInt16(buf, offset, littleEndian, true)
+ var neg = val & 0x8000
+ if (neg)
+ return (0xffff - val + 1) * -1
+ else
+ return val
+}
+
+Buffer.prototype.readInt16LE = function (offset, noAssert) {
+ return _readInt16(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readInt16BE = function (offset, noAssert) {
+ return _readInt16(this, offset, false, noAssert)
+}
+
+function _readInt32 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val = _readUInt32(buf, offset, littleEndian, true)
+ var neg = val & 0x80000000
+ if (neg)
+ return (0xffffffff - val + 1) * -1
+ else
+ return val
+}
+
+Buffer.prototype.readInt32LE = function (offset, noAssert) {
+ return _readInt32(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readInt32BE = function (offset, noAssert) {
+ return _readInt32(this, offset, false, noAssert)
+}
+
+function _readFloat (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ return ieee754.read(buf, offset, littleEndian, 23, 4)
+}
+
+Buffer.prototype.readFloatLE = function (offset, noAssert) {
+ return _readFloat(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readFloatBE = function (offset, noAssert) {
+ return _readFloat(this, offset, false, noAssert)
+}
+
+function _readDouble (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset + 7 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ return ieee754.read(buf, offset, littleEndian, 52, 8)
+}
+
+Buffer.prototype.readDoubleLE = function (offset, noAssert) {
+ return _readDouble(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readDoubleBE = function (offset, noAssert) {
+ return _readDouble(this, offset, false, noAssert)
+}
+
+Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xff)
+ }
+
+ if (offset >= this.length) return
+
+ this[offset] = value
+}
+
+function _writeUInt16 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xffff)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ for (var i = 0, j = Math.min(len - offset, 2); i < j; i++) {
+ buf[offset + i] =
+ (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+ (littleEndian ? i : 1 - i) * 8
+ }
+}
+
+Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
+ _writeUInt16(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
+ _writeUInt16(this, value, offset, false, noAssert)
+}
+
+function _writeUInt32 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xffffffff)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) {
+ buf[offset + i] =
+ (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+ }
+}
+
+Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
+ _writeUInt32(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
+ _writeUInt32(this, value, offset, false, noAssert)
+}
+
+Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7f, -0x80)
+ }
+
+ if (offset >= this.length)
+ return
+
+ if (value >= 0)
+ this.writeUInt8(value, offset, noAssert)
+ else
+ this.writeUInt8(0xff + value + 1, offset, noAssert)
+}
+
+function _writeInt16 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7fff, -0x8000)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ if (value >= 0)
+ _writeUInt16(buf, value, offset, littleEndian, noAssert)
+ else
+ _writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert)
+}
+
+Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
+ _writeInt16(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
+ _writeInt16(this, value, offset, false, noAssert)
+}
+
+function _writeInt32 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7fffffff, -0x80000000)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ if (value >= 0)
+ _writeUInt32(buf, value, offset, littleEndian, noAssert)
+ else
+ _writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert)
+}
+
+Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
+ _writeInt32(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
+ _writeInt32(this, value, offset, false, noAssert)
+}
+
+function _writeFloat (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
+ verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+}
+
+Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
+ _writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
+ _writeFloat(this, value, offset, false, noAssert)
+}
+
+function _writeDouble (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 7 < buf.length,
+ 'Trying to write beyond buffer length')
+ verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+}
+
+Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
+ _writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
+ _writeDouble(this, value, offset, false, noAssert)
+}
+
+Buffer.prototype.fill = function (value, start, end) {
+ if (!value) value = 0
+ if (!start) start = 0
+ if (!end) end = this.length
+
+ if (typeof value === 'string') {
+ value = value.charCodeAt(0)
+ }
+
+ assert(typeof value === 'number' && !isNaN(value), 'value is not a number')
+ assert(end >= start, 'end < start')
+
+ if (end === start) return
+ if (this.length === 0) return
+
+ assert(start >= 0 && start < this.length, 'start out of bounds')
+ assert(end >= 0 && end <= this.length, 'end out of bounds')
+
+ for (var i = start; i < end; i++) {
+ this[i] = value
+ }
+}
+
+Buffer.prototype.inspect = function () {
+ var out = []
+ var len = this.length
+ for (var i = 0; i < len; i++) {
+ out[i] = toHex(this[i])
+ if (i === exports.INSPECT_MAX_BYTES) {
+ out[i + 1] = '...'
+ break
+ }
+ }
+ return ''
+}
+
+
+Buffer.prototype.toArrayBuffer = function () {
+ if (typeof Uint8Array !== 'undefined') {
+ if (Buffer._useTypedArrays) {
+ return (new Buffer(this)).buffer
+ } else {
+ var buf = new Uint8Array(this.length)
+ for (var i = 0, len = buf.length; i < len; i += 1)
+ buf[i] = this[i]
+ return buf.buffer
+ }
+ } else {
+ throw new Error('Buffer.toArrayBuffer not supported in this browser')
+ }
+}
+
+
+function stringtrim (str) {
+ if (str.trim) return str.trim()
+ return str.replace(/^\s+|\s+$/g, '')
+}
+
+var BP = Buffer.prototype
+
+
+Buffer._augment = function (arr) {
+ arr._isBuffer = true
+
+ arr._get = arr.get
+ arr._set = arr.set
+
+ arr.get = BP.get
+ arr.set = BP.set
+
+ arr.write = BP.write
+ arr.toString = BP.toString
+ arr.toLocaleString = BP.toString
+ arr.toJSON = BP.toJSON
+ arr.copy = BP.copy
+ arr.slice = BP.slice
+ arr.readUInt8 = BP.readUInt8
+ arr.readUInt16LE = BP.readUInt16LE
+ arr.readUInt16BE = BP.readUInt16BE
+ arr.readUInt32LE = BP.readUInt32LE
+ arr.readUInt32BE = BP.readUInt32BE
+ arr.readInt8 = BP.readInt8
+ arr.readInt16LE = BP.readInt16LE
+ arr.readInt16BE = BP.readInt16BE
+ arr.readInt32LE = BP.readInt32LE
+ arr.readInt32BE = BP.readInt32BE
+ arr.readFloatLE = BP.readFloatLE
+ arr.readFloatBE = BP.readFloatBE
+ arr.readDoubleLE = BP.readDoubleLE
+ arr.readDoubleBE = BP.readDoubleBE
+ arr.writeUInt8 = BP.writeUInt8
+ arr.writeUInt16LE = BP.writeUInt16LE
+ arr.writeUInt16BE = BP.writeUInt16BE
+ arr.writeUInt32LE = BP.writeUInt32LE
+ arr.writeUInt32BE = BP.writeUInt32BE
+ arr.writeInt8 = BP.writeInt8
+ arr.writeInt16LE = BP.writeInt16LE
+ arr.writeInt16BE = BP.writeInt16BE
+ arr.writeInt32LE = BP.writeInt32LE
+ arr.writeInt32BE = BP.writeInt32BE
+ arr.writeFloatLE = BP.writeFloatLE
+ arr.writeFloatBE = BP.writeFloatBE
+ arr.writeDoubleLE = BP.writeDoubleLE
+ arr.writeDoubleBE = BP.writeDoubleBE
+ arr.fill = BP.fill
+ arr.inspect = BP.inspect
+ arr.toArrayBuffer = BP.toArrayBuffer
+
+ return arr
+}
+
+function clamp (index, len, defaultValue) {
+ if (typeof index !== 'number') return defaultValue
+ index = ~~index; // Coerce to integer.
+ if (index >= len) return len
+ if (index >= 0) return index
+ index += len
+ if (index >= 0) return index
+ return 0
+}
+
+function coerce (length) {
+ length = ~~Math.ceil(+length)
+ return length < 0 ? 0 : length
+}
+
+function isArray (subject) {
+ return (Array.isArray || function (subject) {
+ return Object.prototype.toString.call(subject) === '[object Array]'
+ })(subject)
+}
+
+function isArrayish (subject) {
+ return isArray(subject) || Buffer.isBuffer(subject) ||
+ subject && typeof subject === 'object' &&
+ typeof subject.length === 'number'
+}
+
+function toHex (n) {
+ if (n < 16) return '0' + n.toString(16)
+ return n.toString(16)
+}
+
+function utf8ToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; i++) {
+ var b = str.charCodeAt(i)
+ if (b <= 0x7F)
+ byteArray.push(str.charCodeAt(i))
+ else {
+ var start = i
+ if (b >= 0xD800 && b <= 0xDFFF) i++
+ var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')
+ for (var j = 0; j < h.length; j++)
+ byteArray.push(parseInt(h[j], 16))
+ }
+ }
+ return byteArray
+}
+
+function asciiToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; i++) {
+ byteArray.push(str.charCodeAt(i) & 0xFF)
+ }
+ return byteArray
+}
+
+function utf16leToBytes (str) {
+ var c, hi, lo
+ var byteArray = []
+ for (var i = 0; i < str.length; i++) {
+ c = str.charCodeAt(i)
+ hi = c >> 8
+ lo = c % 256
+ byteArray.push(lo)
+ byteArray.push(hi)
+ }
+
+ return byteArray
+}
+
+function base64ToBytes (str) {
+ return base64.toByteArray(str)
+}
+
+function blitBuffer (src, dst, offset, length) {
+ var pos
+ for (var i = 0; i < length; i++) {
+ if ((i + offset >= dst.length) || (i >= src.length))
+ break
+ dst[i + offset] = src[i]
+ }
+ return i
+}
+
+function decodeUtf8Char (str) {
+ try {
+ return decodeURIComponent(str)
+ } catch (err) {
+ return String.fromCharCode(0xFFFD) // UTF 8 invalid char
+ }
+}
+
+
+function verifuint (value, max) {
+ assert(typeof value === 'number', 'cannot write a non-number as a number')
+ assert(value >= 0, 'specified a negative value for writing an unsigned value')
+ assert(value <= max, 'value is larger than maximum value for type')
+ assert(Math.floor(value) === value, 'value has a fractional component')
+}
+
+function verifsint (value, max, min) {
+ assert(typeof value === 'number', 'cannot write a non-number as a number')
+ assert(value <= max, 'value larger than maximum allowed value')
+ assert(value >= min, 'value smaller than minimum allowed value')
+ assert(Math.floor(value) === value, 'value has a fractional component')
+}
+
+function verifIEEE754 (value, max, min) {
+ assert(typeof value === 'number', 'cannot write a non-number as a number')
+ assert(value <= max, 'value larger than maximum allowed value')
+ assert(value >= min, 'value smaller than minimum allowed value')
+}
+
+function assert (test, message) {
+ if (!test) throw new Error(message || 'Failed assertion')
+}
+
+},{"base64-js":55,"ieee754":56}],55:[function(require,module,exports){
+var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+;(function (exports) {
+ 'use strict';
+
+ var Arr = (typeof Uint8Array !== 'undefined')
+ ? Uint8Array
+ : Array
+
+ var PLUS = '+'.charCodeAt(0)
+ var SLASH = '/'.charCodeAt(0)
+ var NUMBER = '0'.charCodeAt(0)
+ var LOWER = 'a'.charCodeAt(0)
+ var UPPER = 'A'.charCodeAt(0)
+ var PLUS_URL_SAFE = '-'.charCodeAt(0)
+ var SLASH_URL_SAFE = '_'.charCodeAt(0)
+
+ function decode (elt) {
+ var code = elt.charCodeAt(0)
+ if (code === PLUS ||
+ code === PLUS_URL_SAFE)
+ return 62 // '+'
+ if (code === SLASH ||
+ code === SLASH_URL_SAFE)
+ return 63 // '/'
+ if (code < NUMBER)
+ return -1 //no match
+ if (code < NUMBER + 10)
+ return code - NUMBER + 26 + 26
+ if (code < UPPER + 26)
+ return code - UPPER
+ if (code < LOWER + 26)
+ return code - LOWER + 26
+ }
+
+ function b64ToByteArray (b64) {
+ var i, j, l, tmp, placeHolders, arr
+
+ if (b64.length % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4')
+ }
+
+ var len = b64.length
+ placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
+
+ arr = new Arr(b64.length * 3 / 4 - placeHolders)
+
+ l = placeHolders > 0 ? b64.length - 4 : b64.length
+
+ var L = 0
+
+ function push (v) {
+ arr[L++] = v
+ }
+
+ for (i = 0, j = 0; i < l; i += 4, j += 3) {
+ tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
+ push((tmp & 0xFF0000) >> 16)
+ push((tmp & 0xFF00) >> 8)
+ push(tmp & 0xFF)
+ }
+
+ if (placeHolders === 2) {
+ tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
+ push(tmp & 0xFF)
+ } else if (placeHolders === 1) {
+ tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
+ push((tmp >> 8) & 0xFF)
+ push(tmp & 0xFF)
+ }
+
+ return arr
+ }
+
+ function uint8ToBase64 (uint8) {
+ var i,
+ extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
+ output = "",
+ temp, length
+
+ function encode (num) {
+ return lookup.charAt(num)
+ }
+
+ function tripletToBase64 (num) {
+ return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
+ }
+
+ for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
+ temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
+ output += tripletToBase64(temp)
+ }
+
+ switch (extraBytes) {
+ case 1:
+ temp = uint8[uint8.length - 1]
+ output += encode(temp >> 2)
+ output += encode((temp << 4) & 0x3F)
+ output += '=='
+ break
+ case 2:
+ temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
+ output += encode(temp >> 10)
+ output += encode((temp >> 4) & 0x3F)
+ output += encode((temp << 2) & 0x3F)
+ output += '='
+ break
+ }
+
+ return output
+ }
+
+ exports.toByteArray = b64ToByteArray
+ exports.fromByteArray = uint8ToBase64
+}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
+
+},{}],56:[function(require,module,exports){
+exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+ var e, m
+ var eLen = nBytes * 8 - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var nBits = -7
+ var i = isLE ? (nBytes - 1) : 0
+ var d = isLE ? -1 : 1
+ var s = buffer[offset + i]
+
+ i += d
+
+ e = s & ((1 << (-nBits)) - 1)
+ s >>= (-nBits)
+ nBits += eLen
+ for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+
+ m = e & ((1 << (-nBits)) - 1)
+ e >>= (-nBits)
+ nBits += mLen
+ for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
+
+ if (e === 0) {
+ e = 1 - eBias
+ } else if (e === eMax) {
+ return m ? NaN : ((s ? -1 : 1) * Infinity)
+ } else {
+ m = m + Math.pow(2, mLen)
+ e = e - eBias
+ }
+ return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+}
+
+exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+ var e, m, c
+ var eLen = nBytes * 8 - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+ var i = isLE ? 0 : (nBytes - 1)
+ var d = isLE ? 1 : -1
+ var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+
+ value = Math.abs(value)
+
+ if (isNaN(value) || value === Infinity) {
+ m = isNaN(value) ? 1 : 0
+ e = eMax
+ } else {
+ e = Math.floor(Math.log(value) / Math.LN2)
+ if (value * (c = Math.pow(2, -e)) < 1) {
+ e--
+ c *= 2
+ }
+ if (e + eBias >= 1) {
+ value += rt / c
+ } else {
+ value += rt * Math.pow(2, 1 - eBias)
+ }
+ if (value * c >= 2) {
+ e++
+ c /= 2
+ }
+
+ if (e + eBias >= eMax) {
+ m = 0
+ e = eMax
+ } else if (e + eBias >= 1) {
+ m = (value * c - 1) * Math.pow(2, mLen)
+ e = e + eBias
+ } else {
+ m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+ e = 0
+ }
+ }
+
+ for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
+
+ e = (e << mLen) | m
+ eLen += mLen
+ for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
+
+ buffer[offset + i - d] |= s * 128
+}
+
+},{}],57:[function(require,module,exports){
+var Buffer = require('buffer').Buffer;
+var intSize = 4;
+var zeroBuffer = new Buffer(intSize); zeroBuffer.fill(0);
+var chrsz = 8;
+
+function toArray(buf, bigEndian) {
+ if ((buf.length % intSize) !== 0) {
+ var len = buf.length + (intSize - (buf.length % intSize));
+ buf = Buffer.concat([buf, zeroBuffer], len);
+ }
+
+ var arr = [];
+ var fn = bigEndian ? buf.readInt32BE : buf.readInt32LE;
+ for (var i = 0; i < buf.length; i += intSize) {
+ arr.push(fn.call(buf, i));
+ }
+ return arr;
+}
+
+function toBuffer(arr, size, bigEndian) {
+ var buf = new Buffer(size);
+ var fn = bigEndian ? buf.writeInt32BE : buf.writeInt32LE;
+ for (var i = 0; i < arr.length; i++) {
+ fn.call(buf, arr[i], i * 4, true);
+ }
+ return buf;
+}
+
+function hash(buf, fn, hashSize, bigEndian) {
+ if (!Buffer.isBuffer(buf)) buf = new Buffer(buf);
+ var arr = fn(toArray(buf, bigEndian), buf.length * chrsz);
+ return toBuffer(arr, hashSize, bigEndian);
+}
+
+module.exports = { hash: hash };
+
+},{"buffer":54}],58:[function(require,module,exports){
+var Buffer = require('buffer').Buffer
+var sha = require('./sha')
+var sha256 = require('./sha256')
+var rng = require('./rng')
+var md5 = require('./md5')
+
+var algorithms = {
+ sha1: sha,
+ sha256: sha256,
+ md5: md5
+}
+
+var blocksize = 64
+var zeroBuffer = new Buffer(blocksize); zeroBuffer.fill(0)
+function hmac(fn, key, data) {
+ if(!Buffer.isBuffer(key)) key = new Buffer(key)
+ if(!Buffer.isBuffer(data)) data = new Buffer(data)
+
+ if(key.length > blocksize) {
+ key = fn(key)
+ } else if(key.length < blocksize) {
+ key = Buffer.concat([key, zeroBuffer], blocksize)
+ }
+
+ var ipad = new Buffer(blocksize), opad = new Buffer(blocksize)
+ for(var i = 0; i < blocksize; i++) {
+ ipad[i] = key[i] ^ 0x36
+ opad[i] = key[i] ^ 0x5C
+ }
+
+ var hash = fn(Buffer.concat([ipad, data]))
+ return fn(Buffer.concat([opad, hash]))
+}
+
+function hash(alg, key) {
+ alg = alg || 'sha1'
+ var fn = algorithms[alg]
+ var bufs = []
+ var length = 0
+ if(!fn) error('algorithm:', alg, 'is not yet supported')
+ return {
+ update: function (data) {
+ if(!Buffer.isBuffer(data)) data = new Buffer(data)
+
+ bufs.push(data)
+ length += data.length
+ return this
+ },
+ digest: function (enc) {
+ var buf = Buffer.concat(bufs)
+ var r = key ? hmac(fn, key, buf) : fn(buf)
+ bufs = null
+ return enc ? r.toString(enc) : r
+ }
+ }
+}
+
+function error () {
+ var m = [].slice.call(arguments).join(' ')
+ throw new Error([
+ m,
+ 'we accept pull requests',
+ 'http://github.com/dominictarr/crypto-browserify'
+ ].join('\n'))
+}
+
+exports.createHash = function (alg) { return hash(alg) }
+exports.createHmac = function (alg, key) { return hash(alg, key) }
+exports.randomBytes = function(size, callback) {
+ if (callback && callback.call) {
+ try {
+ callback.call(this, undefined, new Buffer(rng(size)))
+ } catch (err) { callback(err) }
+ } else {
+ return new Buffer(rng(size))
+ }
+}
+
+function each(a, f) {
+ for(var i in a)
+ f(a[i], i)
+}
+
+each(['createCredentials'
+, 'createCipher'
+, 'createCipheriv'
+, 'createDecipher'
+, 'createDecipheriv'
+, 'createSign'
+, 'createVerify'
+, 'createDiffieHellman'
+, 'pbkdf2'], function (name) {
+ exports[name] = function () {
+ error('sorry,', name, 'is not implemented yet')
+ }
+})
+
+},{"./md5":59,"./rng":60,"./sha":61,"./sha256":62,"buffer":54}],59:[function(require,module,exports){
+
+
+var helpers = require('./helpers');
+
+
+function md5_vm_test()
+{
+ return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
+}
+
+
+function core_md5(x, len)
+{
+
+ x[len >> 5] |= 0x80 << ((len) % 32);
+ x[(((len + 64) >>> 9) << 4) + 14] = 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 = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
+ d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
+ c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
+ b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
+ a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
+ d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
+ c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
+ b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
+ a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
+ d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
+ c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
+ b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
+ a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
+ d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
+ c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
+ b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);
+
+ a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
+ d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
+ c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
+ b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
+ a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
+ d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
+ c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
+ b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
+ a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
+ d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
+ c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
+ b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
+ a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
+ d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
+ c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
+ b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
+
+ a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
+ d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
+ c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
+ b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
+ a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
+ d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
+ c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
+ b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
+ a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
+ d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
+ c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
+ b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
+ a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
+ d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
+ c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
+ b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
+
+ a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
+ d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
+ c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
+ b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
+ a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
+ d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
+ c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
+ b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
+ a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
+ d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
+ c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
+ b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
+ a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
+ d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
+ c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
+ b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
+
+ a = safe_add(a, olda);
+ b = safe_add(b, oldb);
+ c = safe_add(c, oldc);
+ d = safe_add(d, oldd);
+ }
+ return Array(a, b, c, d);
+
+}
+
+
+function md5_cmn(q, a, b, x, s, t)
+{
+ return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
+}
+function md5_ff(a, b, c, d, x, s, t)
+{
+ return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
+}
+function md5_gg(a, b, c, d, x, s, t)
+{
+ return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
+}
+function md5_hh(a, b, c, d, x, s, t)
+{
+ return md5_cmn(b ^ c ^ d, a, b, x, s, t);
+}
+function md5_ii(a, b, c, d, x, s, t)
+{
+ return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
+}
+
+
+function safe_add(x, y)
+{
+ var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+ var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+ return (msw << 16) | (lsw & 0xFFFF);
+}
+
+
+function bit_rol(num, cnt)
+{
+ return (num << cnt) | (num >>> (32 - cnt));
+}
+
+module.exports = function md5(buf) {
+ return helpers.hash(buf, core_md5, 16);
+};
+
+},{"./helpers":57}],60:[function(require,module,exports){
+(function() {
+ var _global = this;
+
+ var mathRNG, whatwgRNG;
+
+ mathRNG = function(size) {
+ var bytes = new Array(size);
+ var r;
+
+ for (var i = 0, r; i < size; i++) {
+ if ((i & 0x03) == 0) r = Math.random() * 0x100000000;
+ bytes[i] = r >>> ((i & 0x03) << 3) & 0xff;
+ }
+
+ return bytes;
+ }
+
+ if (_global.crypto && crypto.getRandomValues) {
+ whatwgRNG = function(size) {
+ var bytes = new Uint8Array(size);
+ crypto.getRandomValues(bytes);
+ return bytes;
+ }
+ }
+
+ module.exports = whatwgRNG || mathRNG;
+
+}())
+
+},{}],61:[function(require,module,exports){
+
+
+var helpers = require('./helpers');
+
+
+function core_sha1(x, len)
+{
+
+ x[len >> 5] |= 0x80 << (24 - len % 32);
+ x[((len + 64 >> 9) << 4) + 15] = len;
+
+ var w = Array(80);
+ var a = 1732584193;
+ var b = -271733879;
+ var c = -1732584194;
+ var d = 271733878;
+ var e = -1009589776;
+
+ for(var i = 0; i < x.length; i += 16)
+ {
+ var olda = a;
+ var oldb = b;
+ var oldc = c;
+ var oldd = d;
+ var olde = e;
+
+ for(var j = 0; j < 80; j++)
+ {
+ if(j < 16) w[j] = x[i + j];
+ else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
+ var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
+ safe_add(safe_add(e, w[j]), sha1_kt(j)));
+ e = d;
+ d = c;
+ c = rol(b, 30);
+ b = a;
+ a = t;
+ }
+
+ a = safe_add(a, olda);
+ b = safe_add(b, oldb);
+ c = safe_add(c, oldc);
+ d = safe_add(d, oldd);
+ e = safe_add(e, olde);
+ }
+ return Array(a, b, c, d, e);
+
+}
+
+
+function sha1_ft(t, b, c, d)
+{
+ if(t < 20) return (b & c) | ((~b) & d);
+ if(t < 40) return b ^ c ^ d;
+ if(t < 60) return (b & c) | (b & d) | (c & d);
+ return b ^ c ^ d;
+}
+
+
+function sha1_kt(t)
+{
+ return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 :
+ (t < 60) ? -1894007588 : -899497514;
+}
+
+
+function safe_add(x, y)
+{
+ var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+ var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+ return (msw << 16) | (lsw & 0xFFFF);
+}
+
+
+function rol(num, cnt)
+{
+ return (num << cnt) | (num >>> (32 - cnt));
+}
+
+module.exports = function sha1(buf) {
+ return helpers.hash(buf, core_sha1, 20, true);
+};
+
+},{"./helpers":57}],62:[function(require,module,exports){
+
+
+
+var helpers = require('./helpers');
+
+var safe_add = function(x, y) {
+ var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+ var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+ return (msw << 16) | (lsw & 0xFFFF);
+};
+
+var S = function(X, n) {
+ return (X >>> n) | (X << (32 - n));
+};
+
+var R = function(X, n) {
+ return (X >>> n);
+};
+
+var Ch = function(x, y, z) {
+ return ((x & y) ^ ((~x) & z));
+};
+
+var Maj = function(x, y, z) {
+ return ((x & y) ^ (x & z) ^ (y & z));
+};
+
+var Sigma0256 = function(x) {
+ return (S(x, 2) ^ S(x, 13) ^ S(x, 22));
+};
+
+var Sigma1256 = function(x) {
+ return (S(x, 6) ^ S(x, 11) ^ S(x, 25));
+};
+
+var Gamma0256 = function(x) {
+ return (S(x, 7) ^ S(x, 18) ^ R(x, 3));
+};
+
+var Gamma1256 = function(x) {
+ return (S(x, 17) ^ S(x, 19) ^ R(x, 10));
+};
+
+var core_sha256 = function(m, l) {
+ var K = new Array(0x428A2F98,0x71374491,0xB5C0FBCF,0xE9B5DBA5,0x3956C25B,0x59F111F1,0x923F82A4,0xAB1C5ED5,0xD807AA98,0x12835B01,0x243185BE,0x550C7DC3,0x72BE5D74,0x80DEB1FE,0x9BDC06A7,0xC19BF174,0xE49B69C1,0xEFBE4786,0xFC19DC6,0x240CA1CC,0x2DE92C6F,0x4A7484AA,0x5CB0A9DC,0x76F988DA,0x983E5152,0xA831C66D,0xB00327C8,0xBF597FC7,0xC6E00BF3,0xD5A79147,0x6CA6351,0x14292967,0x27B70A85,0x2E1B2138,0x4D2C6DFC,0x53380D13,0x650A7354,0x766A0ABB,0x81C2C92E,0x92722C85,0xA2BFE8A1,0xA81A664B,0xC24B8B70,0xC76C51A3,0xD192E819,0xD6990624,0xF40E3585,0x106AA070,0x19A4C116,0x1E376C08,0x2748774C,0x34B0BCB5,0x391C0CB3,0x4ED8AA4A,0x5B9CCA4F,0x682E6FF3,0x748F82EE,0x78A5636F,0x84C87814,0x8CC70208,0x90BEFFFA,0xA4506CEB,0xBEF9A3F7,0xC67178F2);
+ var HASH = new Array(0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19);
+ var W = new Array(64);
+ var a, b, c, d, e, f, g, h, i, j;
+ var T1, T2;
+
+ m[l >> 5] |= 0x80 << (24 - l % 32);
+ m[((l + 64 >> 9) << 4) + 15] = l;
+ for (var i = 0; i < m.length; i += 16) {
+ a = HASH[0]; b = HASH[1]; c = HASH[2]; d = HASH[3]; e = HASH[4]; f = HASH[5]; g = HASH[6]; h = HASH[7];
+ for (var j = 0; j < 64; j++) {
+ if (j < 16) {
+ W[j] = m[j + i];
+ } else {
+ W[j] = safe_add(safe_add(safe_add(Gamma1256(W[j - 2]), W[j - 7]), Gamma0256(W[j - 15])), W[j - 16]);
+ }
+ T1 = safe_add(safe_add(safe_add(safe_add(h, Sigma1256(e)), Ch(e, f, g)), K[j]), W[j]);
+ T2 = safe_add(Sigma0256(a), Maj(a, b, c));
+ h = g; g = f; f = e; e = safe_add(d, T1); d = c; c = b; b = a; a = safe_add(T1, T2);
+ }
+ HASH[0] = safe_add(a, HASH[0]); HASH[1] = safe_add(b, HASH[1]); HASH[2] = safe_add(c, HASH[2]); HASH[3] = safe_add(d, HASH[3]);
+ HASH[4] = safe_add(e, HASH[4]); HASH[5] = safe_add(f, HASH[5]); HASH[6] = safe_add(g, HASH[6]); HASH[7] = safe_add(h, HASH[7]);
+ }
+ return HASH;
+};
+
+module.exports = function sha256(buf) {
+ return helpers.hash(buf, core_sha256, 32, true);
+};
+
+},{"./helpers":57}],63:[function(require,module,exports){
+
+function EventEmitter() {
+ this._events = this._events || {};
+ this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+EventEmitter.defaultMaxListeners = 10;
+
+EventEmitter.prototype.setMaxListeners = function(n) {
+ if (!isNumber(n) || n < 0 || isNaN(n))
+ throw TypeError('n must be a positive number');
+ this._maxListeners = n;
+ return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+ var er, handler, len, args, i, listeners;
+
+ if (!this._events)
+ this._events = {};
+
+ if (type === 'error') {
+ if (!this._events.error ||
+ (isObject(this._events.error) && !this._events.error.length)) {
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
+ }
+ throw TypeError('Uncaught, unspecified "error" event.');
+ }
+ }
+
+ handler = this._events[type];
+
+ if (isUndefined(handler))
+ return false;
+
+ if (isFunction(handler)) {
+ switch (arguments.length) {
+ case 1:
+ handler.call(this);
+ break;
+ case 2:
+ handler.call(this, arguments[1]);
+ break;
+ case 3:
+ handler.call(this, arguments[1], arguments[2]);
+ break;
+ default:
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+ handler.apply(this, args);
+ }
+ } else if (isObject(handler)) {
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+
+ listeners = handler.slice();
+ len = listeners.length;
+ for (i = 0; i < len; i++)
+ listeners[i].apply(this, args);
+ }
+
+ return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+ var m;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events)
+ this._events = {};
+
+ if (this._events.newListener)
+ this.emit('newListener', type,
+ isFunction(listener.listener) ?
+ listener.listener : listener);
+
+ if (!this._events[type])
+ this._events[type] = listener;
+ else if (isObject(this._events[type]))
+ this._events[type].push(listener);
+ else
+ this._events[type] = [this._events[type], listener];
+
+ if (isObject(this._events[type]) && !this._events[type].warned) {
+ var m;
+ if (!isUndefined(this._maxListeners)) {
+ m = this._maxListeners;
+ } else {
+ m = EventEmitter.defaultMaxListeners;
+ }
+
+ if (m && m > 0 && this._events[type].length > m) {
+ this._events[type].warned = true;
+ console.error('(node) warning: possible EventEmitter memory ' +
+ 'leak detected. %d listeners added. ' +
+ 'Use emitter.setMaxListeners() to increase limit.',
+ this._events[type].length);
+ if (typeof console.trace === 'function') {
+ console.trace();
+ }
+ }
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ var fired = false;
+
+ function g() {
+ this.removeListener(type, g);
+
+ if (!fired) {
+ fired = true;
+ listener.apply(this, arguments);
+ }
+ }
+
+ g.listener = listener;
+ this.on(type, g);
+
+ return this;
+};
+
+EventEmitter.prototype.removeListener = function(type, listener) {
+ var list, position, length, i;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events || !this._events[type])
+ return this;
+
+ list = this._events[type];
+ length = list.length;
+ position = -1;
+
+ if (list === listener ||
+ (isFunction(list.listener) && list.listener === listener)) {
+ delete this._events[type];
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+
+ } else if (isObject(list)) {
+ for (i = length; i-- > 0;) {
+ if (list[i] === listener ||
+ (list[i].listener && list[i].listener === listener)) {
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (list.length === 1) {
+ list.length = 0;
+ delete this._events[type];
+ } else {
+ list.splice(position, 1);
+ }
+
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+ var key, listeners;
+
+ if (!this._events)
+ return this;
+
+ if (!this._events.removeListener) {
+ if (arguments.length === 0)
+ this._events = {};
+ else if (this._events[type])
+ delete this._events[type];
+ return this;
+ }
+
+ if (arguments.length === 0) {
+ for (key in this._events) {
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = {};
+ return this;
+ }
+
+ listeners = this._events[type];
+
+ if (isFunction(listeners)) {
+ this.removeListener(type, listeners);
+ } else {
+ while (listeners.length)
+ this.removeListener(type, listeners[listeners.length - 1]);
+ }
+ delete this._events[type];
+
+ return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+ var ret;
+ if (!this._events || !this._events[type])
+ ret = [];
+ else if (isFunction(this._events[type]))
+ ret = [this._events[type]];
+ else
+ ret = this._events[type].slice();
+ return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ var ret;
+ if (!emitter._events || !emitter._events[type])
+ ret = 0;
+ else if (isFunction(emitter._events[type]))
+ ret = 1;
+ else
+ ret = emitter._events[type].length;
+ return ret;
+};
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+
+},{}],64:[function(require,module,exports){
+if (typeof Object.create === 'function') {
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ };
+} else {
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+}
+
+},{}],65:[function(require,module,exports){
+
+var process = module.exports = {};
+
+process.nextTick = (function () {
+ var canSetImmediate = typeof window !== 'undefined'
+ && window.setImmediate;
+ var canPost = typeof window !== 'undefined'
+ && window.postMessage && window.addEventListener
+ ;
+
+ if (canSetImmediate) {
+ return function (f) { return window.setImmediate(f) };
+ }
+
+ if (canPost) {
+ var queue = [];
+ window.addEventListener('message', function (ev) {
+ var source = ev.source;
+ if ((source === window || source === null) && ev.data === 'process-tick') {
+ ev.stopPropagation();
+ if (queue.length > 0) {
+ var fn = queue.shift();
+ fn();
+ }
+ }
+ }, true);
+
+ return function nextTick(fn) {
+ queue.push(fn);
+ window.postMessage('process-tick', '*');
+ };
+ }
+
+ return function nextTick(fn) {
+ setTimeout(fn, 0);
+ };
+})();
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+
+process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+}
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+};
+
+},{}],66:[function(require,module,exports){
+(function (global){
+
+;(function(root) {
+
+
+ var freeExports = typeof exports == 'object' && exports;
+ var freeModule = typeof module == 'object' && module &&
+ module.exports == freeExports && module;
+ var freeGlobal = typeof global == 'object' && global;
+ if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
+ root = freeGlobal;
+ }
+
+
+ var punycode,
+
+
+ maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1
+
+
+ base = 36,
+ tMin = 1,
+ tMax = 26,
+ skew = 38,
+ damp = 700,
+ initialBias = 72,
+ initialN = 128, // 0x80
+ delimiter = '-', // '\x2D'
+
+
+ regexPunycode = /^xn--/,
+ regexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars
+ regexSeparators = /\x2E|\u3002|\uFF0E|\uFF61/g, // RFC 3490 separators
+
+
+ errors = {
+ 'overflow': 'Overflow: input needs wider integers to process',
+ 'not-basic': 'Illegal input >= 0x80 (not a basic code point)',
+ 'invalid-input': 'Invalid input'
+ },
+
+
+ baseMinusTMin = base - tMin,
+ floor = Math.floor,
+ stringFromCharCode = String.fromCharCode,
+
+
+ key;
+
+
+
+
+ function error(type) {
+ throw RangeError(errors[type]);
+ }
+
+
+ function map(array, fn) {
+ var length = array.length;
+ while (length--) {
+ array[length] = fn(array[length]);
+ }
+ return array;
+ }
+
+
+ function mapDomain(string, fn) {
+ return map(string.split(regexSeparators), fn).join('.');
+ }
+
+
+ function ucs2decode(string) {
+ var output = [],
+ counter = 0,
+ length = string.length,
+ value,
+ extra;
+ while (counter < length) {
+ value = string.charCodeAt(counter++);
+ if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
+ extra = string.charCodeAt(counter++);
+ if ((extra & 0xFC00) == 0xDC00) { // low surrogate
+ output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
+ } else {
+ output.push(value);
+ counter--;
+ }
+ } else {
+ output.push(value);
+ }
+ }
+ return output;
+ }
+
+
+ function ucs2encode(array) {
+ return map(array, function(value) {
+ var output = '';
+ if (value > 0xFFFF) {
+ value -= 0x10000;
+ output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);
+ value = 0xDC00 | value & 0x3FF;
+ }
+ output += stringFromCharCode(value);
+ return output;
+ }).join('');
+ }
+
+
+ function basicToDigit(codePoint) {
+ if (codePoint - 48 < 10) {
+ return codePoint - 22;
+ }
+ if (codePoint - 65 < 26) {
+ return codePoint - 65;
+ }
+ if (codePoint - 97 < 26) {
+ return codePoint - 97;
+ }
+ return base;
+ }
+
+
+ function digitToBasic(digit, flag) {
+ return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+ }
+
+
+ function adapt(delta, numPoints, firstTime) {
+ var k = 0;
+ delta = firstTime ? floor(delta / damp) : delta >> 1;
+ delta += floor(delta / numPoints);
+ for (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {
+ delta = floor(delta / baseMinusTMin);
+ }
+ return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+ }
+
+
+ function decode(input) {
+ var output = [],
+ inputLength = input.length,
+ out,
+ i = 0,
+ n = initialN,
+ bias = initialBias,
+ basic,
+ j,
+ index,
+ oldi,
+ w,
+ k,
+ digit,
+ t,
+
+ baseMinusT;
+
+
+ basic = input.lastIndexOf(delimiter);
+ if (basic < 0) {
+ basic = 0;
+ }
+
+ for (j = 0; j < basic; ++j) {
+ if (input.charCodeAt(j) >= 0x80) {
+ error('not-basic');
+ }
+ output.push(input.charCodeAt(j));
+ }
+
+
+ for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {
+
+ for (oldi = i, w = 1, k = base; /* no condition */; k += base) {
+
+ if (index >= inputLength) {
+ error('invalid-input');
+ }
+
+ digit = basicToDigit(input.charCodeAt(index++));
+
+ if (digit >= base || digit > floor((maxInt - i) / w)) {
+ error('overflow');
+ }
+
+ i += digit * w;
+ t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+
+ if (digit < t) {
+ break;
+ }
+
+ baseMinusT = base - t;
+ if (w > floor(maxInt / baseMinusT)) {
+ error('overflow');
+ }
+
+ w *= baseMinusT;
+
+ }
+
+ out = output.length + 1;
+ bias = adapt(i - oldi, out, oldi == 0);
+
+ if (floor(i / out) > maxInt - n) {
+ error('overflow');
+ }
+
+ n += floor(i / out);
+ i %= out;
+
+ output.splice(i++, 0, n);
+
+ }
+
+ return ucs2encode(output);
+ }
+
+
+ function encode(input) {
+ var n,
+ delta,
+ handledCPCount,
+ basicLength,
+ bias,
+ j,
+ m,
+ q,
+ k,
+ t,
+ currentValue,
+ output = [],
+
+ inputLength,
+
+ handledCPCountPlusOne,
+ baseMinusT,
+ qMinusT;
+
+ input = ucs2decode(input);
+
+ inputLength = input.length;
+
+ n = initialN;
+ delta = 0;
+ bias = initialBias;
+
+ for (j = 0; j < inputLength; ++j) {
+ currentValue = input[j];
+ if (currentValue < 0x80) {
+ output.push(stringFromCharCode(currentValue));
+ }
+ }
+
+ handledCPCount = basicLength = output.length;
+
+
+ if (basicLength) {
+ output.push(delimiter);
+ }
+
+ while (handledCPCount < inputLength) {
+
+ for (m = maxInt, j = 0; j < inputLength; ++j) {
+ currentValue = input[j];
+ if (currentValue >= n && currentValue < m) {
+ m = currentValue;
+ }
+ }
+
+ handledCPCountPlusOne = handledCPCount + 1;
+ if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+ error('overflow');
+ }
+
+ delta += (m - n) * handledCPCountPlusOne;
+ n = m;
+
+ for (j = 0; j < inputLength; ++j) {
+ currentValue = input[j];
+
+ if (currentValue < n && ++delta > maxInt) {
+ error('overflow');
+ }
+
+ if (currentValue == n) {
+ for (q = delta, k = base; /* no condition */; k += base) {
+ t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
+ if (q < t) {
+ break;
+ }
+ qMinusT = q - t;
+ baseMinusT = base - t;
+ output.push(
+ stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
+ );
+ q = floor(qMinusT / baseMinusT);
+ }
+
+ output.push(stringFromCharCode(digitToBasic(q, 0)));
+ bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+ delta = 0;
+ ++handledCPCount;
+ }
+ }
+
+ ++delta;
+ ++n;
+
+ }
+ return output.join('');
+ }
+
+
+ function toUnicode(domain) {
+ return mapDomain(domain, function(string) {
+ return regexPunycode.test(string)
+ ? decode(string.slice(4).toLowerCase())
+ : string;
+ });
+ }
+
+
+ function toASCII(domain) {
+ return mapDomain(domain, function(string) {
+ return regexNonASCII.test(string)
+ ? 'xn--' + encode(string)
+ : string;
+ });
+ }
+
+
+
+
+ punycode = {
+
+ 'version': '1.2.4',
+
+ 'ucs2': {
+ 'decode': ucs2decode,
+ 'encode': ucs2encode
+ },
+ 'decode': decode,
+ 'encode': encode,
+ 'toASCII': toASCII,
+ 'toUnicode': toUnicode
+ };
+
+
+ if (
+ typeof define == 'function' &&
+ typeof define.amd == 'object' &&
+ define.amd
+ ) {
+ define('punycode', function() {
+ return punycode;
+ });
+ } else if (freeExports && !freeExports.nodeType) {
+ if (freeModule) { // in Node.js or RingoJS v0.8.0+
+ freeModule.exports = punycode;
+ } else { // in Narwhal or RingoJS v0.7.0-
+ for (key in punycode) {
+ punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+ }
+ }
+ } else { // in Rhino or a web browser
+ root.punycode = punycode;
+ }
+
+}(this));
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],67:[function(require,module,exports){
+
+'use strict';
+
+function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+module.exports = function(qs, sep, eq, options) {
+ sep = sep || '&';
+ eq = eq || '=';
+ var obj = {};
+
+ if (typeof qs !== 'string' || qs.length === 0) {
+ return obj;
+ }
+
+ var regexp = /\+/g;
+ qs = qs.split(sep);
+
+ var maxKeys = 1000;
+ if (options && typeof options.maxKeys === 'number') {
+ maxKeys = options.maxKeys;
+ }
+
+ var len = qs.length;
+ if (maxKeys > 0 && len > maxKeys) {
+ len = maxKeys;
+ }
+
+ for (var i = 0; i < len; ++i) {
+ var x = qs[i].replace(regexp, '%20'),
+ idx = x.indexOf(eq),
+ kstr, vstr, k, v;
+
+ if (idx >= 0) {
+ kstr = x.substr(0, idx);
+ vstr = x.substr(idx + 1);
+ } else {
+ kstr = x;
+ vstr = '';
+ }
+
+ k = decodeURIComponent(kstr);
+ v = decodeURIComponent(vstr);
+
+ if (!hasOwnProperty(obj, k)) {
+ obj[k] = v;
+ } else if (isArray(obj[k])) {
+ obj[k].push(v);
+ } else {
+ obj[k] = [obj[k], v];
+ }
+ }
+
+ return obj;
+};
+
+var isArray = Array.isArray || function (xs) {
+ return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+},{}],68:[function(require,module,exports){
+
+'use strict';
+
+var stringifyPrimitive = function(v) {
+ switch (typeof v) {
+ case 'string':
+ return v;
+
+ case 'boolean':
+ return v ? 'true' : 'false';
+
+ case 'number':
+ return isFinite(v) ? v : '';
+
+ default:
+ return '';
+ }
+};
+
+module.exports = function(obj, sep, eq, name) {
+ sep = sep || '&';
+ eq = eq || '=';
+ if (obj === null) {
+ obj = undefined;
+ }
+
+ if (typeof obj === 'object') {
+ return map(objectKeys(obj), function(k) {
+ var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
+ if (isArray(obj[k])) {
+ return obj[k].map(function(v) {
+ return ks + encodeURIComponent(stringifyPrimitive(v));
+ }).join(sep);
+ } else {
+ return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
+ }
+ }).join(sep);
+
+ }
+
+ if (!name) return '';
+ return encodeURIComponent(stringifyPrimitive(name)) + eq +
+ encodeURIComponent(stringifyPrimitive(obj));
+};
+
+var isArray = Array.isArray || function (xs) {
+ return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+function map (xs, f) {
+ if (xs.map) return xs.map(f);
+ var res = [];
+ for (var i = 0; i < xs.length; i++) {
+ res.push(f(xs[i], i));
+ }
+ return res;
+}
+
+var objectKeys = Object.keys || function (obj) {
+ var res = [];
+ for (var key in obj) {
+ if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
+ }
+ return res;
+};
+
+},{}],69:[function(require,module,exports){
+'use strict';
+
+exports.decode = exports.parse = require('./decode');
+exports.encode = exports.stringify = require('./encode');
+
+},{"./decode":67,"./encode":68}],70:[function(require,module,exports){
+
+var punycode = require('punycode');
+
+exports.parse = urlParse;
+exports.resolve = urlResolve;
+exports.resolveObject = urlResolveObject;
+exports.format = urlFormat;
+
+exports.Url = Url;
+
+function Url() {
+ this.protocol = null;
+ this.slashes = null;
+ this.auth = null;
+ this.host = null;
+ this.port = null;
+ this.hostname = null;
+ this.hash = null;
+ this.search = null;
+ this.query = null;
+ this.pathname = null;
+ this.path = null;
+ this.href = null;
+}
+
+
+var protocolPattern = /^([a-z0-9.+-]+:)/i,
+ portPattern = /:[0-9]*$/,
+
+ delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t'],
+
+ unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims),
+
+ autoEscape = ['\''].concat(unwise),
+ nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),
+ hostEndingChars = ['/', '?', '#'],
+ hostnameMaxLen = 255,
+ hostnamePartPattern = /^[a-z0-9A-Z_-]{0,63}$/,
+ hostnamePartStart = /^([a-z0-9A-Z_-]{0,63})(.*)$/,
+ unsafeProtocol = {
+ 'javascript': true,
+ 'javascript:': true
+ },
+ hostlessProtocol = {
+ 'javascript': true,
+ 'javascript:': true
+ },
+ slashedProtocol = {
+ 'http': true,
+ 'https': true,
+ 'ftp': true,
+ 'gopher': true,
+ 'file': true,
+ 'http:': true,
+ 'https:': true,
+ 'ftp:': true,
+ 'gopher:': true,
+ 'file:': true
+ },
+ querystring = require('querystring');
+
+function urlParse(url, parseQueryString, slashesDenoteHost) {
+ if (url && isObject(url) && url instanceof Url) return url;
+
+ var u = new Url;
+ u.parse(url, parseQueryString, slashesDenoteHost);
+ return u;
+}
+
+Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
+ if (!isString(url)) {
+ throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
+ }
+
+ var rest = url;
+
+ rest = rest.trim();
+
+ var proto = protocolPattern.exec(rest);
+ if (proto) {
+ proto = proto[0];
+ var lowerProto = proto.toLowerCase();
+ this.protocol = lowerProto;
+ rest = rest.substr(proto.length);
+ }
+
+ if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+ var slashes = rest.substr(0, 2) === '//';
+ if (slashes && !(proto && hostlessProtocol[proto])) {
+ rest = rest.substr(2);
+ this.slashes = true;
+ }
+ }
+
+ if (!hostlessProtocol[proto] &&
+ (slashes || (proto && !slashedProtocol[proto]))) {
+
+
+
+ var hostEnd = -1;
+ for (var i = 0; i < hostEndingChars.length; i++) {
+ var hec = rest.indexOf(hostEndingChars[i]);
+ if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+ hostEnd = hec;
+ }
+
+ var auth, atSign;
+ if (hostEnd === -1) {
+ atSign = rest.lastIndexOf('@');
+ } else {
+ atSign = rest.lastIndexOf('@', hostEnd);
+ }
+
+ if (atSign !== -1) {
+ auth = rest.slice(0, atSign);
+ rest = rest.slice(atSign + 1);
+ this.auth = decodeURIComponent(auth);
+ }
+
+ hostEnd = -1;
+ for (var i = 0; i < nonHostChars.length; i++) {
+ var hec = rest.indexOf(nonHostChars[i]);
+ if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+ hostEnd = hec;
+ }
+ if (hostEnd === -1)
+ hostEnd = rest.length;
+
+ this.host = rest.slice(0, hostEnd);
+ rest = rest.slice(hostEnd);
+
+ this.parseHost();
+
+ this.hostname = this.hostname || '';
+
+ var ipv6Hostname = this.hostname[0] === '[' &&
+ this.hostname[this.hostname.length - 1] === ']';
+
+ if (!ipv6Hostname) {
+ var hostparts = this.hostname.split(/\./);
+ for (var i = 0, l = hostparts.length; i < l; i++) {
+ var part = hostparts[i];
+ if (!part) continue;
+ if (!part.match(hostnamePartPattern)) {
+ var newpart = '';
+ for (var j = 0, k = part.length; j < k; j++) {
+ if (part.charCodeAt(j) > 127) {
+ newpart += 'x';
+ } else {
+ newpart += part[j];
+ }
+ }
+ if (!newpart.match(hostnamePartPattern)) {
+ var validParts = hostparts.slice(0, i);
+ var notHost = hostparts.slice(i + 1);
+ var bit = part.match(hostnamePartStart);
+ if (bit) {
+ validParts.push(bit[1]);
+ notHost.unshift(bit[2]);
+ }
+ if (notHost.length) {
+ rest = '/' + notHost.join('.') + rest;
+ }
+ this.hostname = validParts.join('.');
+ break;
+ }
+ }
+ }
+ }
+
+ if (this.hostname.length > hostnameMaxLen) {
+ this.hostname = '';
+ } else {
+ this.hostname = this.hostname.toLowerCase();
+ }
+
+ if (!ipv6Hostname) {
+ var domainArray = this.hostname.split('.');
+ var newOut = [];
+ for (var i = 0; i < domainArray.length; ++i) {
+ var s = domainArray[i];
+ newOut.push(s.match(/[^A-Za-z0-9_-]/) ?
+ 'xn--' + punycode.encode(s) : s);
+ }
+ this.hostname = newOut.join('.');
+ }
+
+ var p = this.port ? ':' + this.port : '';
+ var h = this.hostname || '';
+ this.host = h + p;
+ this.href += this.host;
+
+ if (ipv6Hostname) {
+ this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+ if (rest[0] !== '/') {
+ rest = '/' + rest;
+ }
+ }
+ }
+
+ if (!unsafeProtocol[lowerProto]) {
+
+ for (var i = 0, l = autoEscape.length; i < l; i++) {
+ var ae = autoEscape[i];
+ var esc = encodeURIComponent(ae);
+ if (esc === ae) {
+ esc = escape(ae);
+ }
+ rest = rest.split(ae).join(esc);
+ }
+ }
+
+
+ var hash = rest.indexOf('#');
+ if (hash !== -1) {
+ this.hash = rest.substr(hash);
+ rest = rest.slice(0, hash);
+ }
+ var qm = rest.indexOf('?');
+ if (qm !== -1) {
+ this.search = rest.substr(qm);
+ this.query = rest.substr(qm + 1);
+ if (parseQueryString) {
+ this.query = querystring.parse(this.query);
+ }
+ rest = rest.slice(0, qm);
+ } else if (parseQueryString) {
+ this.search = '';
+ this.query = {};
+ }
+ if (rest) this.pathname = rest;
+ if (slashedProtocol[lowerProto] &&
+ this.hostname && !this.pathname) {
+ this.pathname = '/';
+ }
+
+ if (this.pathname || this.search) {
+ var p = this.pathname || '';
+ var s = this.search || '';
+ this.path = p + s;
+ }
+
+ this.href = this.format();
+ return this;
+};
+
+function urlFormat(obj) {
+ if (isString(obj)) obj = urlParse(obj);
+ if (!(obj instanceof Url)) return Url.prototype.format.call(obj);
+ return obj.format();
+}
+
+Url.prototype.format = function() {
+ var auth = this.auth || '';
+ if (auth) {
+ auth = encodeURIComponent(auth);
+ auth = auth.replace(/%3A/i, ':');
+ auth += '@';
+ }
+
+ var protocol = this.protocol || '',
+ pathname = this.pathname || '',
+ hash = this.hash || '',
+ host = false,
+ query = '';
+
+ if (this.host) {
+ host = auth + this.host;
+ } else if (this.hostname) {
+ host = auth + (this.hostname.indexOf(':') === -1 ?
+ this.hostname :
+ '[' + this.hostname + ']');
+ if (this.port) {
+ host += ':' + this.port;
+ }
+ }
+
+ if (this.query &&
+ isObject(this.query) &&
+ Object.keys(this.query).length) {
+ query = querystring.stringify(this.query);
+ }
+
+ var search = this.search || (query && ('?' + query)) || '';
+
+ if (protocol && protocol.substr(-1) !== ':') protocol += ':';
+
+ if (this.slashes ||
+ (!protocol || slashedProtocol[protocol]) && host !== false) {
+ host = '//' + (host || '');
+ if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;
+ } else if (!host) {
+ host = '';
+ }
+
+ if (hash && hash.charAt(0) !== '#') hash = '#' + hash;
+ if (search && search.charAt(0) !== '?') search = '?' + search;
+
+ pathname = pathname.replace(/[?#]/g, function(match) {
+ return encodeURIComponent(match);
+ });
+ search = search.replace('#', '%23');
+
+ return protocol + host + pathname + search + hash;
+};
+
+function urlResolve(source, relative) {
+ return urlParse(source, false, true).resolve(relative);
+}
+
+Url.prototype.resolve = function(relative) {
+ return this.resolveObject(urlParse(relative, false, true)).format();
+};
+
+function urlResolveObject(source, relative) {
+ if (!source) return relative;
+ return urlParse(source, false, true).resolveObject(relative);
+}
+
+Url.prototype.resolveObject = function(relative) {
+ if (isString(relative)) {
+ var rel = new Url();
+ rel.parse(relative, false, true);
+ relative = rel;
+ }
+
+ var result = new Url();
+ Object.keys(this).forEach(function(k) {
+ result[k] = this[k];
+ }, this);
+
+ result.hash = relative.hash;
+
+ if (relative.href === '') {
+ result.href = result.format();
+ return result;
+ }
+
+ if (relative.slashes && !relative.protocol) {
+ Object.keys(relative).forEach(function(k) {
+ if (k !== 'protocol')
+ result[k] = relative[k];
+ });
+
+ if (slashedProtocol[result.protocol] &&
+ result.hostname && !result.pathname) {
+ result.path = result.pathname = '/';
+ }
+
+ result.href = result.format();
+ return result;
+ }
+
+ if (relative.protocol && relative.protocol !== result.protocol) {
+ if (!slashedProtocol[relative.protocol]) {
+ Object.keys(relative).forEach(function(k) {
+ result[k] = relative[k];
+ });
+ result.href = result.format();
+ return result;
+ }
+
+ result.protocol = relative.protocol;
+ if (!relative.host && !hostlessProtocol[relative.protocol]) {
+ var relPath = (relative.pathname || '').split('/');
+ while (relPath.length && !(relative.host = relPath.shift()));
+ if (!relative.host) relative.host = '';
+ if (!relative.hostname) relative.hostname = '';
+ if (relPath[0] !== '') relPath.unshift('');
+ if (relPath.length < 2) relPath.unshift('');
+ result.pathname = relPath.join('/');
+ } else {
+ result.pathname = relative.pathname;
+ }
+ result.search = relative.search;
+ result.query = relative.query;
+ result.host = relative.host || '';
+ result.auth = relative.auth;
+ result.hostname = relative.hostname || relative.host;
+ result.port = relative.port;
+ if (result.pathname || result.search) {
+ var p = result.pathname || '';
+ var s = result.search || '';
+ result.path = p + s;
+ }
+ result.slashes = result.slashes || relative.slashes;
+ result.href = result.format();
+ return result;
+ }
+
+ var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),
+ isRelAbs = (
+ relative.host ||
+ relative.pathname && relative.pathname.charAt(0) === '/'
+ ),
+ mustEndAbs = (isRelAbs || isSourceAbs ||
+ (result.host && relative.pathname)),
+ removeAllDots = mustEndAbs,
+ srcPath = result.pathname && result.pathname.split('/') || [],
+ relPath = relative.pathname && relative.pathname.split('/') || [],
+ psychotic = result.protocol && !slashedProtocol[result.protocol];
+
+ if (psychotic) {
+ result.hostname = '';
+ result.port = null;
+ if (result.host) {
+ if (srcPath[0] === '') srcPath[0] = result.host;
+ else srcPath.unshift(result.host);
+ }
+ result.host = '';
+ if (relative.protocol) {
+ relative.hostname = null;
+ relative.port = null;
+ if (relative.host) {
+ if (relPath[0] === '') relPath[0] = relative.host;
+ else relPath.unshift(relative.host);
+ }
+ relative.host = null;
+ }
+ mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');
+ }
+
+ if (isRelAbs) {
+ result.host = (relative.host || relative.host === '') ?
+ relative.host : result.host;
+ result.hostname = (relative.hostname || relative.hostname === '') ?
+ relative.hostname : result.hostname;
+ result.search = relative.search;
+ result.query = relative.query;
+ srcPath = relPath;
+ } else if (relPath.length) {
+ if (!srcPath) srcPath = [];
+ srcPath.pop();
+ srcPath = srcPath.concat(relPath);
+ result.search = relative.search;
+ result.query = relative.query;
+ } else if (!isNullOrUndefined(relative.search)) {
+ if (psychotic) {
+ result.hostname = result.host = srcPath.shift();
+ var authInHost = result.host && result.host.indexOf('@') > 0 ?
+ result.host.split('@') : false;
+ if (authInHost) {
+ result.auth = authInHost.shift();
+ result.host = result.hostname = authInHost.shift();
+ }
+ }
+ result.search = relative.search;
+ result.query = relative.query;
+ if (!isNull(result.pathname) || !isNull(result.search)) {
+ result.path = (result.pathname ? result.pathname : '') +
+ (result.search ? result.search : '');
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ if (!srcPath.length) {
+ result.pathname = null;
+ if (result.search) {
+ result.path = '/' + result.search;
+ } else {
+ result.path = null;
+ }
+ result.href = result.format();
+ return result;
+ }
+
+ var last = srcPath.slice(-1)[0];
+ var hasTrailingSlash = (
+ (result.host || relative.host) && (last === '.' || last === '..') ||
+ last === '');
+
+ var up = 0;
+ for (var i = srcPath.length; i >= 0; i--) {
+ last = srcPath[i];
+ if (last == '.') {
+ srcPath.splice(i, 1);
+ } else if (last === '..') {
+ srcPath.splice(i, 1);
+ up++;
+ } else if (up) {
+ srcPath.splice(i, 1);
+ up--;
+ }
+ }
+
+ if (!mustEndAbs && !removeAllDots) {
+ for (; up--; up) {
+ srcPath.unshift('..');
+ }
+ }
+
+ if (mustEndAbs && srcPath[0] !== '' &&
+ (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {
+ srcPath.unshift('');
+ }
+
+ if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {
+ srcPath.push('');
+ }
+
+ var isAbsolute = srcPath[0] === '' ||
+ (srcPath[0] && srcPath[0].charAt(0) === '/');
+
+ if (psychotic) {
+ result.hostname = result.host = isAbsolute ? '' :
+ srcPath.length ? srcPath.shift() : '';
+ var authInHost = result.host && result.host.indexOf('@') > 0 ?
+ result.host.split('@') : false;
+ if (authInHost) {
+ result.auth = authInHost.shift();
+ result.host = result.hostname = authInHost.shift();
+ }
+ }
+
+ mustEndAbs = mustEndAbs || (result.host && srcPath.length);
+
+ if (mustEndAbs && !isAbsolute) {
+ srcPath.unshift('');
+ }
+
+ if (!srcPath.length) {
+ result.pathname = null;
+ result.path = null;
+ } else {
+ result.pathname = srcPath.join('/');
+ }
+
+ if (!isNull(result.pathname) || !isNull(result.search)) {
+ result.path = (result.pathname ? result.pathname : '') +
+ (result.search ? result.search : '');
+ }
+ result.auth = relative.auth || result.auth;
+ result.slashes = result.slashes || relative.slashes;
+ result.href = result.format();
+ return result;
+};
+
+Url.prototype.parseHost = function() {
+ var host = this.host;
+ var port = portPattern.exec(host);
+ if (port) {
+ port = port[0];
+ if (port !== ':') {
+ this.port = port.substr(1);
+ }
+ host = host.substr(0, host.length - port.length);
+ }
+ if (host) this.hostname = host;
+};
+
+function isString(arg) {
+ return typeof arg === "string";
+}
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+
+function isNull(arg) {
+ return arg === null;
+}
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+
+},{"punycode":66,"querystring":69}],71:[function(require,module,exports){
+module.exports = function isBuffer(arg) {
+ return arg && typeof arg === 'object'
+ && typeof arg.copy === 'function'
+ && typeof arg.fill === 'function'
+ && typeof arg.readUInt8 === 'function';
+}
+},{}],72:[function(require,module,exports){
+(function (process,global){
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+ if (!isString(f)) {
+ var objects = [];
+ for (var i = 0; i < arguments.length; i++) {
+ objects.push(inspect(arguments[i]));
+ }
+ return objects.join(' ');
+ }
+
+ var i = 1;
+ var args = arguments;
+ var len = args.length;
+ var str = String(f).replace(formatRegExp, function(x) {
+ if (x === '%') return '%';
+ if (i >= len) return x;
+ switch (x) {
+ case '%s': return String(args[i++]);
+ case '%d': return Number(args[i++]);
+ case '%j':
+ try {
+ return JSON.stringify(args[i++]);
+ } catch (_) {
+ return '[Circular]';
+ }
+ default:
+ return x;
+ }
+ });
+ for (var x = args[i]; i < len; x = args[++i]) {
+ if (isNull(x) || !isObject(x)) {
+ str += ' ' + x;
+ } else {
+ str += ' ' + inspect(x);
+ }
+ }
+ return str;
+};
+
+
+exports.deprecate = function(fn, msg) {
+ if (isUndefined(global.process)) {
+ return function() {
+ return exports.deprecate(fn, msg).apply(this, arguments);
+ };
+ }
+
+ if (process.noDeprecation === true) {
+ return fn;
+ }
+
+ var warned = false;
+ function deprecated() {
+ if (!warned) {
+ if (process.throwDeprecation) {
+ throw new Error(msg);
+ } else if (process.traceDeprecation) {
+ console.trace(msg);
+ } else {
+ console.error(msg);
+ }
+ warned = true;
+ }
+ return fn.apply(this, arguments);
+ }
+
+ return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+ if (isUndefined(debugEnviron))
+ debugEnviron = process.env.NODE_DEBUG || '';
+ set = set.toUpperCase();
+ if (!debugs[set]) {
+ if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+ var pid = process.pid;
+ debugs[set] = function() {
+ var msg = exports.format.apply(exports, arguments);
+ console.error('%s %d: %s', set, pid, msg);
+ };
+ } else {
+ debugs[set] = function() {};
+ }
+ }
+ return debugs[set];
+};
+
+
+
+
+function inspect(obj, opts) {
+ var ctx = {
+ seen: [],
+ stylize: stylizeNoColor
+ };
+ if (arguments.length >= 3) ctx.depth = arguments[2];
+ if (arguments.length >= 4) ctx.colors = arguments[3];
+ if (isBoolean(opts)) {
+ ctx.showHidden = opts;
+ } else if (opts) {
+ exports._extend(ctx, opts);
+ }
+ if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+ if (isUndefined(ctx.depth)) ctx.depth = 2;
+ if (isUndefined(ctx.colors)) ctx.colors = false;
+ if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+ if (ctx.colors) ctx.stylize = stylizeWithColor;
+ return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+inspect.colors = {
+ 'bold' : [1, 22],
+ 'italic' : [3, 23],
+ 'underline' : [4, 24],
+ 'inverse' : [7, 27],
+ 'white' : [37, 39],
+ 'grey' : [90, 39],
+ 'black' : [30, 39],
+ 'blue' : [34, 39],
+ 'cyan' : [36, 39],
+ 'green' : [32, 39],
+ 'magenta' : [35, 39],
+ 'red' : [31, 39],
+ 'yellow' : [33, 39]
+};
+
+inspect.styles = {
+ 'special': 'cyan',
+ 'number': 'yellow',
+ 'boolean': 'yellow',
+ 'undefined': 'grey',
+ 'null': 'bold',
+ 'string': 'green',
+ 'date': 'magenta',
+ 'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+ var style = inspect.styles[styleType];
+
+ if (style) {
+ return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+ '\u001b[' + inspect.colors[style][1] + 'm';
+ } else {
+ return str;
+ }
+}
+
+
+function stylizeNoColor(str, styleType) {
+ return str;
+}
+
+
+function arrayToHash(array) {
+ var hash = {};
+
+ array.forEach(function(val, idx) {
+ hash[val] = true;
+ });
+
+ return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+ if (ctx.customInspect &&
+ value &&
+ isFunction(value.inspect) &&
+ value.inspect !== exports.inspect &&
+ !(value.constructor && value.constructor.prototype === value)) {
+ var ret = value.inspect(recurseTimes, ctx);
+ if (!isString(ret)) {
+ ret = formatValue(ctx, ret, recurseTimes);
+ }
+ return ret;
+ }
+
+ var primitive = formatPrimitive(ctx, value);
+ if (primitive) {
+ return primitive;
+ }
+
+ var keys = Object.keys(value);
+ var visibleKeys = arrayToHash(keys);
+
+ if (ctx.showHidden) {
+ keys = Object.getOwnPropertyNames(value);
+ }
+
+ if (isError(value)
+ && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+ return formatError(value);
+ }
+
+ if (keys.length === 0) {
+ if (isFunction(value)) {
+ var name = value.name ? ': ' + value.name : '';
+ return ctx.stylize('[Function' + name + ']', 'special');
+ }
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ }
+ if (isDate(value)) {
+ return ctx.stylize(Date.prototype.toString.call(value), 'date');
+ }
+ if (isError(value)) {
+ return formatError(value);
+ }
+ }
+
+ var base = '', array = false, braces = ['{', '}'];
+
+ if (isArray(value)) {
+ array = true;
+ braces = ['[', ']'];
+ }
+
+ if (isFunction(value)) {
+ var n = value.name ? ': ' + value.name : '';
+ base = ' [Function' + n + ']';
+ }
+
+ if (isRegExp(value)) {
+ base = ' ' + RegExp.prototype.toString.call(value);
+ }
+
+ if (isDate(value)) {
+ base = ' ' + Date.prototype.toUTCString.call(value);
+ }
+
+ if (isError(value)) {
+ base = ' ' + formatError(value);
+ }
+
+ if (keys.length === 0 && (!array || value.length == 0)) {
+ return braces[0] + base + braces[1];
+ }
+
+ if (recurseTimes < 0) {
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ } else {
+ return ctx.stylize('[Object]', 'special');
+ }
+ }
+
+ ctx.seen.push(value);
+
+ var output;
+ if (array) {
+ output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+ } else {
+ output = keys.map(function(key) {
+ return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+ });
+ }
+
+ ctx.seen.pop();
+
+ return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+ if (isUndefined(value))
+ return ctx.stylize('undefined', 'undefined');
+ if (isString(value)) {
+ var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+ .replace(/'/g, "\\'")
+ .replace(/\\"/g, '"') + '\'';
+ return ctx.stylize(simple, 'string');
+ }
+ if (isNumber(value))
+ return ctx.stylize('' + value, 'number');
+ if (isBoolean(value))
+ return ctx.stylize('' + value, 'boolean');
+ if (isNull(value))
+ return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+ return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+ var output = [];
+ for (var i = 0, l = value.length; i < l; ++i) {
+ if (hasOwnProperty(value, String(i))) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ String(i), true));
+ } else {
+ output.push('');
+ }
+ }
+ keys.forEach(function(key) {
+ if (!key.match(/^\d+$/)) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ key, true));
+ }
+ });
+ return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+ var name, str, desc;
+ desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+ if (desc.get) {
+ if (desc.set) {
+ str = ctx.stylize('[Getter/Setter]', 'special');
+ } else {
+ str = ctx.stylize('[Getter]', 'special');
+ }
+ } else {
+ if (desc.set) {
+ str = ctx.stylize('[Setter]', 'special');
+ }
+ }
+ if (!hasOwnProperty(visibleKeys, key)) {
+ name = '[' + key + ']';
+ }
+ if (!str) {
+ if (ctx.seen.indexOf(desc.value) < 0) {
+ if (isNull(recurseTimes)) {
+ str = formatValue(ctx, desc.value, null);
+ } else {
+ str = formatValue(ctx, desc.value, recurseTimes - 1);
+ }
+ if (str.indexOf('\n') > -1) {
+ if (array) {
+ str = str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n').substr(2);
+ } else {
+ str = '\n' + str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n');
+ }
+ }
+ } else {
+ str = ctx.stylize('[Circular]', 'special');
+ }
+ }
+ if (isUndefined(name)) {
+ if (array && key.match(/^\d+$/)) {
+ return str;
+ }
+ name = JSON.stringify('' + key);
+ if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+ name = name.substr(1, name.length - 2);
+ name = ctx.stylize(name, 'name');
+ } else {
+ name = name.replace(/'/g, "\\'")
+ .replace(/\\"/g, '"')
+ .replace(/(^"|"$)/g, "'");
+ name = ctx.stylize(name, 'string');
+ }
+ }
+
+ return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+ var numLinesEst = 0;
+ var length = output.reduce(function(prev, cur) {
+ numLinesEst++;
+ if (cur.indexOf('\n') >= 0) numLinesEst++;
+ return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+ }, 0);
+
+ if (length > 60) {
+ return braces[0] +
+ (base === '' ? '' : base + '\n ') +
+ ' ' +
+ output.join(',\n ') +
+ ' ' +
+ braces[1];
+ }
+
+ return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+function isArray(ar) {
+ return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return isObject(e) &&
+ (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('./support/isBuffer');
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+ return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+ 'Oct', 'Nov', 'Dec'];
+
+function timestamp() {
+ var d = new Date();
+ var time = [pad(d.getHours()),
+ pad(d.getMinutes()),
+ pad(d.getSeconds())].join(':');
+ return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+exports.log = function() {
+ console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+
+exports.inherits = require('inherits');
+
+exports._extend = function(origin, add) {
+ if (!add || !isObject(add)) return origin;
+
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
+ }
+ return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+}).call(this,require("FWaASH"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":71,"FWaASH":65,"inherits":64}],73:[function(require,module,exports){
+(function() {
+ var XMLBuilder, XMLFragment;
+
+ XMLFragment = require('./XMLFragment');
+
+ XMLBuilder = (function() {
+
+ function XMLBuilder(name, xmldec, doctype) {
+ var att, child, _ref;
+ this.children = [];
+ this.rootObject = null;
+ if (this.is(name, 'Object')) {
+ _ref = [name, xmldec], xmldec = _ref[0], doctype = _ref[1];
+ name = null;
+ }
+ if (name != null) {
+ name = '' + name || '';
+ if (xmldec == null) {
+ xmldec = {
+ 'version': '1.0'
+ };
+ }
+ }
+ if ((xmldec != null) && !(xmldec.version != null)) {
+ throw new Error("Version number is required");
+ }
+ if (xmldec != null) {
+ xmldec.version = '' + xmldec.version || '';
+ if (!xmldec.version.match(/1\.[0-9]+/)) {
+ throw new Error("Invalid version number: " + xmldec.version);
+ }
+ att = {
+ version: xmldec.version
+ };
+ if (xmldec.encoding != null) {
+ xmldec.encoding = '' + xmldec.encoding || '';
+ if (!xmldec.encoding.match(/[A-Za-z](?:[A-Za-z0-9._-]|-)*/)) {
+ throw new Error("Invalid encoding: " + xmldec.encoding);
+ }
+ att.encoding = xmldec.encoding;
+ }
+ if (xmldec.standalone != null) {
+ att.standalone = xmldec.standalone ? "yes" : "no";
+ }
+ child = new XMLFragment(this, '?xml', att);
+ this.children.push(child);
+ }
+ if (doctype != null) {
+ att = {};
+ if (name != null) {
+ att.name = name;
+ }
+ if (doctype.ext != null) {
+ doctype.ext = '' + doctype.ext || '';
+ att.ext = doctype.ext;
+ }
+ child = new XMLFragment(this, '!DOCTYPE', att);
+ this.children.push(child);
+ }
+ if (name != null) {
+ this.begin(name);
+ }
+ }
+
+ XMLBuilder.prototype.begin = function(name, xmldec, doctype) {
+ var doc, root;
+ if (!(name != null)) {
+ throw new Error("Root element needs a name");
+ }
+ if (this.rootObject) {
+ this.children = [];
+ this.rootObject = null;
+ }
+ if (xmldec != null) {
+ doc = new XMLBuilder(name, xmldec, doctype);
+ return doc.root();
+ }
+ name = '' + name || '';
+ root = new XMLFragment(this, name, {});
+ root.isRoot = true;
+ root.documentObject = this;
+ this.children.push(root);
+ this.rootObject = root;
+ return root;
+ };
+
+ XMLBuilder.prototype.root = function() {
+ return this.rootObject;
+ };
+
+ XMLBuilder.prototype.end = function(options) {
+ return toString(options);
+ };
+
+ XMLBuilder.prototype.toString = function(options) {
+ var child, r, _i, _len, _ref;
+ r = '';
+ _ref = this.children;
+ for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+ child = _ref[_i];
+ r += child.toString(options);
+ }
+ return r;
+ };
+
+ XMLBuilder.prototype.is = function(obj, type) {
+ var clas;
+ clas = Object.prototype.toString.call(obj).slice(8, -1);
+ return (obj != null) && clas === type;
+ };
+
+ return XMLBuilder;
+
+ })();
+
+ module.exports = XMLBuilder;
+
+}).call(this);
+
+},{"./XMLFragment":74}],74:[function(require,module,exports){
+(function() {
+ var XMLFragment,
+ __hasProp = {}.hasOwnProperty;
+
+ XMLFragment = (function() {
+
+ function XMLFragment(parent, name, attributes, text) {
+ this.isRoot = false;
+ this.documentObject = null;
+ this.parent = parent;
+ this.name = name;
+ this.attributes = attributes;
+ this.value = text;
+ this.children = [];
+ }
+
+ XMLFragment.prototype.element = function(name, attributes, text) {
+ var child, key, val, _ref, _ref1;
+ if (!(name != null)) {
+ throw new Error("Missing element name");
+ }
+ name = '' + name || '';
+ this.assertLegalChar(name);
+ if (attributes == null) {
+ attributes = {};
+ }
+ if (this.is(attributes, 'String') && this.is(text, 'Object')) {
+ _ref = [text, attributes], attributes = _ref[0], text = _ref[1];
+ } else if (this.is(attributes, 'String')) {
+ _ref1 = [{}, attributes], attributes = _ref1[0], text = _ref1[1];
+ }
+ for (key in attributes) {
+ if (!__hasProp.call(attributes, key)) continue;
+ val = attributes[key];
+ val = '' + val || '';
+ attributes[key] = this.escape(val);
+ }
+ child = new XMLFragment(this, name, attributes);
+ if (text != null) {
+ text = '' + text || '';
+ text = this.escape(text);
+ this.assertLegalChar(text);
+ child.raw(text);
+ }
+ this.children.push(child);
+ return child;
+ };
+
+ XMLFragment.prototype.insertBefore = function(name, attributes, text) {
+ var child, i, key, val, _ref, _ref1;
+ if (this.isRoot) {
+ throw new Error("Cannot insert elements at root level");
+ }
+ if (!(name != null)) {
+ throw new Error("Missing element name");
+ }
+ name = '' + name || '';
+ this.assertLegalChar(name);
+ if (attributes == null) {
+ attributes = {};
+ }
+ if (this.is(attributes, 'String') && this.is(text, 'Object')) {
+ _ref = [text, attributes], attributes = _ref[0], text = _ref[1];
+ } else if (this.is(attributes, 'String')) {
+ _ref1 = [{}, attributes], attributes = _ref1[0], text = _ref1[1];
+ }
+ for (key in attributes) {
+ if (!__hasProp.call(attributes, key)) continue;
+ val = attributes[key];
+ val = '' + val || '';
+ attributes[key] = this.escape(val);
+ }
+ child = new XMLFragment(this.parent, name, attributes);
+ if (text != null) {
+ text = '' + text || '';
+ text = this.escape(text);
+ this.assertLegalChar(text);
+ child.raw(text);
+ }
+ i = this.parent.children.indexOf(this);
+ this.parent.children.splice(i, 0, child);
+ return child;
+ };
+
+ XMLFragment.prototype.insertAfter = function(name, attributes, text) {
+ var child, i, key, val, _ref, _ref1;
+ if (this.isRoot) {
+ throw new Error("Cannot insert elements at root level");
+ }
+ if (!(name != null)) {
+ throw new Error("Missing element name");
+ }
+ name = '' + name || '';
+ this.assertLegalChar(name);
+ if (attributes == null) {
+ attributes = {};
+ }
+ if (this.is(attributes, 'String') && this.is(text, 'Object')) {
+ _ref = [text, attributes], attributes = _ref[0], text = _ref[1];
+ } else if (this.is(attributes, 'String')) {
+ _ref1 = [{}, attributes], attributes = _ref1[0], text = _ref1[1];
+ }
+ for (key in attributes) {
+ if (!__hasProp.call(attributes, key)) continue;
+ val = attributes[key];
+ val = '' + val || '';
+ attributes[key] = this.escape(val);
+ }
+ child = new XMLFragment(this.parent, name, attributes);
+ if (text != null) {
+ text = '' + text || '';
+ text = this.escape(text);
+ this.assertLegalChar(text);
+ child.raw(text);
+ }
+ i = this.parent.children.indexOf(this);
+ this.parent.children.splice(i + 1, 0, child);
+ return child;
+ };
+
+ XMLFragment.prototype.remove = function() {
+ var i, _ref;
+ if (this.isRoot) {
+ throw new Error("Cannot remove the root element");
+ }
+ i = this.parent.children.indexOf(this);
+ [].splice.apply(this.parent.children, [i, i - i + 1].concat(_ref = [])), _ref;
+ return this.parent;
+ };
+
+ XMLFragment.prototype.text = function(value) {
+ var child;
+ if (!(value != null)) {
+ throw new Error("Missing element text");
+ }
+ value = '' + value || '';
+ value = this.escape(value);
+ this.assertLegalChar(value);
+ child = new XMLFragment(this, '', {}, value);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLFragment.prototype.cdata = function(value) {
+ var child;
+ if (!(value != null)) {
+ throw new Error("Missing CDATA text");
+ }
+ value = '' + value || '';
+ this.assertLegalChar(value);
+ if (value.match(/]]>/)) {
+ throw new Error("Invalid CDATA text: " + value);
+ }
+ child = new XMLFragment(this, '', {}, '');
+ this.children.push(child);
+ return this;
+ };
+
+ XMLFragment.prototype.comment = function(value) {
+ var child;
+ if (!(value != null)) {
+ throw new Error("Missing comment text");
+ }
+ value = '' + value || '';
+ value = this.escape(value);
+ this.assertLegalChar(value);
+ if (value.match(/--/)) {
+ throw new Error("Comment text cannot contain double-hypen: " + value);
+ }
+ child = new XMLFragment(this, '', {}, '');
+ this.children.push(child);
+ return this;
+ };
+
+ XMLFragment.prototype.raw = function(value) {
+ var child;
+ if (!(value != null)) {
+ throw new Error("Missing raw text");
+ }
+ value = '' + value || '';
+ child = new XMLFragment(this, '', {}, value);
+ this.children.push(child);
+ return this;
+ };
+
+ XMLFragment.prototype.up = function() {
+ if (this.isRoot) {
+ throw new Error("This node has no parent. Use doc() if you need to get the document object.");
+ }
+ return this.parent;
+ };
+
+ XMLFragment.prototype.root = function() {
+ var child;
+ if (this.isRoot) {
+ return this;
+ }
+ child = this.parent;
+ while (!child.isRoot) {
+ child = child.parent;
+ }
+ return child;
+ };
+
+ XMLFragment.prototype.document = function() {
+ return this.root().documentObject;
+ };
+
+ XMLFragment.prototype.end = function(options) {
+ return this.document().toString(options);
+ };
+
+ XMLFragment.prototype.prev = function() {
+ var i;
+ if (this.isRoot) {
+ throw new Error("Root node has no siblings");
+ }
+ i = this.parent.children.indexOf(this);
+ if (i < 1) {
+ throw new Error("Already at the first node");
+ }
+ return this.parent.children[i - 1];
+ };
+
+ XMLFragment.prototype.next = function() {
+ var i;
+ if (this.isRoot) {
+ throw new Error("Root node has no siblings");
+ }
+ i = this.parent.children.indexOf(this);
+ if (i === -1 || i === this.parent.children.length - 1) {
+ throw new Error("Already at the last node");
+ }
+ return this.parent.children[i + 1];
+ };
+
+ XMLFragment.prototype.clone = function(deep) {
+ var clonedSelf;
+ clonedSelf = new XMLFragment(this.parent, this.name, this.attributes, this.value);
+ if (deep) {
+ this.children.forEach(function(child) {
+ var clonedChild;
+ clonedChild = child.clone(deep);
+ clonedChild.parent = clonedSelf;
+ return clonedSelf.children.push(clonedChild);
+ });
+ }
+ return clonedSelf;
+ };
+
+ XMLFragment.prototype.importXMLBuilder = function(xmlbuilder) {
+ var clonedRoot;
+ clonedRoot = xmlbuilder.root().clone(true);
+ clonedRoot.parent = this;
+ this.children.push(clonedRoot);
+ clonedRoot.isRoot = false;
+ return this;
+ };
+
+ XMLFragment.prototype.attribute = function(name, value) {
+ var _ref;
+ if (!(name != null)) {
+ throw new Error("Missing attribute name");
+ }
+ if (!(value != null)) {
+ throw new Error("Missing attribute value");
+ }
+ name = '' + name || '';
+ value = '' + value || '';
+ if ((_ref = this.attributes) == null) {
+ this.attributes = {};
+ }
+ this.attributes[name] = this.escape(value);
+ return this;
+ };
+
+ XMLFragment.prototype.removeAttribute = function(name) {
+ if (!(name != null)) {
+ throw new Error("Missing attribute name");
+ }
+ name = '' + name || '';
+ delete this.attributes[name];
+ return this;
+ };
+
+ XMLFragment.prototype.toString = function(options, level) {
+ var attName, attValue, child, indent, newline, pretty, r, space, _i, _len, _ref, _ref1;
+ pretty = (options != null) && options.pretty || false;
+ indent = (options != null) && options.indent || ' ';
+ newline = (options != null) && options.newline || '\n';
+ level || (level = 0);
+ space = new Array(level + 1).join(indent);
+ r = '';
+ if (pretty) {
+ r += space;
+ }
+ if (!(this.value != null)) {
+ r += '<' + this.name;
+ } else {
+ r += '' + this.value;
+ }
+ _ref = this.attributes;
+ for (attName in _ref) {
+ attValue = _ref[attName];
+ if (this.name === '!DOCTYPE') {
+ r += ' ' + attValue;
+ } else {
+ r += ' ' + attName + '="' + attValue + '"';
+ }
+ }
+ if (this.children.length === 0) {
+ if (!(this.value != null)) {
+ r += this.name === '?xml' ? '?>' : this.name === '!DOCTYPE' ? '>' : '/>';
+ }
+ if (pretty) {
+ r += newline;
+ }
+ } else if (pretty && this.children.length === 1 && this.children[0].value) {
+ r += '>';
+ r += this.children[0].value;
+ r += '';
+ r += newline;
+ } else {
+ r += '>';
+ if (pretty) {
+ r += newline;
+ }
+ _ref1 = this.children;
+ for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+ child = _ref1[_i];
+ r += child.toString(options, level + 1);
+ }
+ if (pretty) {
+ r += space;
+ }
+ r += '';
+ if (pretty) {
+ r += newline;
+ }
+ }
+ return r;
+ };
+
+ XMLFragment.prototype.escape = function(str) {
+ return str.replace(/&/g, '&').replace(//g, '>').replace(/'/g, ''').replace(/"/g, '"');
+ };
+
+ XMLFragment.prototype.assertLegalChar = function(str) {
+ var chars, chr;
+ chars = /[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE-\uFFFF]/;
+ chr = str.match(chars);
+ if (chr) {
+ throw new Error("Invalid character (" + chr + ") in string: " + str);
+ }
+ };
+
+ XMLFragment.prototype.is = function(obj, type) {
+ var clas;
+ clas = Object.prototype.toString.call(obj).slice(8, -1);
+ return (obj != null) && clas === type;
+ };
+
+ XMLFragment.prototype.ele = function(name, attributes, text) {
+ return this.element(name, attributes, text);
+ };
+
+ XMLFragment.prototype.txt = function(value) {
+ return this.text(value);
+ };
+
+ XMLFragment.prototype.dat = function(value) {
+ return this.cdata(value);
+ };
+
+ XMLFragment.prototype.att = function(name, value) {
+ return this.attribute(name, value);
+ };
+
+ XMLFragment.prototype.com = function(value) {
+ return this.comment(value);
+ };
+
+ XMLFragment.prototype.doc = function() {
+ return this.document();
+ };
+
+ XMLFragment.prototype.e = function(name, attributes, text) {
+ return this.element(name, attributes, text);
+ };
+
+ XMLFragment.prototype.t = function(value) {
+ return this.text(value);
+ };
+
+ XMLFragment.prototype.d = function(value) {
+ return this.cdata(value);
+ };
+
+ XMLFragment.prototype.a = function(name, value) {
+ return this.attribute(name, value);
+ };
+
+ XMLFragment.prototype.c = function(value) {
+ return this.comment(value);
+ };
+
+ XMLFragment.prototype.r = function(value) {
+ return this.raw(value);
+ };
+
+ XMLFragment.prototype.u = function() {
+ return this.up();
+ };
+
+ return XMLFragment;
+
+ })();
+
+ module.exports = XMLFragment;
+
+}).call(this);
+
+},{}],75:[function(require,module,exports){
+(function() {
+ var XMLBuilder;
+
+ XMLBuilder = require('./XMLBuilder');
+
+ module.exports.create = function(name, xmldec, doctype) {
+ if (name != null) {
+ return new XMLBuilder(name, xmldec, doctype).root();
+ } else {
+ return new XMLBuilder();
+ }
+ };
+
+}).call(this);
+
+},{"./XMLBuilder":73}]},{},[1])
diff --git a/public/vendor/aws-sdk/dist/aws-sdk.min.js b/public/vendor/aws-sdk/dist/aws-sdk.min.js
new file mode 100644
index 00000000000..077da7dab3e
--- /dev/null
+++ b/public/vendor/aws-sdk/dist/aws-sdk.min.js
@@ -0,0 +1,17 @@
+// AWS SDK for JavaScript v2.1.42
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// License at https://sdk.amazonaws.com/js/BUNDLE_LICENSE.txt
+!function e(t,r,a){function o(i,s){if(!r[i]){if(!t[i]){var u="function"==typeof require&&require;if(!s&&u)return u(i,!0);if(n)return n(i,!0);throw new Error("Cannot find module '"+i+"'")}var c=r[i]={exports:{}};t[i][0].call(c.exports,function(e){var r=t[i][1][e];return o(r?r:e)},c,c.exports,e,t,r,a)}return r[i].exports}for(var n="function"==typeof require&&require,i=0;ithis.expireTime?!0:this.expired||!this.accessKeyId||!this.secretAccessKey},get:function(e){var t=this;this.needsRefresh()?this.refresh(function(r){r||(t.expired=!1),e&&e(r)}):e&&e()},refresh:function(e){this.expired=!1,e()}})},{"./core":3}],5:[function(e,t,r){var a=e("../core");a.CognitoIdentityCredentials=a.util.inherit(a.Credentials,{localStorageKey:{id:"aws.cognito.identity-id.",providers:"aws.cognito.identity-providers."},constructor:function(e){a.Credentials.call(this),this.expired=!0,this.params=e,this.data=null,this.identityId=null,this.loadCachedId()},refresh:function(e){var t=this;t.createClients(),t.data=null,t.identityId=null,t.getId(function(r){r?(t.clearCachedId(),e(r)):t.params.RoleArn?t.getCredentialsFromSTS(e):t.getCredentialsForIdentity(e)})},clearCachedId:function(){this.identityId=null,delete this.params.IdentityId;var e=this.params.IdentityPoolId;delete this.storage[this.localStorageKey.id+e],delete this.storage[this.localStorageKey.providers+e]},getId:function(e){var t=this;return"string"==typeof t.params.IdentityId?e(null,t.params.IdentityId):void t.cognito.getId(function(r,a){!r&&a.IdentityId?(t.params.IdentityId=a.IdentityId,e(null,a.IdentityId)):e(r)})},loadCredentials:function(e,t){e&&t&&(t.expired=!1,t.accessKeyId=e.Credentials.AccessKeyId,t.secretAccessKey=e.Credentials.SecretKey,t.sessionToken=e.Credentials.SessionToken,t.expireTime=e.Credentials.Expiration)},getCredentialsForIdentity:function(e){var t=this;t.cognito.getCredentialsForIdentity(function(r,a){r?t.clearCachedId():(t.cacheId(a),t.data=a,t.loadCredentials(t.data,t)),e(r)})},getCredentialsFromSTS:function(e){var t=this;t.cognito.getOpenIdToken(function(r,a){r?(t.clearCachedId(),e(r)):(t.cacheId(a),t.params.WebIdentityToken=a.Token,t.webIdentityCredentials.refresh(function(r){r?t.clearCachedId():(t.data=t.webIdentityCredentials.data,t.sts.credentialsFrom(t.data,t)),e(r)}))})},loadCachedId:function(){var e=this;if(a.util.isBrowser()&&!e.params.IdentityId){var t=e.getStorage("id");if(t&&e.params.Logins){var r=Object.keys(e.params.Logins),o=(e.getStorage("providers")||"").split(","),n=o.filter(function(e){return-1!==r.indexOf(e)});0!==n.length&&(e.params.IdentityId=t)}else t&&(e.params.IdentityId=t)}},createClients:function(){this.webIdentityCredentials=this.webIdentityCredentials||new a.WebIdentityCredentials(this.params),this.cognito=this.cognito||new a.CognitoIdentity({params:this.params}),this.sts=this.sts||new a.STS},cacheId:function(e){this.identityId=e.IdentityId,this.params.IdentityId=this.identityId,a.util.isBrowser()&&(this.setStorage("id",e.IdentityId),this.params.Logins&&this.setStorage("providers",Object.keys(this.params.Logins).join(",")))},getStorage:function(e){return this.storage[this.localStorageKey[e]+this.params.IdentityPoolId]},setStorage:function(e,t){try{this.storage[this.localStorageKey[e]+this.params.IdentityPoolId]=t}catch(r){}},storage:function(){try{return a.util.isBrowser()&&"object"==typeof window.localStorage?window.localStorage:{}}catch(e){return{}}}()})},{"../core":3}],6:[function(e,t,r){var a=e("../core");a.CredentialProviderChain=a.util.inherit(a.Credentials,{constructor:function(e){e?this.providers=e:this.providers=a.CredentialProviderChain.defaultProviders.slice(0)},resolve:function(e){function t(o,n){if(!o&&n||r===a.length)return void e(o,n);var i=a[r++];n="function"==typeof i?i.call():i,n.get?n.get(function(e){t(e,e?null:n)}):t(null,n)}if(0===this.providers.length)return e(new Error("No providers")),this;var r=0,a=this.providers.slice(0);return t(),this}}),a.CredentialProviderChain.defaultProviders=[]},{"../core":3}],7:[function(e,t,r){var a=e("../core");a.SAMLCredentials=a.util.inherit(a.Credentials,{constructor:function(e){a.Credentials.call(this),this.expired=!0,this.params=e},refresh:function(e){var t=this;t.createClients(),e||(e=function(e){if(e)throw e}),t.service.assumeRoleWithSAML(function(r,a){r||t.service.credentialsFrom(a,t),e(r)})},createClients:function(){this.service=this.service||new a.STS({params:this.params})}})},{"../core":3}],8:[function(e,t,r){var a=e("../core");a.TemporaryCredentials=a.util.inherit(a.Credentials,{constructor:function(e){a.Credentials.call(this),this.loadMasterCredentials(),this.expired=!0,this.params=e||{},this.params.RoleArn&&(this.params.RoleSessionName=this.params.RoleSessionName||"temporary-credentials")},refresh:function(e){var t=this;t.createClients(),e||(e=function(e){if(e)throw e}),t.service.config.credentials=t.masterCredentials;var r=t.params.RoleArn?t.service.assumeRole:t.service.getSessionToken;r.call(t.service,function(r,a){r||t.service.credentialsFrom(a,t),e(r)})},loadMasterCredentials:function(){for(this.masterCredentials=a.config.credentials;this.masterCredentials.masterCredentials;)this.masterCredentials=this.masterCredentials.masterCredentials},createClients:function(){this.service=this.service||new a.STS({params:this.params})}})},{"../core":3}],9:[function(e,t,r){var a=e("../core");a.WebIdentityCredentials=a.util.inherit(a.Credentials,{constructor:function(e){a.Credentials.call(this),this.expired=!0,this.params=e,this.params.RoleSessionName=this.params.RoleSessionName||"web-identity",this.data=null},refresh:function(e){var t=this;t.createClients(),e||(e=function(e){if(e)throw e}),t.service.assumeRoleWithWebIdentity(function(r,a){t.data=null,r||(t.data=a,t.service.credentialsFrom(a,t)),e(r)})},createClients:function(){this.service=this.service||new a.STS({params:this.params})}})},{"../core":3}],10:[function(e,t,r){var a=e("./core"),o=e("./sequential_executor");a.EventListeners={Core:{}},a.EventListeners={Core:(new o).addNamedListeners(function(e,t){t("VALIDATE_CREDENTIALS","validate",function(e,t){return e.service.api.signatureVersion?void e.service.config.getCredentials(function(r){r&&(e.response.error=a.util.error(r,{code:"CredentialsError",message:"Missing credentials in config"})),t()}):t()}),e("VALIDATE_REGION","validate",function(e){e.service.config.region||e.service.isGlobalEndpoint||(e.response.error=a.util.error(new Error,{code:"ConfigError",message:"Missing region in config"}))}),e("VALIDATE_PARAMETERS","validate",function(e){var t=e.service.api.operations[e.operation].input;(new a.ParamValidator).validate(t,e.params)}),t("COMPUTE_SHA256","afterBuild",function(e,t){if(e.haltHandlersOnError(),!e.service.api.signatureVersion)return t();if(e.service.getSignerClass(e)===a.Signers.V4){var r=e.httpRequest.body||"";a.util.computeSha256(r,function(r,a){r?t(r):(e.httpRequest.headers["X-Amz-Content-Sha256"]=a,t())})}else t()}),e("SET_CONTENT_LENGTH","afterBuild",function(e){if(void 0===e.httpRequest.headers["Content-Length"]){var t=a.util.string.byteLength(e.httpRequest.body);e.httpRequest.headers["Content-Length"]=t}}),e("SET_HTTP_HOST","afterBuild",function(e){e.httpRequest.headers.Host=e.httpRequest.endpoint.host}),e("RESTART","restart",function(){var e=this.response.error;e&&e.retryable&&(this.httpRequest=new a.HttpRequest(this.service.endpoint,this.service.region),this.response.retryCount=600?this.emit("sign",[this],function(e){e?t(e):i()}):i()}),e("HTTP_HEADERS","httpHeaders",function(e,t,r){r.httpResponse.statusCode=e,r.httpResponse.headers=t,r.httpResponse.body=new a.util.Buffer(""),r.httpResponse.buffers=[],r.httpResponse.numBytes=0}),e("HTTP_DATA","httpData",function(e,t){if(e){if(a.util.isNode()){t.httpResponse.numBytes+=e.length;var r=t.httpResponse.headers["content-length"],o={loaded:t.httpResponse.numBytes,total:r};t.request.emit("httpDownloadProgress",[o,t])}t.httpResponse.buffers.push(new a.util.Buffer(e))}}),e("HTTP_DONE","httpDone",function(e){if(e.httpResponse.buffers&&e.httpResponse.buffers.length>0){var t=a.util.buffer.concat(e.httpResponse.buffers);e.httpResponse.body=t}delete e.httpResponse.numBytes,delete e.httpResponse.buffers}),e("FINALIZE_ERROR","retry",function(e){e.httpResponse.statusCode&&(e.error.statusCode=e.httpResponse.statusCode,void 0===e.error.retryable&&(e.error.retryable=this.service.retryableError(e.error,this)))}),e("INVALIDATE_CREDENTIALS","retry",function(e){
+if(e.error)switch(e.error.code){case"RequestExpired":case"ExpiredTokenException":case"ExpiredToken":e.error.retryable=!0,e.request.service.config.credentials.expired=!0}}),e("EXPIRED_SIGNATURE","retry",function(e){var t=e.error;t&&"string"==typeof t.code&&"string"==typeof t.message&&t.code.match(/Signature/)&&t.message.match(/expired/)&&(e.error.retryable=!0)}),e("REDIRECT","retry",function(e){e.error&&e.error.statusCode>=300&&e.error.statusCode<400&&e.httpResponse.headers.location&&(this.httpRequest.endpoint=new a.Endpoint(e.httpResponse.headers.location),this.httpRequest.headers.Host=this.httpRequest.endpoint.host,e.error.redirect=!0,e.error.retryable=!0)}),e("RETRY_CHECK","retry",function(e){if(e.error)if(e.error.redirect&&e.redirectCount=this.HEADERS_RECEIVED&&!m){try{p.responseType="arraybuffer"}catch(e){}u.statusCode=p.status,u.headers=i.parseHeaders(p.getAllResponseHeaders()),u.emit("headers",u.statusCode,u.headers),m=!0}this.readyState===this.DONE&&i.finishRequest(p,u)},!1),p.upload.addEventListener("progress",function(e){u.emit("sendProgress",e)}),p.addEventListener("progress",function(e){u.emit("receiveProgress",e)},!1),p.addEventListener("timeout",function(){n(a.util.error(new Error("Timeout"),{code:"TimeoutError"}))},!1),p.addEventListener("error",function(){n(a.util.error(new Error("Network Failure"),{code:"NetworkingError"}))},!1),r(u),p.open(e.method,c,t.xhrAsync!==!1),a.util.each(e.headers,function(e,t){"Content-Length"!==e&&"User-Agent"!==e&&"Host"!==e&&p.setRequestHeader(e,t)}),t.timeout&&t.xhrAsync!==!1&&(p.timeout=t.timeout),t.xhrWithCredentials&&(p.withCredentials=!0);try{p.send(e.body)}catch(l){if(!e.body||"object"!=typeof e.body.buffer)throw l;p.send(e.body.buffer)}return u},parseHeaders:function(e){var t={};return a.util.arrayEach(e.split(/\r?\n/),function(e){var r=e.split(":",1)[0],a=e.substring(r.length+2);r.length>0&&(t[r.toLowerCase()]=a)}),t},finishRequest:function(e,t){var r;if("arraybuffer"===e.responseType&&e.response){var o=e.response;r=new a.util.Buffer(o.byteLength);for(var n=new Uint8Array(o),i=0;i1)){if(1===this.errors.length)throw this.errors[0];return!0}var o=this.errors.join("\n* ");if(this.errors.length>1)throw o="There were "+this.errors.length+" validation errors:\n* "+o,a.util.error(new Error(o),{code:"MultipleValidationErrors",errors:this.errors})},validateStructure:function(e,t,r){this.validateType(r,t,["object"],"structure");for(var a,o=0;e.required&&o0){var a=JSON.parse(r.body.toString());(a.__type||a.code)&&(t.code=(a.__type||a.code).split("#").pop()),"RequestEntityTooLarge"===t.code?t.message="Request body must be less than 1 MB":t.message=a.message||a.Message||null}else t.statusCode=r.statusCode,t.message=r.statusCode.toString();e.error=i.error(new Error,t)}function n(e){var t=e.httpResponse.body.toString()||"{}";if(e.request.service.config.convertResponseTypes===!1)e.data=JSON.parse(t);else{var r=e.request.service.api.operations[e.request.operation],a=r.output||{},o=new u;e.data=o.parse(t,a)}}var i=e("../util"),s=e("../json/builder"),u=e("../json/parser");t.exports={buildRequest:a,extractError:o,extractData:n}},{"../json/builder":13,"../json/parser":14,"../util":51}],23:[function(e,t,r){function a(e){var t=e.service.api.operations[e.operation],r=e.httpRequest;r.headers["Content-Type"]="application/x-www-form-urlencoded; charset=utf-8",r.params={Version:e.service.api.apiVersion,Action:t.name};var a=new u;a.serialize(e.params,t.input,function(e,t){r.params[e]=t}),r.body=s.queryParamsToString(r.params)}function o(e){var t,r=e.httpResponse.body.toString();t=r.match("=0?"&":"?";var i=[];c.arrayEach(Object.keys(o).sort(),function(e){Array.isArray(o[e])||(o[e]=[o[e]]);for(var t=0;t0){t=new s.XML.Parser;var m=t.parse(a.toString(),n);u.update(e.data,m)}}var s=e("../core"),u=e("../util"),c=e("./rest");t.exports={buildRequest:o,extractError:n,extractData:i}},{"../core":3,"../util":51,"./rest":24}],27:[function(e,t,r){function a(){}function o(e){return e.isQueryName||"ec2"!==e.api.protocol?e.name:e.name[0].toUpperCase()+e.name.substr(1)}function n(e,t,r,a){c.each(r.members,function(r,n){var i=t[r];if(null!==i&&void 0!==i){var s=o(n);s=e?e+"."+s:s,u(s,i,n,a)}})}function i(e,t,r,a){var o=1;c.each(t,function(t,n){var i=r.flattened?".":".entry.",s=i+o++ +".",c=s+(r.key.name||"key"),p=s+(r.value.name||"value");u(e+c,t,r.key,a),u(e+p,n,r.value,a)})}function s(e,t,r,a){var n=r.member||{};return 0===t.length?void a.call(this,e,null):void c.arrayEach(t,function(t,i){var s="."+(i+1);if("ec2"===r.api.protocol)s+="";else if(r.flattened){if(n.name){var c=e.split(".");c.pop(),c.push(o(n)),e=c.join(".")}}else s=".member"+s;u(e+s,t,n,a)})}function u(e,t,r,a){null!==t&&void 0!==t&&("structure"===r.type?n(e,t,r,a):"list"===r.type?s(e,t,r,a):"map"===r.type?i(e,t,r,a):a(e,r.toWireFormat(t).toString()))}var c=e("../util");a.prototype.serialize=function(e,t,r){n("",e,t,r)},t.exports=a},{"../util":51}],28:[function(e,t,r){function a(e){if(!e)return null;var t=e.split("-");return t.length<3?null:t.slice(0,t.length-2).join("-")+"-*"}function o(e){var t=e.config.region,r=a(t),o=e.api.endpointPrefix;return[[t,o],[r,o],[t,"*"],[r,"*"],["*",o],["*","*"]].map(function(e){return e[0]&&e[1]?e.join("/"):null})}function n(e,t){s.each(t,function(t,r){"globalEndpoint"!==t&&(void 0===e.config[t]||null===e.config[t])&&(e.config[t]=r)})}function i(e){for(var t=o(e),r=0;re){r.removeListener("httpData",a.EventListeners.Core.HTTP_DATA),r.removeListener("httpError",a.EventListeners.Core.HTTP_ERROR),r.on("httpError",function(e){n.error=e,n.error.retryable=!1});var i=n.httpResponse.createUnbufferedStream();2===a.HttpClient.streamsApiVersion?i.pipe(o):(i.on("data",function(e){o.emit("data",e)}),i.on("end",function(){o.emit("end")})),i.on("error",function(e){o.emit("error",e)})}}),this.on("error",function(e){o.emit("error",e)}),o},emitEvent:function(e,t,r){"function"==typeof t&&(r=t,t=null),r||(r=function(){}),t||(t=this.eventParameters(e,this.response));var o=a.SequentialExecutor.prototype.emit;o.call(this,e,t,function(e){e&&(this.response.error=e),r.call(this,e)})},eventParameters:function(e){switch(e){case"restart":case"validate":case"sign":case"build":case"afterValidate":case"afterBuild":return[this];case"error":return[this.response.error,this.response];default:return[this.response]}},presign:function(e,t){return t||"function"!=typeof e||(t=e,e=null),(new a.Signers.Presign).sign(this.toGet(),e,t)},toUnauthenticated:function(){return this.removeListener("validate",a.EventListeners.Core.VALIDATE_CREDENTIALS),this.removeListener("sign",a.EventListeners.Core.SIGN),this.toGet()},toGet:function(){return("query"===this.service.api.protocol||"ec2"===this.service.api.protocol)&&(this.removeListener("build",this.buildAsGet),this.addListener("build",this.buildAsGet)),this},buildAsGet:function(e){e.httpRequest.method="GET",e.httpRequest.path=e.service.endpoint.path+"?"+e.httpRequest.body,e.httpRequest.body="",delete e.httpRequest.headers["Content-Length"],delete e.httpRequest.headers["Content-Type"]},haltHandlersOnError:function(){this._haltHandlersOnError=!0}}),a.util.mixin(a.Request,a.SequentialExecutor)}).call(this,e("FWaASH"))},{"./core":3,"./state_machine":50,FWaASH:65}],31:[function(e,t,r){var a=e("./core"),o=a.util.inherit;a.ResourceWaiter=o({constructor:function(e,t){this.service=e,this.state=t,"object"==typeof this.state&&a.util.each.call(this,this.state,function(e,t){this.state=e,this.expectedValue=t}),this.loadWaiterConfig(this.state),this.expectedValue||(this.expectedValue=this.config.successValue)},service:null,state:null,expectedValue:null,config:null,waitDone:!1,Listeners:{retry:(new a.SequentialExecutor).addNamedListeners(function(e){e("RETRY_CHECK","retry",function(e){var t=e.request._waiter;e.error&&"ResourceNotReady"===e.error.code&&(e.error.retryDelay=1e3*t.config.interval)})}),output:(new a.SequentialExecutor).addNamedListeners(function(e){e("CHECK_OUT_ERROR","extractError",function(e){e.error&&e.request._waiter.setError(e,!0)}),e("CHECK_OUTPUT","extractData",function(e){var t=e.request._waiter,r=t.checkSuccess(e);r?e.error=null:t.setError(e,null===r?!1:!0)})}),error:(new a.SequentialExecutor).addNamedListeners(function(e){e("CHECK_ERROR","extractError",function(e){var t=e.request._waiter,r=t.checkError(e);r?(e.error=null,e.data={},e.request.removeAllListeners("extractData")):t.setError(e,null===r?!1:!0)}),e("CHECK_ERR_OUTPUT","extractData",function(e){e.request._waiter.setError(e,!0)})})},wait:function(e,t){"function"==typeof e&&(t=e,e=void 0);var r=this.service.makeRequest(this.config.operation,e),a=this.Listeners[this.config.successType];return r._waiter=this,r.response.maxRetries=this.config.maxAttempts,r.addListeners(this.Listeners.retry),a&&r.addListeners(a),t&&r.send(t),r},setError:function(e,t){e.data=null,e.error=a.util.error(e.error||new Error,{code:"ResourceNotReady",message:"Resource is not in the state "+this.state,retryable:t})},checkSuccess:function(e){if(!this.config.successPath)return e.httpResponse.statusCode<300;var t=a.util.jamespath.find(this.config.successPath,e.data);return this.config.failureValue&&this.config.failureValue.indexOf(t)>=0?null:this.expectedValue?t===this.expectedValue:t?!0:!1},checkError:function(e){var t=this.config.successValue;return"number"==typeof t?e.httpResponse.statusCode===t:e.error&&e.error.code===t},loadWaiterConfig:function(e,t){if(!this.service.api.waiters[e]){if(t)return;throw new a.util.error(new Error,{code:"StateNotFoundError",message:"State "+e+" not found."})}this.config=this.service.api.waiters[e];var r=this.config;!function(){r.successType=r.successType||r.acceptorType,r.successPath=r.successPath||r.acceptorPath,r.successValue=r.successValue||r.acceptorValue,r.failureType=r.failureType||r.acceptorType,r.failurePath=r.failurePath||r.acceptorPath,r.failureValue=r.failureValue||r.acceptorValue}()}})},{"./core":3}],32:[function(e,t,r){var a=e("./core"),o=a.util.inherit;a.Response=o({constructor:function(e){this.request=e,this.data=null,this.error=null,this.retryCount=0,this.redirectCount=0,this.httpResponse=new a.HttpResponse,e&&(this.maxRetries=e.service.numRetries(),this.maxRedirects=e.service.config.maxRedirects)},nextPage:function(e){var t,r=this.request.service,o=this.request.operation;try{t=r.paginationConfig(o,!0)}catch(n){this.error=n}if(!this.hasNextPage()){if(e)e(this.error,null);else if(this.error)throw this.error;return null}var i=a.util.copy(this.request.params);if(this.nextPageTokens){var s=t.inputToken;"string"==typeof s&&(s=[s]);for(var u=0;ue.partSize&&(e.partSize=r)}else e.totalBytes=void 0},isDoneChunking:!1,partPos:0,totalChunkedBytes:0,totalUploadedBytes:0,totalBytes:void 0,numParts:0,totalPartNumbers:0,activeParts:0,doneParts:0,parts:null,completeInfo:null,failed:!1,multipartReq:null,partBuffers:null,partBufferLength:0,fillBuffer:function(){var e=this,t=o(e.body);if(0===t)return e.isDoneChunking=!0,e.numParts=1,void e.nextChunk(e.body);for(;e.activeParts=e.queueSize)){var t=e.body.read(e.partSize-e.partBufferLength)||e.body.read();if(t&&(e.partBuffers.push(t),e.partBufferLength+=t.length,e.totalChunkedBytes+=t.length),e.partBufferLength>=e.partSize){var a=r.concat(e.partBuffers);if(e.partBuffers=[],e.partBufferLength=0,a.length>e.partSize){var o=a.slice(e.partSize);e.partBuffers.push(o),e.partBufferLength+=o.length,a=a.slice(0,e.partSize)}e.nextChunk(a)}e.isDoneChunking&&!e.isDoneSending&&(a=r.concat(e.partBuffers),e.partBuffers=[],e.partBufferLength=0,e.totalBytes=e.totalChunkedBytes,e.isDoneSending=!0,(0===e.numParts||a.length>0)&&(e.numParts++,e.nextChunk(a))),e.body.read(0)}},nextChunk:function(e){var t=this;if(t.failed)return null;var r=++t.totalPartNumbers;if(t.isDoneChunking&&1===r){var a=t.service.putObject({Body:e});return a._managedUpload=t,a.on("httpUploadProgress",t.progress).send(t.finishSinglePart),null}t.activeParts++,t.service.config.params.UploadId?t.uploadPart(e,r):t.multipartReq?t.queueChunks(e,r):(t.multipartReq=t.service.createMultipartUpload(),t.multipartReq.on("success",function(e){t.service.config.params.UploadId=e.data.UploadId,t.multipartReq=null}),t.queueChunks(e,r),t.multipartReq.on("error",function(e){t.cleanup(e)}),t.multipartReq.send())},uploadPart:function(e,t){var r=this,o={Body:e,ContentLength:a.util.string.byteLength(e),PartNumber:t},n={ETag:null,PartNumber:t};r.completeInfo.push(n);var i=r.service.uploadPart(o);r.parts[t]=i,i._lastUploadedBytes=0,i._managedUpload=r,i.on("httpUploadProgress",r.progress),i.send(function(e,t){if(delete r.parts[o.PartNumber],r.activeParts--,!(e||t&&t.ETag)){var i="No access to ETag property on response.";a.util.isBrowser()&&(i+=" Check CORS configuration to expose ETag header."),e=a.util.error(new Error(i),{code:"ETagMissing",retryable:!1})}return e?r.cleanup(e):(n.ETag=t.ETag,r.doneParts++,void(r.isDoneChunking&&r.doneParts===r.numParts?r.finishMultiPart():r.fillQueue.call(r)))})},queueChunks:function(e,t){var r=this;r.multipartReq.on("success",function(){r.uploadPart(e,t)})},cleanup:function(e){var t=this;t.failed||("function"==typeof t.body.removeAllListeners&&"function"==typeof t.body.resume&&(t.body.removeAllListeners("readable"),t.body.removeAllListeners("end"),t.body.resume()),t.service.config.params.UploadId&&!t.leavePartsOnError&&t.service.abortMultipartUpload().send(),a.util.each(t.parts,function(e,t){t.removeAllListeners("complete"),t.abort()}),t.parts={},t.callback(e),t.failed=!0)},finishMultiPart:function(){var e=this,t={MultipartUpload:{Parts:e.completeInfo}};e.service.completeMultipartUpload(t,function(t,r){return t?e.cleanup(t):void e.callback(t,r)})},finishSinglePart:function(e,t){var r=this.request._managedUpload,o=this.request.httpRequest,n=a.util.urlFormat(o.endpoint);return e?r.callback(e):(t.Location=n.substr(0,n.length-1)+o.path,void r.callback(e,t))},progress:function(e){var t=this._managedUpload;"putObject"===this.operation?e.part=1:(t.totalUploadedBytes+=e.loaded-this._lastUploadedBytes,this._lastUploadedBytes=e.loaded,e={loaded:t.totalUploadedBytes,total:t.totalBytes,part:this.params.PartNumber}),t.emit("httpUploadProgress",[e])}}),a.util.mixin(a.S3.ManagedUpload,a.SequentialExecutor),t.exports=a.S3.ManagedUpload}).call(this,e("buffer").Buffer)},{"../core":3,buffer:54}],34:[function(e,t,r){var a=e("./core");a.SequentialExecutor=a.util.inherit({constructor:function(){this._events={}},listeners:function(e){return this._events[e]?this._events[e].slice(0):[]},on:function(e,t){return this._events[e]?this._events[e].push(t):this._events[e]=[t],this},onAsync:function(e,t){return t._isAsync=!0,this.on(e,t)},removeListener:function(e,t){var r=this._events[e];if(r){for(var a=r.length,o=-1,n=0;a>n;++n)r[n]===t&&(o=n);o>-1&&r.splice(o,1)}return this},removeAllListeners:function(e){return e?delete this._events[e]:this._events={},this},emit:function(e,t,r){r||(r=function(){});var a=this.listeners(e),o=a.length;return this.callListeners(a,t,r),o>0},callListeners:function(e,t,r,o){function n(o){return o&&(s=a.util.error(s||new Error,o),i._haltHandlersOnError)?r.call(i,s):void i.callListeners(e,t,r,s)}for(var i=this,s=o||null;e.length>0;){var u=e.shift();if(u._isAsync)return void u.apply(i,t.concat([n]));try{u.apply(i,t)}catch(c){s=a.util.error(s||new Error,c)}if(s&&i._haltHandlersOnError)return void r.call(i,s)}r.call(i,s)},addListeners:function(e){var t=this;return e._events&&(e=e._events),a.util.each(e,function(e,r){"function"==typeof r&&(r=[r]),a.util.arrayEach(r,function(r){t.on(e,r)})}),t},addNamedListener:function(e,t,r){return this[e]=r,this.addListener(t,r),this},addNamedAsyncListener:function(e,t,r){return r._isAsync=!0,this.addNamedListener(e,t,r)},addNamedListeners:function(e){var t=this;return e(function(){t.addNamedListener.apply(t,arguments)},function(){t.addNamedAsyncListener.apply(t,arguments)}),this}}),a.SequentialExecutor.prototype.addListener=a.SequentialExecutor.prototype.on,t.exports=a.SequentialExecutor},{"./core":3}],35:[function(e,t,r){var a=e("./core"),o=e("./model/api"),n=e("./region_config"),i=a.util.inherit;a.Service=i({constructor:function(e){if(!this.loadServiceClass)throw a.util.error(new Error,"Service must be constructed with `new' operator");var t=this.loadServiceClass(e||{});return t?new t(e):void this.initialize(e)},initialize:function(e){var t=a.config[this.serviceIdentifier];this.config=new a.Config(a.config),t&&this.config.update(t,!0),e&&this.config.update(e,!0),this.validateService(),this.config.endpoint||n(this),this.config.endpoint=this.endpointFromTemplate(this.config.endpoint),this.setEndpoint(this.config.endpoint)},validateService:function(){},loadServiceClass:function(e){var t=e;if(a.util.isEmpty(this.api)){if(t.apiConfig)return a.Service.defineServiceApi(this.constructor,t.apiConfig);if(this.constructor.services){t=new a.Config(a.config),t.update(e,!0);var r=t.apiVersions[this.constructor.serviceIdentifier];return r=r||t.apiVersion,this.getLatestServiceClass(r)}return null}return null},getLatestServiceClass:function(e){return e=this.getLatestServiceVersion(e),null===this.constructor.services[e]&&a.Service.defineServiceApi(this.constructor,e),this.constructor.services[e]},getLatestServiceVersion:function(e){if(!this.constructor.services||0===this.constructor.services.length)throw new Error("No services defined on "+this.constructor.serviceIdentifier);if(e?a.util.isType(e,Date)&&(e=a.util.date.iso8601(e).split("T")[0]):e="latest",Object.hasOwnProperty(this.constructor.services,e))return e;for(var t=Object.keys(this.constructor.services).sort(),r=null,o=t.length-1;o>=0;o--)if("*"!==t[o][t[o].length-1]&&(r=t[o]),t[o].substr(0,10)<=e)return r;throw new Error("Could not find "+this.constructor.serviceIdentifier+" API to satisfy version constraint `"+e+"'")},api:{},defaultRetryCount:3,makeRequest:function(e,t,r){if("function"==typeof t&&(r=t,t=null),t=t||{},this.config.params){var o=this.api.operations[e];o&&(t=a.util.copy(t),a.util.each(this.config.params,function(e,r){o.input.members[e]&&(void 0===t[e]||null===t[e])&&(t[e]=r)}))}var n=new a.Request(this,e,t);return this.addAllRequestListeners(n),r&&n.send(r),n},makeUnauthenticatedRequest:function(e,t,r){"function"==typeof t&&(r=t,t={});var a=this.makeRequest(e,t).toUnauthenticated();return r?a.send(r):a},waitFor:function(e,t,r){var o=new a.ResourceWaiter(this,e);return o.wait(t,r)},addAllRequestListeners:function(e){for(var t=[a.events,a.EventListeners.Core,this.serviceInterface(),a.EventListeners.CorePost],r=0;rr;++r)t[r]=30*Math.pow(2,r);return t},retryableError:function(e){return this.networkingError(e)?!0:this.expiredCredentialsError(e)?!0:this.throttledError(e)?!0:e.statusCode>=500?!0:!1},networkingError:function(e){return"NetworkingError"===e.code},expiredCredentialsError:function(e){return"ExpiredTokenException"===e.code},throttledError:function(e){switch(e.code){case"ProvisionedThroughputExceededException":case"Throttling":case"ThrottlingException":case"RequestLimitExceeded":case"RequestThrottled":return!0;default:return!1}},endpointFromTemplate:function(e){if("string"!=typeof e)return e;var t=e;return t=t.replace(/\{service\}/g,this.api.endpointPrefix),t=t.replace(/\{region\}/g,this.config.region),t=t.replace(/\{scheme\}/g,this.config.sslEnabled?"https":"http")},setEndpoint:function(e){this.endpoint=new a.Endpoint(e,this.config)},paginationConfig:function(e,t){var r=this.api.operations[e].paginator;if(!r){if(t){var o=new Error;throw a.util.error(o,"No pagination configuration for "+e)}return null}return r}}),a.util.update(a.Service,{defineMethods:function(e){a.util.each(e.prototype.api.operations,function(t){e.prototype[t]||(e.prototype[t]=function(e,r){return this.makeRequest(t,e,r)})})},defineService:function(e,t,r){a.Service._serviceMap[e]=!0,Array.isArray(t)||(r=t,t=[]);var o=i(a.Service,r||{});if("string"==typeof e){a.Service.addVersions(o,t);var n=o.serviceIdentifier||e;o.serviceIdentifier=n}else o.prototype.api=e,a.Service.defineMethods(o);return o},addVersions:function(e,t){Array.isArray(t)||(t=[t]),e.services=e.services||{};for(var r=0;rr;++r)0===r?t.push(0):t.push(50*Math.pow(2,r-1));return t}})},{"../core":3}],38:[function(e,t,r){var a=e("../core");a.util.update(a.EC2.prototype,{setupRequestListeners:function(e){e.removeListener("extractError",a.EventListeners.Query.EXTRACT_ERROR),e.addListener("extractError",this.extractError),"copySnapshot"===e.operation&&e.onAsync("validate",this.buildCopySnapshotPresignedUrl)},buildCopySnapshotPresignedUrl:function(e,t){if(e.params.PresignedUrl||e._subRequest)return t();e.params=a.util.copy(e.params),e.params.DestinationRegion=e.service.config.region;var r=a.util.copy(e.service.config);delete r.endpoint,r.region=e.params.SourceRegion;var o=new e.service.constructor(r),n=o[e.operation](e.params);n._subRequest=!0,n.presign(function(r,a){r?t(r):(e.params.PresignedUrl=a,t())})},extractError:function(e){var t=e.httpResponse,r=(new a.XML.Parser).parse(t.body.toString()||"");r.Errors?e.error=a.util.error(new Error,{code:r.Errors.Error.Code,message:r.Errors.Error.Message}):e.error=a.util.error(new Error,{code:t.statusCode,message:null})}})},{"../core":3}],39:[function(e,t,r){var a=e("../core");a.util.update(a.MachineLearning.prototype,{setupRequestListeners:function(e){"predict"===e.operation&&e.addListener("build",this.buildEndpoint)},buildEndpoint:function(e){var t=e.params.PredictEndpoint;t&&(e.httpRequest.endpoint=new a.Endpoint(t))}})},{"../core":3}],40:[function(e,t,r){var a=e("../core");e("../s3/managed_upload"),a.util.update(a.S3.prototype,{validateService:function(){if(this.config.region||(this.config.region="us-east-1"),!this.config.endpoint&&this.config.s3BucketEndpoint){var e="An endpoint must be provided when configuring `s3BucketEndpoint` to true.";throw a.util.error(new Error,{name:"InvalidEndpoint",message:e})}},setupRequestListeners:function(e){e.addListener("validate",this.validateScheme),e.addListener("validate",this.validateBucketEndpoint),e.addListener("build",this.addContentType),e.addListener("build",this.populateURI),e.addListener("build",this.computeContentMd5),e.addListener("build",this.computeSseCustomerKeyMd5),e.addListener("afterBuild",this.addExpect100Continue),e.removeListener("validate",a.EventListeners.Core.VALIDATE_REGION),e.addListener("extractError",this.extractError),e.addListener("extractData",this.extractData),e.addListener("extractData",a.util.hoistPayloadMember),e.addListener("beforePresign",this.prepareSignedUrl)},validateScheme:function(e){var t=e.params,r=e.httpRequest.endpoint.protocol,o=t.SSECustomerKey||t.CopySourceSSECustomerKey;if(o&&"https:"!==r){var n="Cannot send SSE keys over HTTP. Set 'sslEnabled'to 'true' in your configuration";throw a.util.error(new Error,{code:"ConfigError",message:n})}},validateBucketEndpoint:function(e){if(!e.params.Bucket&&e.service.config.s3BucketEndpoint){var t="Cannot send requests to root API with `s3BucketEndpoint` set.";throw a.util.error(new Error,{code:"ConfigError",message:t})}},populateURI:function(e){var t=e.httpRequest,r=e.params.Bucket;if(r&&!e.service.pathStyleBucketName(r)){if(!e.service.config.s3BucketEndpoint){t.endpoint.hostname=r+"."+t.endpoint.hostname;var a=t.endpoint.port;80!==a&&443!==a?t.endpoint.host=t.endpoint.hostname+":"+t.endpoint.port:t.endpoint.host=t.endpoint.hostname}t.virtualHostedBucket=r,t.path=t.path.replace(new RegExp("/"+r),""),"/"!==t.path[0]&&(t.path="/"+t.path)}},addExpect100Continue:function(e){var t=e.httpRequest.headers["Content-Length"];a.util.isNode()&&t>=1048576&&(e.httpRequest.headers.Expect="100-continue")},addContentType:function(e){var t=e.httpRequest;if("GET"===t.method||"HEAD"===t.method)return void delete t.headers["Content-Type"];t.headers["Content-Type"]||(t.headers["Content-Type"]="application/octet-stream");var r=t.headers["Content-Type"];if(a.util.isBrowser())if("string"!=typeof t.body||r.match(/;\s*charset=/)){var o=function(e,t,r){return t+r.toUpperCase()};t.headers["Content-Type"]=r.replace(/(;\s*charset=)(.+)$/,o)}else{var n="; charset=UTF-8";t.headers["Content-Type"]+=n}},computableChecksumOperations:{putBucketCors:!0,putBucketLifecycle:!0,putBucketTagging:!0,deleteObjects:!0},willComputeChecksums:function(e){if(this.computableChecksumOperations[e.operation])return!0;if(!this.config.computeChecksums)return!1;if(!a.util.Buffer.isBuffer(e.httpRequest.body)&&"string"!=typeof e.httpRequest.body)return!1;var t=e.service.api.operations[e.operation].input.members;return e.service.getSignerClass(e)===a.Signers.V4&&t.ContentMD5&&!t.ContentMD5.required?!1:t.ContentMD5&&!e.params.ContentMD5?!0:void 0},computeContentMd5:function(e){if(e.service.willComputeChecksums(e)){var t=a.util.crypto.md5(e.httpRequest.body,"base64");e.httpRequest.headers["Content-MD5"]=t}},computeSseCustomerKeyMd5:function(e){var t={SSECustomerKey:"x-amz-server-side-encryption-customer-key-MD5",CopySourceSSECustomerKey:"x-amz-copy-source-server-side-encryption-customer-key-MD5"};a.util.each(t,function(t,r){if(e.params[t]){var o=a.util.crypto.md5(e.params[t],"base64");e.httpRequest.headers[r]=o}})},pathStyleBucketName:function(e){return this.config.s3ForcePathStyle?!0:this.config.s3BucketEndpoint?!1:this.dnsCompatibleBucketName(e)?this.config.sslEnabled&&e.match(/\./)?!0:!1:!0},dnsCompatibleBucketName:function(e){var t=e,r=new RegExp(/^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/),a=new RegExp(/(\d+\.){3}\d+/),o=new RegExp(/\.\./);return!t.match(r)||t.match(a)||t.match(o)?!1:!0},successfulResponse:function(e){var t=e.request,r=e.httpResponse;return"completeMultipartUpload"===t.operation&&r.body.toString().match("")?!1:r.statusCode<300},retryableError:function(e,t){if("completeMultipartUpload"===t.operation&&200===e.statusCode)return!0;if(e&&"RequestTimeout"===e.code)return!0;var r=a.Service.prototype.retryableError;return r.call(this,e,t)},extractData:function(e){var t=e.request;if("getBucketLocation"===t.operation){var r=e.httpResponse.body.toString().match(/>(.+)<\/Location/);delete e.data._,r?e.data.LocationConstraint=r[1]:e.data.LocationConstraint=""}},extractError:function(e){var t={304:"NotModified",403:"Forbidden",400:"BadRequest",404:"NotFound"},r=e.httpResponse.statusCode,o=e.httpResponse.body||"";if(t[r]&&0===o.length)e.error=a.util.error(new Error,{code:t[e.httpResponse.statusCode],message:null});else{var n=(new a.XML.Parser).parse(o.toString());e.error=a.util.error(new Error,{code:n.Code||r,message:n.Message||null})}},getSignedUrl:function(e,t,r){t=a.util.copy(t||{});var o=t.Expires||900;delete t.Expires;var n=this.makeRequest(e,t);return n.presign(o,r)},prepareSignedUrl:function(e){e.addListener("validate",e.service.noPresignedContentLength),e.removeListener("build",e.service.addContentType),e.params.Body?e.addListener("afterBuild",a.EventListeners.Core.COMPUTE_SHA256):e.removeListener("build",e.service.computeContentMd5)},noPresignedContentLength:function(e){if(void 0!==e.params.ContentLength)throw a.util.error(new Error,{code:"UnexpectedParameter",message:"ContentLength is not supported in pre-signed URLs."})},createBucket:function(e,t){e||(e={});var r=this.endpoint.hostname;return r===this.api.globalEndpoint||e.CreateBucketConfiguration||(e.CreateBucketConfiguration={LocationConstraint:this.config.region}),this.makeRequest("createBucket",e,t)},upload:function(e,t,r){"function"==typeof t&&void 0===r&&(r=t,t=null),t=t||{},t=a.util.merge(t||{},{service:this,params:e});var o=new a.S3.ManagedUpload(t);return"function"==typeof r&&o.send(r),o}})},{"../core":3,"../s3/managed_upload":33}],41:[function(e,t,r){var a=e("../core");a.util.update(a.SQS.prototype,{setupRequestListeners:function(e){e.addListener("build",this.buildEndpoint),e.service.config.computeChecksums&&("sendMessage"===e.operation?e.addListener("extractData",this.verifySendMessageChecksum):"sendMessageBatch"===e.operation?e.addListener("extractData",this.verifySendMessageBatchChecksum):"receiveMessage"===e.operation&&e.addListener("extractData",this.verifyReceiveMessageChecksum))},verifySendMessageChecksum:function(e){if(e.data){var t=e.data.MD5OfMessageBody,r=this.params.MessageBody,a=this.service.calculateChecksum(r);if(a!==t){var o='Got "'+e.data.MD5OfMessageBody+'", expecting "'+a+'".';this.service.throwInvalidChecksumError(e,[e.data.MessageId],o)}}},verifySendMessageBatchChecksum:function(e){if(e.data){var t=this.service,r={},o=[],n=[];a.util.arrayEach(e.data.Successful,function(e){r[e.Id]=e}),a.util.arrayEach(this.params.Entries,function(e){if(r[e.Id]){var a=r[e.Id].MD5OfMessageBody,i=e.MessageBody;t.isChecksumValid(a,i)||(o.push(e.Id),n.push(r[e.Id].MessageId))}}),o.length>0&&t.throwInvalidChecksumError(e,n,"Invalid messages: "+o.join(", "))}},verifyReceiveMessageChecksum:function(e){if(e.data){var t=this.service,r=[];a.util.arrayEach(e.data.Messages,function(e){var a=e.MD5OfBody,o=e.Body;t.isChecksumValid(a,o)||r.push(e.MessageId)}),r.length>0&&t.throwInvalidChecksumError(e,r,"Invalid messages: "+r.join(", "))}},throwInvalidChecksumError:function(e,t,r){e.error=a.util.error(new Error,{retryable:!0,code:"InvalidChecksum",messageIds:t,message:e.request.operation+" returned an invalid MD5 response. "+r})},isChecksumValid:function(e,t){return this.calculateChecksum(t)===e},calculateChecksum:function(e){return a.util.crypto.md5(e,"hex")},buildEndpoint:function(e){var t=e.httpRequest.params.QueueUrl;if(t){e.httpRequest.endpoint=new a.Endpoint(t);var r=e.httpRequest.endpoint.host.match(/^sqs\.(.+?)\./);r&&(e.httpRequest.region=r[1])}}})},{"../core":3}],42:[function(e,t,r){var a=e("../core");a.util.update(a.STS.prototype,{credentialsFrom:function(e,t){return e?(t||(t=new a.TemporaryCredentials),t.expired=!1,t.accessKeyId=e.Credentials.AccessKeyId,t.secretAccessKey=e.Credentials.SecretAccessKey,t.sessionToken=e.Credentials.SessionToken,t.expireTime=e.Credentials.Expiration,t):null},assumeRoleWithWebIdentity:function(e,t){return this.makeUnauthenticatedRequest("assumeRoleWithWebIdentity",e,t)},assumeRoleWithSAML:function(e,t){return this.makeUnauthenticatedRequest("assumeRoleWithSAML",e,t)}})},{"../core":3}],43:[function(e,t,r){function a(e){var t=e.httpRequest.headers[s];
+if(delete e.httpRequest.headers["User-Agent"],delete e.httpRequest.headers["X-Amz-User-Agent"],e.service.getSignerClass()===n.Signers.V4){if(t>604800){var r="Presigning does not support expiry time greater than a week with SigV4 signing.";throw n.util.error(new Error,{code:"InvalidExpiryTime",message:r,retryable:!1})}e.httpRequest.headers[s]=t}else{if(e.service.getSignerClass()!==n.Signers.S3)throw n.util.error(new Error,{message:"Presigning only supports S3 or SigV4 signing.",code:"UnsupportedSigner",retryable:!1});e.httpRequest.headers[s]=parseInt(n.util.date.unixTimestamp()+t,10).toString()}}function o(e){var t=e.httpRequest.endpoint,r=n.util.urlParse(e.httpRequest.path),a={};r.search&&(a=n.util.queryStringParse(r.search.substr(1))),n.util.each(e.httpRequest.headers,function(e,t){e===s&&(e="Expires"),a[e]=t}),delete e.httpRequest.headers[s];var o=a.Authorization.split(" ");if("AWS"===o[0])o=o[1].split(":"),a.AWSAccessKeyId=o[0],a.Signature=o[1];else if("AWS4-HMAC-SHA256"===o[0]){o.shift();var i=o.join(" "),u=i.match(/Signature=(.*?)(?:,|\s|\r?\n|$)/)[1];a["X-Amz-Signature"]=u,delete a.Expires}delete a.Authorization,delete a.Host,t.pathname=r.pathname,t.search=n.util.queryParamsToString(a)}var n=e("../core"),i=n.util.inherit,s="presigned-expires";n.Signers.Presign=i({sign:function(e,t,r){if(e.httpRequest.headers[s]=t||3600,e.on("build",a),e.on("sign",o),e.removeListener("afterBuild",n.EventListeners.Core.SET_CONTENT_LENGTH),e.removeListener("afterBuild",n.EventListeners.Core.COMPUTE_SHA256),e.emit("beforePresign",[e]),!r){if(e.build(),e.response.error)throw e.response.error;return n.util.urlFormat(e.httpRequest.endpoint)}e.build(function(){this.response.error?r(this.response.error):r(null,n.util.urlFormat(e.httpRequest.endpoint))})}}),t.exports=n.Signers.Presign},{"../core":3}],44:[function(e,t,r){var a=e("../core"),o=a.util.inherit;a.Signers.RequestSigner=o({constructor:function(e){this.request=e}}),a.Signers.RequestSigner.getVersion=function(e){switch(e){case"v2":return a.Signers.V2;case"v3":return a.Signers.V3;case"v4":return a.Signers.V4;case"s3":return a.Signers.S3;case"v3https":return a.Signers.V3Https}throw new Error("Unknown signing version "+e)},e("./v2"),e("./v3"),e("./v3https"),e("./v4"),e("./s3"),e("./presign")},{"../core":3,"./presign":43,"./s3":45,"./v2":46,"./v3":47,"./v3https":48,"./v4":49}],45:[function(e,t,r){var a=e("../core"),o=a.util.inherit;a.Signers.S3=o(a.Signers.RequestSigner,{subResources:{acl:1,cors:1,lifecycle:1,"delete":1,location:1,logging:1,notification:1,partNumber:1,policy:1,requestPayment:1,restore:1,tagging:1,torrent:1,uploadId:1,uploads:1,versionId:1,versioning:1,versions:1,website:1},responseHeaders:{"response-content-type":1,"response-content-language":1,"response-expires":1,"response-cache-control":1,"response-content-disposition":1,"response-content-encoding":1},addAuthorization:function(e,t){this.request.headers["presigned-expires"]||(this.request.headers["X-Amz-Date"]=a.util.date.rfc822(t)),e.sessionToken&&(this.request.headers["x-amz-security-token"]=e.sessionToken);var r=this.sign(e.secretAccessKey,this.stringToSign()),o="AWS "+e.accessKeyId+":"+r;this.request.headers.Authorization=o},stringToSign:function(){var e=this.request,t=[];t.push(e.method),t.push(e.headers["Content-MD5"]||""),t.push(e.headers["Content-Type"]||""),t.push(e.headers["presigned-expires"]||"");var r=this.canonicalizedAmzHeaders();return r&&t.push(r),t.push(this.canonicalizedResource()),t.join("\n")},canonicalizedAmzHeaders:function(){var e=[];a.util.each(this.request.headers,function(t){t.match(/^x-amz-/i)&&e.push(t)}),e.sort(function(e,t){return e.toLowerCase()=0?"&":"?";this.request.path+=n+a.util.queryParamsToString(o)},authorization:function(e,t){var r=[],a=this.credentialString(t);return r.push(this.algorithm+" Credential="+e.accessKeyId+"/"+a),r.push("SignedHeaders="+this.signedHeaders()),r.push("Signature="+this.signature(e,t)),r.join(", ")},signature:function(e,t){var r=n[this.serviceName],o=t.substr(0,8);if(!r||r.akid!==e.accessKeyId||r.region!==this.request.region||r.date!==o){var i=e.secretAccessKey,s=a.util.crypto.hmac("AWS4"+i,o,"buffer"),u=a.util.crypto.hmac(s,this.request.region,"buffer"),c=a.util.crypto.hmac(u,this.serviceName,"buffer"),p=a.util.crypto.hmac(c,"aws4_request","buffer");n[this.serviceName]={region:this.request.region,date:o,key:p,akid:e.accessKeyId}}var m=n[this.serviceName].key;return a.util.crypto.hmac(m,this.stringToSign(t),"hex")},stringToSign:function(e){var t=[];return t.push("AWS4-HMAC-SHA256"),t.push(e),t.push(this.credentialString(e)),t.push(this.hexEncodedHash(this.canonicalString())),t.join("\n")},canonicalString:function(){var e=[],t=this.request.pathname();return"s3"!==this.serviceName&&(t=a.util.uriEscapePath(t)),e.push(this.request.method),e.push(t),e.push(this.request.search()),e.push(this.canonicalHeaders()+"\n"),e.push(this.signedHeaders()),e.push(this.hexEncodedBodyHash()),e.join("\n")},canonicalHeaders:function(){var e=[];a.util.each.call(this,this.request.headers,function(t,r){e.push([t,r])}),e.sort(function(e,t){return e[0].toLowerCase()=e.length)return t.push(null);var o=r+a;o>e.length&&(o=e.length),t.push(e.slice(r,o)),r=o},t},concat:function(e){var t,r=0,a=0,o=null;for(t=0;ta&&(a=e.length+a),r.push(e[a])}}),a=r),0===a.length?i.abort:void 0}),a.length>0?(r=a,i.abort):void 0}),r},find:function(e,t){return i.jamespath.query(e,t)[0]}},date:{getDate:function(){return a||(a=e("./core")),a.config.systemClockOffset?new Date((new Date).getTime()+a.config.systemClockOffset):new Date},iso8601:function(e){return void 0===e&&(e=i.date.getDate()),e.toISOString().replace(/\.\d{3}Z$/,"Z")},rfc822:function(e){return void 0===e&&(e=i.date.getDate()),e.toUTCString()},unixTimestamp:function(e){return void 0===e&&(e=i.date.getDate()),e.getTime()/1e3},from:function(e){return"number"==typeof e?new Date(1e3*e):new Date(e)},format:function(e,t){return t||(t="iso8601"),i.date[t](i.date.from(e))},parseTimestamp:function(e){if("number"==typeof e)return new Date(1e3*e);if(e.match(/^\d+$/))return new Date(1e3*e);if(e.match(/^\d{4}/))return new Date(e);if(e.match(/^\w{3},/))return new Date(e);throw i.error(new Error("unhandled timestamp format: "+e),{code:"TimestampParserError"})}},crypto:{crc32Table:[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759,2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977,2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755,2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956,3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270,936918e3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117],crc32:function(e){var t=i.crypto.crc32Table,r=-1;"string"==typeof e&&(e=new n(e));for(var a=0;a>>8^t[255&(r^o)]}return(-1^r)>>>0},hmac:function(e,t,r,a){return r||(r="binary"),"buffer"===r&&(r=void 0),a||(a="sha256"),"string"==typeof t&&(t=new n(t)),o.createHmac(a,e).update(t).digest(r)},md5:function(e,t,r){return i.crypto.hash("md5",e,t,r)},sha256:function(e,t,r){return i.crypto.hash("sha256",e,t,r)},hash:function(e,t,r,a){var o=i.crypto.createHash(e);r||(r="binary"),"buffer"===r&&(r=void 0),"string"==typeof t&&(t=new n(t));var s=i.arraySliceFn(t),u=n.isBuffer(t);if(a&&"object"==typeof t&&"function"==typeof t.on&&!u)t.on("data",function(e){o.update(e)}),t.on("error",function(e){a(e)}),t.on("end",function(){a(null,o.digest(r))});else{if(!a||!s||u||"undefined"==typeof FileReader){i.isBrowser()&&"object"==typeof t&&!u&&(t=new n(new Uint8Array(t)));var c=o.update(t).digest(r);return a&&a(null,c),c}var p=0,m=524288,l=new FileReader;l.onerror=function(){a(new Error("Failed to read data."))},l.onload=function(){var e=new n(new Uint8Array(l.result));o.update(e),p+=e.length,l._continueReading()},l._continueReading=function(){if(p>=t.size)return void a(null,o.digest(r));var e=p+m;e>t.size&&(e=t.size),l.readAsArrayBuffer(s.call(t,p,e))},l._continueReading()}},toHex:function(e){for(var t=[],r=0;r0||a?n.root().toString():""},t.exports=a},{"../util":51,xmlbuilder:75}],54:[function(e,t,r){function a(e,t,r){if(!(this instanceof a))return new a(e,t,r);var o=typeof e;if("base64"===t&&"string"===o)for(e=A(e);e.length%4!==0;)e+="=";var n;if("number"===o)n=x(e);else if("string"===o)n=a.byteLength(e,t);else{if("object"!==o)throw new Error("First argument needs to be a number, array or string.");n=x(e.length)}var i;a._useTypedArrays?i=a._augment(new Uint8Array(n)):(i=this,i.length=n,i._isBuffer=!0);var s;if(a._useTypedArrays&&"number"==typeof e.byteLength)i._set(e);else if(P(e))for(s=0;n>s;s++)a.isBuffer(e)?i[s]=e.readUInt8(s):i[s]=e[s];else if("string"===o)i.write(e,0,t);else if("number"===o&&!a._useTypedArrays&&!r)for(s=0;n>s;s++)i[s]=0;return i}function o(e,t,r,o){r=Number(r)||0;var n=e.length-r;o?(o=Number(o),o>n&&(o=n)):o=n;var i=t.length;G(i%2===0,"Invalid hex string"),o>i/2&&(o=i/2);for(var s=0;o>s;s++){var u=parseInt(t.substr(2*s,2),16);G(!isNaN(u),"Invalid hex string"),e[r+s]=u}return a._charsWritten=2*s,s}function n(e,t,r,o){var n=a._charsWritten=_(L(t),e,r,o);return n}function i(e,t,r,o){var n=a._charsWritten=_(M(t),e,r,o);return n}function s(e,t,r,a){return i(e,t,r,a)}function u(e,t,r,o){var n=a._charsWritten=_(U(t),e,r,o);return n}function c(e,t,r,o){var n=a._charsWritten=_(B(t),e,r,o);return n}function p(e,t,r){return 0===t&&r===e.length?K.fromByteArray(e):K.fromByteArray(e.slice(t,r))}function m(e,t,r){var a="",o="";r=Math.min(e.length,r);for(var n=t;r>n;n++)e[n]<=127?(a+=V(o)+String.fromCharCode(e[n]),o=""):o+="%"+e[n].toString(16);return a+V(o)}function l(e,t,r){var a="";r=Math.min(e.length,r);for(var o=t;r>o;o++)a+=String.fromCharCode(e[o]);return a}function d(e,t,r){return l(e,t,r)}function y(e,t,r){var a=e.length;(!t||0>t)&&(t=0),(!r||0>r||r>a)&&(r=a);for(var o="",n=t;r>n;n++)o+=w(e[n]);return o}function h(e,t,r){for(var a=e.slice(t,r),o="",n=0;n=o)){var n;return r?(n=e[t],o>t+1&&(n|=e[t+1]<<8)):(n=e[t]<<8,o>t+1&&(n|=e[t+1])),n}}function f(e,t,r,a){a||(G("boolean"==typeof r,"missing or invalid endian"),G(void 0!==t&&null!==t,"missing offset"),G(t+3=o)){var n;return r?(o>t+2&&(n=e[t+2]<<16),o>t+1&&(n|=e[t+1]<<8),n|=e[t],o>t+3&&(n+=e[t+3]<<24>>>0)):(o>t+1&&(n=e[t+1]<<16),o>t+2&&(n|=e[t+2]<<8),o>t+3&&(n|=e[t+3]),n+=e[t]<<24>>>0),n}}function S(e,t,r,a){a||(G("boolean"==typeof r,"missing or invalid endian"),G(void 0!==t&&null!==t,"missing offset"),G(t+1=o)){var n=b(e,t,r,!0),i=32768&n;return i?-1*(65535-n+1):n}}function g(e,t,r,a){a||(G("boolean"==typeof r,"missing or invalid endian"),G(void 0!==t&&null!==t,"missing offset"),G(t+3=o)){var n=f(e,t,r,!0),i=2147483648&n;return i?-1*(4294967295-n+1):n}}function N(e,t,r,a){return a||(G("boolean"==typeof r,"missing or invalid endian"),G(t+3=n))for(var i=0,s=Math.min(n-r,2);s>i;i++)e[r+i]=(t&255<<8*(a?i:1-i))>>>8*(a?i:1-i)}function k(e,t,r,a,o){o||(G(void 0!==t&&null!==t,"missing value"),G("boolean"==typeof a,"missing or invalid endian"),G(void 0!==r&&null!==r,"missing offset"),G(r+3=n))for(var i=0,s=Math.min(n-r,4);s>i;i++)e[r+i]=t>>>8*(a?i:3-i)&255}function R(e,t,r,a,o){o||(G(void 0!==t&&null!==t,"missing value"),G("boolean"==typeof a,"missing or invalid endian"),G(void 0!==r&&null!==r,"missing offset"),G(r+1=n||(t>=0?v(e,t,r,a,o):v(e,65535+t+1,r,a,o))}function C(e,t,r,a,o){o||(G(void 0!==t&&null!==t,"missing value"),G("boolean"==typeof a,"missing or invalid endian"),G(void 0!==r&&null!==r,"missing offset"),G(r+3=n||(t>=0?k(e,t,r,a,o):k(e,4294967295+t+1,r,a,o))}function T(e,t,r,a,o){o||(G(void 0!==t&&null!==t,"missing value"),G("boolean"==typeof a,"missing or invalid endian"),G(void 0!==r&&null!==r,"missing offset"),G(r+3=n||j.write(e,t,r,a,23,4)}function D(e,t,r,a,o){o||(G(void 0!==t&&null!==t,"missing value"),
+G("boolean"==typeof a,"missing or invalid endian"),G(void 0!==r&&null!==r,"missing offset"),G(r+7=n||j.write(e,t,r,a,52,8)}function A(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}function q(e,t,r){return"number"!=typeof e?r:(e=~~e,e>=t?t:e>=0?e:(e+=t,e>=0?e:0))}function x(e){return e=~~Math.ceil(+e),0>e?0:e}function E(e){return(Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)})(e)}function P(e){return E(e)||a.isBuffer(e)||e&&"object"==typeof e&&"number"==typeof e.length}function w(e){return 16>e?"0"+e.toString(16):e.toString(16)}function L(e){for(var t=[],r=0;r=a)t.push(e.charCodeAt(r));else{var o=r;a>=55296&&57343>=a&&r++;for(var n=encodeURIComponent(e.slice(o,r+1)).substr(1).split("%"),i=0;i>8,a=t%256,o.push(a),o.push(r);return o}function U(e){return K.toByteArray(e)}function _(e,t,r,a){for(var o=0;a>o&&!(o+r>=t.length||o>=e.length);o++)t[o+r]=e[o];return o}function V(e){try{return decodeURIComponent(e)}catch(t){return String.fromCharCode(65533)}}function z(e,t){G("number"==typeof e,"cannot write a non-number as a number"),G(e>=0,"specified a negative value for writing an unsigned value"),G(t>=e,"value is larger than maximum value for type"),G(Math.floor(e)===e,"value has a fractional component")}function F(e,t,r){G("number"==typeof e,"cannot write a non-number as a number"),G(t>=e,"value larger than maximum allowed value"),G(e>=r,"value smaller than minimum allowed value"),G(Math.floor(e)===e,"value has a fractional component")}function O(e,t,r){G("number"==typeof e,"cannot write a non-number as a number"),G(t>=e,"value larger than maximum allowed value"),G(e>=r,"value smaller than minimum allowed value")}function G(e,t){if(!e)throw new Error(t||"Failed assertion")}var K=e("base64-js"),j=e("ieee754");r.Buffer=a,r.SlowBuffer=a,r.INSPECT_MAX_BYTES=50,a.poolSize=8192,a._useTypedArrays=function(){try{var e=new ArrayBuffer(0),t=new Uint8Array(e);return t.foo=function(){return 42},42===t.foo()&&"function"==typeof t.subarray}catch(r){return!1}}(),a.isEncoding=function(e){switch(String(e).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"raw":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},a.isBuffer=function(e){return!(null===e||void 0===e||!e._isBuffer)},a.byteLength=function(e,t){var r;switch(e+="",t||"utf8"){case"hex":r=e.length/2;break;case"utf8":case"utf-8":r=L(e).length;break;case"ascii":case"binary":case"raw":r=e.length;break;case"base64":r=U(e).length;break;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":r=2*e.length;break;default:throw new Error("Unknown encoding")}return r},a.concat=function(e,t){if(G(E(e),"Usage: Buffer.concat(list, [totalLength])\nlist should be an Array."),0===e.length)return new a(0);if(1===e.length)return e[0];var r;if("number"!=typeof t)for(t=0,r=0;rm&&(r=m)):r=m,a=String(a||"utf8").toLowerCase();var l;switch(a){case"hex":l=o(this,e,t,r);break;case"utf8":case"utf-8":l=n(this,e,t,r);break;case"ascii":l=i(this,e,t,r);break;case"binary":l=s(this,e,t,r);break;case"base64":l=u(this,e,t,r);break;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":l=c(this,e,t,r);break;default:throw new Error("Unknown encoding")}return l},a.prototype.toString=function(e,t,r){var a=this;if(e=String(e||"utf8").toLowerCase(),t=Number(t)||0,r=void 0!==r?Number(r):r=a.length,r===t)return"";var o;switch(e){case"hex":o=y(a,t,r);break;case"utf8":case"utf-8":o=m(a,t,r);break;case"ascii":o=l(a,t,r);break;case"binary":o=d(a,t,r);break;case"base64":o=p(a,t,r);break;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":o=h(a,t,r);break;default:throw new Error("Unknown encoding")}return o},a.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}},a.prototype.copy=function(e,t,r,o){var n=this;if(r||(r=0),o||0===o||(o=this.length),t||(t=0),o!==r&&0!==e.length&&0!==n.length){G(o>=r,"sourceEnd < sourceStart"),G(t>=0&&t=0&&r=0&&o<=n.length,"sourceEnd out of bounds"),o>this.length&&(o=this.length),e.length-ti||!a._useTypedArrays)for(var s=0;i>s;s++)e[s+t]=this[s+r];else e._set(this.subarray(r,r+i),t)}},a.prototype.slice=function(e,t){var r=this.length;if(e=q(e,r,0),t=q(t,r,r),a._useTypedArrays)return a._augment(this.subarray(e,t));for(var o=t-e,n=new a(o,void 0,!0),i=0;o>i;i++)n[i]=this[i+e];return n},a.prototype.get=function(e){return console.log(".get() is deprecated. Access using array indexes instead."),this.readUInt8(e)},a.prototype.set=function(e,t){return console.log(".set() is deprecated. Access using array indexes instead."),this.writeUInt8(e,t)},a.prototype.readUInt8=function(e,t){return t||(G(void 0!==e&&null!==e,"missing offset"),G(e=this.length?void 0:this[e]},a.prototype.readUInt16LE=function(e,t){return b(this,e,!0,t)},a.prototype.readUInt16BE=function(e,t){return b(this,e,!1,t)},a.prototype.readUInt32LE=function(e,t){return f(this,e,!0,t)},a.prototype.readUInt32BE=function(e,t){return f(this,e,!1,t)},a.prototype.readInt8=function(e,t){if(t||(G(void 0!==e&&null!==e,"missing offset"),G(e=this.length)){var r=128&this[e];return r?-1*(255-this[e]+1):this[e]}},a.prototype.readInt16LE=function(e,t){return S(this,e,!0,t)},a.prototype.readInt16BE=function(e,t){return S(this,e,!1,t)},a.prototype.readInt32LE=function(e,t){return g(this,e,!0,t)},a.prototype.readInt32BE=function(e,t){return g(this,e,!1,t)},a.prototype.readFloatLE=function(e,t){return N(this,e,!0,t)},a.prototype.readFloatBE=function(e,t){return N(this,e,!1,t)},a.prototype.readDoubleLE=function(e,t){return I(this,e,!0,t)},a.prototype.readDoubleBE=function(e,t){return I(this,e,!1,t)},a.prototype.writeUInt8=function(e,t,r){r||(G(void 0!==e&&null!==e,"missing value"),G(void 0!==t&&null!==t,"missing offset"),G(t=this.length||(this[t]=e)},a.prototype.writeUInt16LE=function(e,t,r){v(this,e,t,!0,r)},a.prototype.writeUInt16BE=function(e,t,r){v(this,e,t,!1,r)},a.prototype.writeUInt32LE=function(e,t,r){k(this,e,t,!0,r)},a.prototype.writeUInt32BE=function(e,t,r){k(this,e,t,!1,r)},a.prototype.writeInt8=function(e,t,r){r||(G(void 0!==e&&null!==e,"missing value"),G(void 0!==t&&null!==t,"missing offset"),G(t=this.length||(e>=0?this.writeUInt8(e,t,r):this.writeUInt8(255+e+1,t,r))},a.prototype.writeInt16LE=function(e,t,r){R(this,e,t,!0,r)},a.prototype.writeInt16BE=function(e,t,r){R(this,e,t,!1,r)},a.prototype.writeInt32LE=function(e,t,r){C(this,e,t,!0,r)},a.prototype.writeInt32BE=function(e,t,r){C(this,e,t,!1,r)},a.prototype.writeFloatLE=function(e,t,r){T(this,e,t,!0,r)},a.prototype.writeFloatBE=function(e,t,r){T(this,e,t,!1,r)},a.prototype.writeDoubleLE=function(e,t,r){D(this,e,t,!0,r)},a.prototype.writeDoubleBE=function(e,t,r){D(this,e,t,!1,r)},a.prototype.fill=function(e,t,r){if(e||(e=0),t||(t=0),r||(r=this.length),"string"==typeof e&&(e=e.charCodeAt(0)),G("number"==typeof e&&!isNaN(e),"value is not a number"),G(r>=t,"end < start"),r!==t&&0!==this.length){G(t>=0&&t=0&&r<=this.length,"end out of bounds");for(var a=t;r>a;a++)this[a]=e}},a.prototype.inspect=function(){for(var e=[],t=this.length,a=0;t>a;a++)if(e[a]=w(this[a]),a===r.INSPECT_MAX_BYTES){e[a+1]="...";break}return""},a.prototype.toArrayBuffer=function(){if("undefined"!=typeof Uint8Array){if(a._useTypedArrays)return new a(this).buffer;for(var e=new Uint8Array(this.length),t=0,r=e.length;r>t;t+=1)e[t]=this[t];return e.buffer}throw new Error("Buffer.toArrayBuffer not supported in this browser")};var H=a.prototype;a._augment=function(e){return e._isBuffer=!0,e._get=e.get,e._set=e.set,e.get=H.get,e.set=H.set,e.write=H.write,e.toString=H.toString,e.toLocaleString=H.toString,e.toJSON=H.toJSON,e.copy=H.copy,e.slice=H.slice,e.readUInt8=H.readUInt8,e.readUInt16LE=H.readUInt16LE,e.readUInt16BE=H.readUInt16BE,e.readUInt32LE=H.readUInt32LE,e.readUInt32BE=H.readUInt32BE,e.readInt8=H.readInt8,e.readInt16LE=H.readInt16LE,e.readInt16BE=H.readInt16BE,e.readInt32LE=H.readInt32LE,e.readInt32BE=H.readInt32BE,e.readFloatLE=H.readFloatLE,e.readFloatBE=H.readFloatBE,e.readDoubleLE=H.readDoubleLE,e.readDoubleBE=H.readDoubleBE,e.writeUInt8=H.writeUInt8,e.writeUInt16LE=H.writeUInt16LE,e.writeUInt16BE=H.writeUInt16BE,e.writeUInt32LE=H.writeUInt32LE,e.writeUInt32BE=H.writeUInt32BE,e.writeInt8=H.writeInt8,e.writeInt16LE=H.writeInt16LE,e.writeInt16BE=H.writeInt16BE,e.writeInt32LE=H.writeInt32LE,e.writeInt32BE=H.writeInt32BE,e.writeFloatLE=H.writeFloatLE,e.writeFloatBE=H.writeFloatBE,e.writeDoubleLE=H.writeDoubleLE,e.writeDoubleBE=H.writeDoubleBE,e.fill=H.fill,e.inspect=H.inspect,e.toArrayBuffer=H.toArrayBuffer,e}},{"base64-js":55,ieee754:56}],55:[function(e,t,r){var a="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";!function(e){"use strict";function t(e){var t=e.charCodeAt(0);return t===i||t===m?62:t===s||t===l?63:u>t?-1:u+10>t?t-u+26+26:p+26>t?t-p:c+26>t?t-c+26:void 0}function r(e){function r(e){c[m++]=e}var a,o,i,s,u,c;if(e.length%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var p=e.length;u="="===e.charAt(p-2)?2:"="===e.charAt(p-1)?1:0,c=new n(3*e.length/4-u),i=u>0?e.length-4:e.length;var m=0;for(a=0,o=0;i>a;a+=4,o+=3)s=t(e.charAt(a))<<18|t(e.charAt(a+1))<<12|t(e.charAt(a+2))<<6|t(e.charAt(a+3)),r((16711680&s)>>16),r((65280&s)>>8),r(255&s);return 2===u?(s=t(e.charAt(a))<<2|t(e.charAt(a+1))>>4,r(255&s)):1===u&&(s=t(e.charAt(a))<<10|t(e.charAt(a+1))<<4|t(e.charAt(a+2))>>2,r(s>>8&255),r(255&s)),c}function o(e){function t(e){return a.charAt(e)}function r(e){return t(e>>18&63)+t(e>>12&63)+t(e>>6&63)+t(63&e)}var o,n,i,s=e.length%3,u="";for(o=0,i=e.length-s;i>o;o+=3)n=(e[o]<<16)+(e[o+1]<<8)+e[o+2],u+=r(n);switch(s){case 1:n=e[e.length-1],u+=t(n>>2),u+=t(n<<4&63),u+="==";break;case 2:n=(e[e.length-2]<<8)+e[e.length-1],u+=t(n>>10),u+=t(n>>4&63),u+=t(n<<2&63),u+="="}return u}var n="undefined"!=typeof Uint8Array?Uint8Array:Array,i="+".charCodeAt(0),s="/".charCodeAt(0),u="0".charCodeAt(0),c="a".charCodeAt(0),p="A".charCodeAt(0),m="-".charCodeAt(0),l="_".charCodeAt(0);e.toByteArray=r,e.fromByteArray=o}("undefined"==typeof r?this.base64js={}:r)},{}],56:[function(e,t,r){r.read=function(e,t,r,a,o){var n,i,s=8*o-a-1,u=(1<>1,p=-7,m=r?o-1:0,l=r?-1:1,d=e[t+m];for(m+=l,n=d&(1<<-p)-1,d>>=-p,p+=s;p>0;n=256*n+e[t+m],m+=l,p-=8);for(i=n&(1<<-p)-1,n>>=-p,p+=a;p>0;i=256*i+e[t+m],m+=l,p-=8);if(0===n)n=1-c;else{if(n===u)return i?NaN:(d?-1:1)*(1/0);i+=Math.pow(2,a),n-=c}return(d?-1:1)*i*Math.pow(2,n-a)},r.write=function(e,t,r,a,o,n){var i,s,u,c=8*n-o-1,p=(1<>1,l=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,d=a?0:n-1,y=a?1:-1,h=0>t||0===t&&0>1/t?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,i=p):(i=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-i))<1&&(i--,u*=2),t+=i+m>=1?l/u:l*Math.pow(2,1-m),t*u>=2&&(i++,u/=2),i+m>=p?(s=0,i=p):i+m>=1?(s=(t*u-1)*Math.pow(2,o),i+=m):(s=t*Math.pow(2,m-1)*Math.pow(2,o),i=0));o>=8;e[r+d]=255&s,d+=y,s/=256,o-=8);for(i=i<0;e[r+d]=255&i,d+=y,i/=256,c-=8);e[r+d-y]|=128*h}},{}],57:[function(e,t,r){function a(e,t){if(e.length%s!==0){var r=e.length+(s-e.length%s);e=i.concat([e,u],r)}for(var a=[],o=t?e.readInt32BE:e.readInt32LE,n=0;nd?t=e(t):t.lengthn;n++)a[n]=54^t[n],o[n]=92^t[n];var i=e(s.concat([a,r]));return e(s.concat([o,i]))}function o(e,t){e=e||"sha1";var r=l[e],o=[],i=0;return r||n("algorithm:",e,"is not yet supported"),{update:function(e){return s.isBuffer(e)||(e=new s(e)),o.push(e),i+=e.length,this},digest:function(e){var n=s.concat(o),i=t?a(r,t,n):r(n);return o=null,e?i.toString(e):i}}}function n(){var e=[].slice.call(arguments).join(" ");throw new Error([e,"we accept pull requests","http://github.com/dominictarr/crypto-browserify"].join("\n"))}function i(e,t){for(var r in e)t(e[r],r)}var s=e("buffer").Buffer,u=e("./sha"),c=e("./sha256"),p=e("./rng"),m=e("./md5"),l={sha1:u,sha256:c,md5:m},d=64,y=new s(d);y.fill(0),r.createHash=function(e){return o(e)},r.createHmac=function(e,t){return o(e,t)},r.randomBytes=function(e,t){if(!t||!t.call)return new s(p(e));try{t.call(this,void 0,new s(p(e)))}catch(r){t(r)}},i(["createCredentials","createCipher","createCipheriv","createDecipher","createDecipheriv","createSign","createVerify","createDiffieHellman","pbkdf2"],function(e){r[e]=function(){n("sorry,",e,"is not implemented yet")}})},{"./md5":59,"./rng":60,"./sha":61,"./sha256":62,buffer:54}],59:[function(e,t,r){function a(e,t){e[t>>5]|=128<>>9<<4)+14]=t;for(var r=1732584193,a=-271733879,o=-1732584194,p=271733878,m=0;m>16)+(t>>16)+(r>>16);return a<<16|65535&r}function p(e,t){return e<>>32-t}var m=e("./helpers");t.exports=function(e){return m.hash(e,a,16)}},{"./helpers":57}],60:[function(e,t,r){!function(){var e,r,a=this;e=function(e){for(var t,t,r=new Array(e),a=0;e>a;a++)0==(3&a)&&(t=4294967296*Math.random()),r[a]=t>>>((3&a)<<3)&255;return r},a.crypto&&crypto.getRandomValues&&(r=function(e){var t=new Uint8Array(e);return crypto.getRandomValues(t),t}),t.exports=r||e}()},{}],61:[function(e,t,r){function a(e,t){e[t>>5]|=128<<24-t%32,e[(t+64>>9<<4)+15]=t;for(var r=Array(80),a=1732584193,u=-271733879,c=-1732584194,p=271733878,m=-1009589776,l=0;lS;S++){16>S?r[S]=e[l+S]:r[S]=s(r[S-3]^r[S-8]^r[S-14]^r[S-16],1);var g=i(i(s(a,5),o(S,u,c,p)),i(i(m,r[S]),n(S)));m=p,p=c,c=s(u,30),u=a,a=g}a=i(a,d),u=i(u,y),c=i(c,h),p=i(p,b),m=i(m,f)}return Array(a,u,c,p,m)}function o(e,t,r,a){return 20>e?t&r|~t&a:40>e?t^r^a:60>e?t&r|t&a|r&a:t^r^a}function n(e){return 20>e?1518500249:40>e?1859775393:60>e?-1894007588:-899497514}function i(e,t){var r=(65535&e)+(65535&t),a=(e>>16)+(t>>16)+(r>>16);return a<<16|65535&r}function s(e,t){return e<>>32-t}var u=e("./helpers");t.exports=function(e){return u.hash(e,a,20,!0)}},{"./helpers":57}],62:[function(e,t,r){var a=e("./helpers"),o=function(e,t){var r=(65535&e)+(65535&t),a=(e>>16)+(t>>16)+(r>>16);return a<<16|65535&r},n=function(e,t){return e>>>t|e<<32-t},i=function(e,t){return e>>>t},s=function(e,t,r){return e&t^~e&r},u=function(e,t,r){return e&t^e&r^t&r},c=function(e){return n(e,2)^n(e,13)^n(e,22)},p=function(e){return n(e,6)^n(e,11)^n(e,25)},m=function(e){return n(e,7)^n(e,18)^i(e,3)},l=function(e){return n(e,17)^n(e,19)^i(e,10)},d=function(e,t){var r,a,n,i,d,y,h,b,f,S,g,N,I=new Array(1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298),v=new Array(1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225),k=new Array(64);e[t>>5]|=128<<24-t%32,e[(t+64>>9<<4)+15]=t;for(var f=0;fS;S++)16>S?k[S]=e[S+f]:k[S]=o(o(o(l(k[S-2]),k[S-7]),m(k[S-15])),k[S-16]),g=o(o(o(o(b,p(d)),s(d,y,h)),I[S]),k[S]),N=o(c(r),u(r,a,n)),b=h,h=y,y=d,d=o(i,g),i=n,n=a,a=r,r=o(g,N);v[0]=o(r,v[0]),v[1]=o(a,v[1]),v[2]=o(n,v[2]),v[3]=o(i,v[3]),v[4]=o(d,v[4]),v[5]=o(y,v[5]),v[6]=o(h,v[6]),v[7]=o(b,v[7])}return v};t.exports=function(e){return a.hash(e,d,32,!0)}},{"./helpers":57}],63:[function(e,t,r){function a(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function o(e){return"function"==typeof e}function n(e){return"number"==typeof e}function i(e){return"object"==typeof e&&null!==e}function s(e){return void 0===e}t.exports=a,a.EventEmitter=a,a.prototype._events=void 0,a.prototype._maxListeners=void 0,a.defaultMaxListeners=10,a.prototype.setMaxListeners=function(e){if(!n(e)||0>e||isNaN(e))throw TypeError("n must be a positive number");return this._maxListeners=e,this},a.prototype.emit=function(e){var t,r,a,n,u,c;if(this._events||(this._events={}),"error"===e&&(!this._events.error||i(this._events.error)&&!this._events.error.length)){if(t=arguments[1],t instanceof Error)throw t;throw TypeError('Uncaught, unspecified "error" event.')}if(r=this._events[e],s(r))return!1;if(o(r))switch(arguments.length){case 1:r.call(this);break;case 2:r.call(this,arguments[1]);break;case 3:r.call(this,arguments[1],arguments[2]);break;default:for(a=arguments.length,n=new Array(a-1),u=1;a>u;u++)n[u-1]=arguments[u];r.apply(this,n)}else if(i(r)){for(a=arguments.length,n=new Array(a-1),u=1;a>u;u++)n[u-1]=arguments[u];for(c=r.slice(),a=c.length,u=0;a>u;u++)c[u].apply(this,n)}return!0},a.prototype.addListener=function(e,t){var r;if(!o(t))throw TypeError("listener must be a function");if(this._events||(this._events={}),this._events.newListener&&this.emit("newListener",e,o(t.listener)?t.listener:t),this._events[e]?i(this._events[e])?this._events[e].push(t):this._events[e]=[this._events[e],t]:this._events[e]=t,i(this._events[e])&&!this._events[e].warned){var r;r=s(this._maxListeners)?a.defaultMaxListeners:this._maxListeners,r&&r>0&&this._events[e].length>r&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace())}return this},a.prototype.on=a.prototype.addListener,a.prototype.once=function(e,t){function r(){this.removeListener(e,r),a||(a=!0,t.apply(this,arguments))}if(!o(t))throw TypeError("listener must be a function");var a=!1;return r.listener=t,this.on(e,r),this},a.prototype.removeListener=function(e,t){var r,a,n,s;if(!o(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(r=this._events[e],n=r.length,a=-1,r===t||o(r.listener)&&r.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(i(r)){for(s=n;s-->0;)if(r[s]===t||r[s].listener&&r[s].listener===t){a=s;break}if(0>a)return this;1===r.length?(r.length=0,delete this._events[e]):r.splice(a,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},a.prototype.removeAllListeners=function(e){var t,r;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(r=this._events[e],o(r))this.removeListener(e,r);else for(;r.length;)this.removeListener(e,r[r.length-1]);return delete this._events[e],this},a.prototype.listeners=function(e){var t;return t=this._events&&this._events[e]?o(this._events[e])?[this._events[e]]:this._events[e].slice():[]},a.listenerCount=function(e,t){var r;return r=e._events&&e._events[t]?o(e._events[t])?1:e._events[t].length:0}},{}],64:[function(e,t,r){"function"==typeof Object.create?t.exports=function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:t.exports=function(e,t){e.super_=t;var r=function(){};r.prototype=t.prototype,e.prototype=new r,e.prototype.constructor=e}},{}],65:[function(e,t,r){function a(){}var o=t.exports={};o.nextTick=function(){var e="undefined"!=typeof window&&window.setImmediate,t="undefined"!=typeof window&&window.postMessage&&window.addEventListener;if(e)return function(e){return window.setImmediate(e)};if(t){var r=[];return window.addEventListener("message",function(e){var t=e.source;if((t===window||null===t)&&"process-tick"===e.data&&(e.stopPropagation(),r.length>0)){var a=r.shift();a()}},!0),function(e){r.push(e),window.postMessage("process-tick","*")}}return function(e){setTimeout(e,0)}}(),o.title="browser",o.browser=!0,o.env={},o.argv=[],o.on=a,o.addListener=a,o.once=a,o.off=a,o.removeListener=a,o.removeAllListeners=a,o.emit=a,o.binding=function(e){throw new Error("process.binding is not supported")},o.cwd=function(){return"/"},o.chdir=function(e){throw new Error("process.chdir is not supported")}},{}],66:[function(e,t,r){(function(e){!function(a){function o(e){throw RangeError(w[e])}function n(e,t){for(var r=e.length;r--;)e[r]=t(e[r]);return e}function i(e,t){return n(e.split(P),t).join(".")}function s(e){for(var t,r,a=[],o=0,n=e.length;n>o;)t=e.charCodeAt(o++),t>=55296&&56319>=t&&n>o?(r=e.charCodeAt(o++),56320==(64512&r)?a.push(((1023&t)<<10)+(1023&r)+65536):(a.push(t),o--)):a.push(t);return a}function u(e){return n(e,function(e){var t="";return e>65535&&(e-=65536,t+=B(e>>>10&1023|55296),e=56320|1023&e),t+=B(e)}).join("")}function c(e){return 10>e-48?e-22:26>e-65?e-65:26>e-97?e-97:v}function p(e,t){return e+22+75*(26>e)-((0!=t)<<5)}function m(e,t,r){var a=0;for(e=r?M(e/T):e>>1,e+=M(e/t);e>L*R>>1;a+=v)e=M(e/L);return M(a+(L+1)*e/(e+C))}function l(e){var t,r,a,n,i,s,p,l,d,y,h=[],b=e.length,f=0,S=A,g=D;for(r=e.lastIndexOf(q),0>r&&(r=0),a=0;r>a;++a)e.charCodeAt(a)>=128&&o("not-basic"),h.push(e.charCodeAt(a));for(n=r>0?r+1:0;b>n;){for(i=f,s=1,p=v;n>=b&&o("invalid-input"),l=c(e.charCodeAt(n++)),(l>=v||l>M((I-f)/s))&&o("overflow"),f+=l*s,d=g>=p?k:p>=g+R?R:p-g,!(d>l);p+=v)y=v-d,s>M(I/y)&&o("overflow"),s*=y;t=h.length+1,g=m(f-i,t,0==i),M(f/t)>I-S&&o("overflow"),S+=M(f/t),f%=t,h.splice(f++,0,S)}return u(h)}function d(e){var t,r,a,n,i,u,c,l,d,y,h,b,f,S,g,N=[];for(e=s(e),b=e.length,t=A,r=0,i=D,u=0;b>u;++u)h=e[u],128>h&&N.push(B(h));for(a=n=N.length,n&&N.push(q);b>a;){for(c=I,u=0;b>u;++u)h=e[u],h>=t&&c>h&&(c=h);for(f=a+1,c-t>M((I-r)/f)&&o("overflow"),r+=(c-t)*f,t=c,u=0;b>u;++u)if(h=e[u],t>h&&++r>I&&o("overflow"),h==t){for(l=r,d=v;y=i>=d?k:d>=i+R?R:d-i,!(y>l);d+=v)g=l-y,S=v-y,N.push(B(p(y+g%S,0))),l=M(g/S);N.push(B(p(l,0))),i=m(r,f,a==n),r=0,++a}++r,++t}return N.join("")}function y(e){return i(e,function(e){return x.test(e)?l(e.slice(4).toLowerCase()):e})}function h(e){return i(e,function(e){return E.test(e)?"xn--"+d(e):e})}var b="object"==typeof r&&r,f="object"==typeof t&&t&&t.exports==b&&t,S="object"==typeof e&&e;(S.global===S||S.window===S)&&(a=S);var g,N,I=2147483647,v=36,k=1,R=26,C=38,T=700,D=72,A=128,q="-",x=/^xn--/,E=/[^ -~]/,P=/\x2E|\u3002|\uFF0E|\uFF61/g,w={overflow:"Overflow: input needs wider integers to process","not-basic":"Illegal input >= 0x80 (not a basic code point)","invalid-input":"Invalid input"},L=v-k,M=Math.floor,B=String.fromCharCode;if(g={version:"1.2.4",ucs2:{decode:s,encode:u},decode:l,encode:d,toASCII:h,toUnicode:y},"function"==typeof define&&"object"==typeof define.amd&&define.amd)define("punycode",function(){return g});else if(b&&!b.nodeType)if(f)f.exports=g;else for(N in g)g.hasOwnProperty(N)&&(b[N]=g[N]);else a.punycode=g}(this)}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],67:[function(e,t,r){"use strict";function a(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.exports=function(e,t,r,n){t=t||"&",r=r||"=";var i={};if("string"!=typeof e||0===e.length)return i;var s=/\+/g;e=e.split(t);var u=1e3;n&&"number"==typeof n.maxKeys&&(u=n.maxKeys);var c=e.length;u>0&&c>u&&(c=u);for(var p=0;c>p;++p){var m,l,d,y,h=e[p].replace(s,"%20"),b=h.indexOf(r);b>=0?(m=h.substr(0,b),l=h.substr(b+1)):(m=h,l=""),d=decodeURIComponent(m),y=decodeURIComponent(l),a(i,d)?o(i[d])?i[d].push(y):i[d]=[i[d],y]:i[d]=y}return i};var o=Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)}},{}],68:[function(e,t,r){"use strict";function a(e,t){if(e.map)return e.map(t);for(var r=[],a=0;a",'"',"`"," ","\r","\n"," "],b=["{","}","|","\\","^","`"].concat(h),f=["'"].concat(b),S=["%","/","?",";","#"].concat(f),g=["/","?","#"],N=255,I=/^[a-z0-9A-Z_-]{0,63}$/,v=/^([a-z0-9A-Z_-]{0,63})(.*)$/,k={javascript:!0,"javascript:":!0},R={javascript:!0,"javascript:":!0},C={http:!0,https:!0,ftp:!0,gopher:!0,file:!0,"http:":!0,"https:":!0,"ftp:":!0,"gopher:":!0,"file:":!0},T=e("querystring");a.prototype.parse=function(e,t,r){if(!u(e))throw new TypeError("Parameter 'url' must be a string, not "+typeof e);var a=e;a=a.trim();var o=d.exec(a);if(o){o=o[0];var n=o.toLowerCase();this.protocol=n,a=a.substr(o.length)}if(r||o||a.match(/^\/\/[^@\/]+@[^@\/]+/)){var i="//"===a.substr(0,2);!i||o&&R[o]||(a=a.substr(2),this.slashes=!0)}if(!R[o]&&(i||o&&!C[o])){for(var s=-1,c=0;cp)&&(s=p)}var m,y;y=-1===s?a.lastIndexOf("@"):a.lastIndexOf("@",s),-1!==y&&(m=a.slice(0,y),a=a.slice(y+1),this.auth=decodeURIComponent(m)),s=-1;for(var c=0;cp)&&(s=p)}-1===s&&(s=a.length),this.host=a.slice(0,s),a=a.slice(s),this.parseHost(),this.hostname=this.hostname||"";var h="["===this.hostname[0]&&"]"===this.hostname[this.hostname.length-1];if(!h)for(var b=this.hostname.split(/\./),c=0,D=b.length;D>c;c++){var A=b[c];if(A&&!A.match(I)){for(var q="",x=0,E=A.length;E>x;x++)q+=A.charCodeAt(x)>127?"x":A[x];if(!q.match(I)){var P=b.slice(0,c),w=b.slice(c+1),L=A.match(v);L&&(P.push(L[1]),w.unshift(L[2])),w.length&&(a="/"+w.join(".")+a),this.hostname=P.join(".");break}}}if(this.hostname.length>N?this.hostname="":this.hostname=this.hostname.toLowerCase(),!h){for(var M=this.hostname.split("."),B=[],c=0;cc;c++){var z=f[c],F=encodeURIComponent(z);F===z&&(F=escape(z)),a=a.split(z).join(F)}var O=a.indexOf("#");-1!==O&&(this.hash=a.substr(O),a=a.slice(0,O));var G=a.indexOf("?");if(-1!==G?(this.search=a.substr(G),this.query=a.substr(G+1),t&&(this.query=T.parse(this.query)),a=a.slice(0,G)):t&&(this.search="",this.query={}),a&&(this.pathname=a),C[n]&&this.hostname&&!this.pathname&&(this.pathname="/"),this.pathname||this.search){var _=this.pathname||"",U=this.search||"";this.path=_+U}return this.href=this.format(),this},a.prototype.format=function(){var e=this.auth||"";
+e&&(e=encodeURIComponent(e),e=e.replace(/%3A/i,":"),e+="@");var t=this.protocol||"",r=this.pathname||"",a=this.hash||"",o=!1,n="";this.host?o=e+this.host:this.hostname&&(o=e+(-1===this.hostname.indexOf(":")?this.hostname:"["+this.hostname+"]"),this.port&&(o+=":"+this.port)),this.query&&c(this.query)&&Object.keys(this.query).length&&(n=T.stringify(this.query));var i=this.search||n&&"?"+n||"";return t&&":"!==t.substr(-1)&&(t+=":"),this.slashes||(!t||C[t])&&o!==!1?(o="//"+(o||""),r&&"/"!==r.charAt(0)&&(r="/"+r)):o||(o=""),a&&"#"!==a.charAt(0)&&(a="#"+a),i&&"?"!==i.charAt(0)&&(i="?"+i),r=r.replace(/[?#]/g,function(e){return encodeURIComponent(e)}),i=i.replace("#","%23"),t+o+r+i+a},a.prototype.resolve=function(e){return this.resolveObject(o(e,!1,!0)).format()},a.prototype.resolveObject=function(e){if(u(e)){var t=new a;t.parse(e,!1,!0),e=t}var r=new a;if(Object.keys(this).forEach(function(e){r[e]=this[e]},this),r.hash=e.hash,""===e.href)return r.href=r.format(),r;if(e.slashes&&!e.protocol)return Object.keys(e).forEach(function(t){"protocol"!==t&&(r[t]=e[t])}),C[r.protocol]&&r.hostname&&!r.pathname&&(r.path=r.pathname="/"),r.href=r.format(),r;if(e.protocol&&e.protocol!==r.protocol){if(!C[e.protocol])return Object.keys(e).forEach(function(t){r[t]=e[t]}),r.href=r.format(),r;if(r.protocol=e.protocol,e.host||R[e.protocol])r.pathname=e.pathname;else{for(var o=(e.pathname||"").split("/");o.length&&!(e.host=o.shift()););e.host||(e.host=""),e.hostname||(e.hostname=""),""!==o[0]&&o.unshift(""),o.length<2&&o.unshift(""),r.pathname=o.join("/")}if(r.search=e.search,r.query=e.query,r.host=e.host||"",r.auth=e.auth,r.hostname=e.hostname||e.host,r.port=e.port,r.pathname||r.search){var n=r.pathname||"",i=r.search||"";r.path=n+i}return r.slashes=r.slashes||e.slashes,r.href=r.format(),r}var s=r.pathname&&"/"===r.pathname.charAt(0),c=e.host||e.pathname&&"/"===e.pathname.charAt(0),l=c||s||r.host&&e.pathname,d=l,y=r.pathname&&r.pathname.split("/")||[],o=e.pathname&&e.pathname.split("/")||[],h=r.protocol&&!C[r.protocol];if(h&&(r.hostname="",r.port=null,r.host&&(""===y[0]?y[0]=r.host:y.unshift(r.host)),r.host="",e.protocol&&(e.hostname=null,e.port=null,e.host&&(""===o[0]?o[0]=e.host:o.unshift(e.host)),e.host=null),l=l&&(""===o[0]||""===y[0])),c)r.host=e.host||""===e.host?e.host:r.host,r.hostname=e.hostname||""===e.hostname?e.hostname:r.hostname,r.search=e.search,r.query=e.query,y=o;else if(o.length)y||(y=[]),y.pop(),y=y.concat(o),r.search=e.search,r.query=e.query;else if(!m(e.search)){if(h){r.hostname=r.host=y.shift();var b=r.host&&r.host.indexOf("@")>0?r.host.split("@"):!1;b&&(r.auth=b.shift(),r.host=r.hostname=b.shift())}return r.search=e.search,r.query=e.query,p(r.pathname)&&p(r.search)||(r.path=(r.pathname?r.pathname:"")+(r.search?r.search:"")),r.href=r.format(),r}if(!y.length)return r.pathname=null,r.search?r.path="/"+r.search:r.path=null,r.href=r.format(),r;for(var f=y.slice(-1)[0],S=(r.host||e.host)&&("."===f||".."===f)||""===f,g=0,N=y.length;N>=0;N--)f=y[N],"."==f?y.splice(N,1):".."===f?(y.splice(N,1),g++):g&&(y.splice(N,1),g--);if(!l&&!d)for(;g--;g)y.unshift("..");!l||""===y[0]||y[0]&&"/"===y[0].charAt(0)||y.unshift(""),S&&"/"!==y.join("/").substr(-1)&&y.push("");var I=""===y[0]||y[0]&&"/"===y[0].charAt(0);if(h){r.hostname=r.host=I?"":y.length?y.shift():"";var b=r.host&&r.host.indexOf("@")>0?r.host.split("@"):!1;b&&(r.auth=b.shift(),r.host=r.hostname=b.shift())}return l=l||r.host&&y.length,l&&!I&&y.unshift(""),y.length?r.pathname=y.join("/"):(r.pathname=null,r.path=null),p(r.pathname)&&p(r.search)||(r.path=(r.pathname?r.pathname:"")+(r.search?r.search:"")),r.auth=e.auth||r.auth,r.slashes=r.slashes||e.slashes,r.href=r.format(),r},a.prototype.parseHost=function(){var e=this.host,t=y.exec(e);t&&(t=t[0],":"!==t&&(this.port=t.substr(1)),e=e.substr(0,e.length-t.length)),e&&(this.hostname=e)}},{punycode:66,querystring:69}],71:[function(e,t,r){t.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},{}],72:[function(e,t,r){(function(t,a){function o(e,t){var a={seen:[],stylize:i};return arguments.length>=3&&(a.depth=arguments[2]),arguments.length>=4&&(a.colors=arguments[3]),h(t)?a.showHidden=t:t&&r._extend(a,t),I(a.showHidden)&&(a.showHidden=!1),I(a.depth)&&(a.depth=2),I(a.colors)&&(a.colors=!1),I(a.customInspect)&&(a.customInspect=!0),a.colors&&(a.stylize=n),u(a,e,a.depth)}function n(e,t){var r=o.styles[t];return r?"["+o.colors[r][0]+"m"+e+"["+o.colors[r][1]+"m":e}function i(e,t){return e}function s(e){var t={};return e.forEach(function(e,r){t[e]=!0}),t}function u(e,t,a){if(e.customInspect&&t&&T(t.inspect)&&t.inspect!==r.inspect&&(!t.constructor||t.constructor.prototype!==t)){var o=t.inspect(a,e);return g(o)||(o=u(e,o,a)),o}var n=c(e,t);if(n)return n;var i=Object.keys(t),h=s(i);if(e.showHidden&&(i=Object.getOwnPropertyNames(t)),C(t)&&(i.indexOf("message")>=0||i.indexOf("description")>=0))return p(t);if(0===i.length){if(T(t)){var b=t.name?": "+t.name:"";return e.stylize("[Function"+b+"]","special")}if(v(t))return e.stylize(RegExp.prototype.toString.call(t),"regexp");if(R(t))return e.stylize(Date.prototype.toString.call(t),"date");if(C(t))return p(t)}var f="",S=!1,N=["{","}"];if(y(t)&&(S=!0,N=["[","]"]),T(t)){var I=t.name?": "+t.name:"";f=" [Function"+I+"]"}if(v(t)&&(f=" "+RegExp.prototype.toString.call(t)),R(t)&&(f=" "+Date.prototype.toUTCString.call(t)),C(t)&&(f=" "+p(t)),0===i.length&&(!S||0==t.length))return N[0]+f+N[1];if(0>a)return v(t)?e.stylize(RegExp.prototype.toString.call(t),"regexp"):e.stylize("[Object]","special");e.seen.push(t);var k;return k=S?m(e,t,a,h,i):i.map(function(r){return l(e,t,a,h,r,S)}),e.seen.pop(),d(k,f,N)}function c(e,t){if(I(t))return e.stylize("undefined","undefined");if(g(t)){var r="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(r,"string")}return S(t)?e.stylize(""+t,"number"):h(t)?e.stylize(""+t,"boolean"):b(t)?e.stylize("null","null"):void 0}function p(e){return"["+Error.prototype.toString.call(e)+"]"}function m(e,t,r,a,o){for(var n=[],i=0,s=t.length;s>i;++i)E(t,String(i))?n.push(l(e,t,r,a,String(i),!0)):n.push("");return o.forEach(function(o){o.match(/^\d+$/)||n.push(l(e,t,r,a,o,!0))}),n}function l(e,t,r,a,o,n){var i,s,c;if(c=Object.getOwnPropertyDescriptor(t,o)||{value:t[o]},c.get?s=c.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):c.set&&(s=e.stylize("[Setter]","special")),E(a,o)||(i="["+o+"]"),s||(e.seen.indexOf(c.value)<0?(s=b(r)?u(e,c.value,null):u(e,c.value,r-1),s.indexOf("\n")>-1&&(s=n?s.split("\n").map(function(e){return" "+e}).join("\n").substr(2):"\n"+s.split("\n").map(function(e){return" "+e}).join("\n"))):s=e.stylize("[Circular]","special")),I(i)){if(n&&o.match(/^\d+$/))return s;i=JSON.stringify(""+o),i.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(i=i.substr(1,i.length-2),i=e.stylize(i,"name")):(i=i.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),i=e.stylize(i,"string"))}return i+": "+s}function d(e,t,r){var a=0,o=e.reduce(function(e,t){return a++,t.indexOf("\n")>=0&&a++,e+t.replace(/\u001b\[\d\d?m/g,"").length+1},0);return o>60?r[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+r[1]:r[0]+t+" "+e.join(", ")+" "+r[1]}function y(e){return Array.isArray(e)}function h(e){return"boolean"==typeof e}function b(e){return null===e}function f(e){return null==e}function S(e){return"number"==typeof e}function g(e){return"string"==typeof e}function N(e){return"symbol"==typeof e}function I(e){return void 0===e}function v(e){return k(e)&&"[object RegExp]"===A(e)}function k(e){return"object"==typeof e&&null!==e}function R(e){return k(e)&&"[object Date]"===A(e)}function C(e){return k(e)&&("[object Error]"===A(e)||e instanceof Error)}function T(e){return"function"==typeof e}function D(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||"undefined"==typeof e}function A(e){return Object.prototype.toString.call(e)}function q(e){return 10>e?"0"+e.toString(10):e.toString(10)}function x(){var e=new Date,t=[q(e.getHours()),q(e.getMinutes()),q(e.getSeconds())].join(":");return[e.getDate(),M[e.getMonth()],t].join(" ")}function E(e,t){return Object.prototype.hasOwnProperty.call(e,t)}var P=/%[sdj%]/g;r.format=function(e){if(!g(e)){for(var t=[],r=0;r=n)return e;switch(e){case"%s":return String(a[r++]);case"%d":return Number(a[r++]);case"%j":try{return JSON.stringify(a[r++])}catch(t){return"[Circular]"}default:return e}}),s=a[r];n>r;s=a[++r])i+=b(s)||!k(s)?" "+s:" "+o(s);return i},r.deprecate=function(e,o){function n(){if(!i){if(t.throwDeprecation)throw new Error(o);t.traceDeprecation?console.trace(o):console.error(o),i=!0}return e.apply(this,arguments)}if(I(a.process))return function(){return r.deprecate(e,o).apply(this,arguments)};if(t.noDeprecation===!0)return e;var i=!1;return n};var w,L={};r.debuglog=function(e){if(I(w)&&(w=t.env.NODE_DEBUG||""),e=e.toUpperCase(),!L[e])if(new RegExp("\\b"+e+"\\b","i").test(w)){var a=t.pid;L[e]=function(){var t=r.format.apply(r,arguments);console.error("%s %d: %s",e,a,t)}}else L[e]=function(){};return L[e]},r.inspect=o,o.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},o.styles={special:"cyan",number:"yellow","boolean":"yellow",undefined:"grey","null":"bold",string:"green",date:"magenta",regexp:"red"},r.isArray=y,r.isBoolean=h,r.isNull=b,r.isNullOrUndefined=f,r.isNumber=S,r.isString=g,r.isSymbol=N,r.isUndefined=I,r.isRegExp=v,r.isObject=k,r.isDate=R,r.isError=C,r.isFunction=T,r.isPrimitive=D,r.isBuffer=e("./support/isBuffer");var M=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];r.log=function(){console.log("%s - %s",x(),r.format.apply(r,arguments))},r.inherits=e("inherits"),r._extend=function(e,t){if(!t||!k(t))return e;for(var r=Object.keys(t),a=r.length;a--;)e[r[a]]=t[r[a]];return e}}).call(this,e("FWaASH"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":71,FWaASH:65,inherits:64}],73:[function(e,t,r){(function(){var r,a;a=e("./XMLFragment"),r=function(){function e(e,t,r){var o,n,i;if(this.children=[],this.rootObject=null,this.is(e,"Object")&&(i=[e,t],t=i[0],r=i[1],e=null),null!=e&&(e=""+e||"",null==t&&(t={version:"1.0"})),null!=t&&null==t.version)throw new Error("Version number is required");if(null!=t){if(t.version=""+t.version||"",!t.version.match(/1\.[0-9]+/))throw new Error("Invalid version number: "+t.version);if(o={version:t.version},null!=t.encoding){if(t.encoding=""+t.encoding||"",!t.encoding.match(/[A-Za-z](?:[A-Za-z0-9._-]|-)*/))throw new Error("Invalid encoding: "+t.encoding);o.encoding=t.encoding}null!=t.standalone&&(o.standalone=t.standalone?"yes":"no"),n=new a(this,"?xml",o),this.children.push(n)}null!=r&&(o={},null!=e&&(o.name=e),null!=r.ext&&(r.ext=""+r.ext||"",o.ext=r.ext),n=new a(this,"!DOCTYPE",o),this.children.push(n)),null!=e&&this.begin(e)}return e.prototype.begin=function(t,r,o){var n,i;if(null==t)throw new Error("Root element needs a name");return this.rootObject&&(this.children=[],this.rootObject=null),null!=r?(n=new e(t,r,o),n.root()):(t=""+t||"",i=new a(this,t,{}),i.isRoot=!0,i.documentObject=this,this.children.push(i),this.rootObject=i,i)},e.prototype.root=function(){return this.rootObject},e.prototype.end=function(e){return toString(e)},e.prototype.toString=function(e){var t,r,a,o,n;for(r="",n=this.children,a=0,o=n.length;o>a;a++)t=n[a],r+=t.toString(e);return r},e.prototype.is=function(e,t){var r;return r=Object.prototype.toString.call(e).slice(8,-1),null!=e&&r===t},e}(),t.exports=r}).call(this)},{"./XMLFragment":74}],74:[function(e,t,r){(function(){var e,r={}.hasOwnProperty;e=function(){function e(e,t,r,a){this.isRoot=!1,this.documentObject=null,this.parent=e,this.name=t,this.attributes=r,this.value=a,this.children=[]}return e.prototype.element=function(t,a,o){var n,i,s,u,c;if(null==t)throw new Error("Missing element name");t=""+t||"",this.assertLegalChar(t),null==a&&(a={}),this.is(a,"String")&&this.is(o,"Object")?(u=[o,a],a=u[0],o=u[1]):this.is(a,"String")&&(c=[{},a],a=c[0],o=c[1]);for(i in a)r.call(a,i)&&(s=a[i],s=""+s||"",a[i]=this.escape(s));return n=new e(this,t,a),null!=o&&(o=""+o||"",o=this.escape(o),this.assertLegalChar(o),n.raw(o)),this.children.push(n),n},e.prototype.insertBefore=function(t,a,o){var n,i,s,u,c,p;if(this.isRoot)throw new Error("Cannot insert elements at root level");if(null==t)throw new Error("Missing element name");t=""+t||"",this.assertLegalChar(t),null==a&&(a={}),this.is(a,"String")&&this.is(o,"Object")?(c=[o,a],a=c[0],o=c[1]):this.is(a,"String")&&(p=[{},a],a=p[0],o=p[1]);for(s in a)r.call(a,s)&&(u=a[s],u=""+u||"",a[s]=this.escape(u));return n=new e(this.parent,t,a),null!=o&&(o=""+o||"",o=this.escape(o),this.assertLegalChar(o),n.raw(o)),i=this.parent.children.indexOf(this),this.parent.children.splice(i,0,n),n},e.prototype.insertAfter=function(t,a,o){var n,i,s,u,c,p;if(this.isRoot)throw new Error("Cannot insert elements at root level");if(null==t)throw new Error("Missing element name");t=""+t||"",this.assertLegalChar(t),null==a&&(a={}),this.is(a,"String")&&this.is(o,"Object")?(c=[o,a],a=c[0],o=c[1]):this.is(a,"String")&&(p=[{},a],a=p[0],o=p[1]);for(s in a)r.call(a,s)&&(u=a[s],u=""+u||"",a[s]=this.escape(u));return n=new e(this.parent,t,a),null!=o&&(o=""+o||"",o=this.escape(o),this.assertLegalChar(o),n.raw(o)),i=this.parent.children.indexOf(this),this.parent.children.splice(i+1,0,n),n},e.prototype.remove=function(){var e,t;if(this.isRoot)throw new Error("Cannot remove the root element");return e=this.parent.children.indexOf(this),[].splice.apply(this.parent.children,[e,e-e+1].concat(t=[])),t,this.parent},e.prototype.text=function(t){var r;if(null==t)throw new Error("Missing element text");return t=""+t||"",t=this.escape(t),this.assertLegalChar(t),r=new e(this,"",{},t),this.children.push(r),this},e.prototype.cdata=function(t){var r;if(null==t)throw new Error("Missing CDATA text");if(t=""+t||"",this.assertLegalChar(t),t.match(/]]>/))throw new Error("Invalid CDATA text: "+t);return r=new e(this,"",{},""),this.children.push(r),this},e.prototype.comment=function(t){var r;if(null==t)throw new Error("Missing comment text");if(t=""+t||"",t=this.escape(t),this.assertLegalChar(t),t.match(/--/))throw new Error("Comment text cannot contain double-hypen: "+t);return r=new e(this,"",{},""),this.children.push(r),this},e.prototype.raw=function(t){var r;if(null==t)throw new Error("Missing raw text");return t=""+t||"",r=new e(this,"",{},t),this.children.push(r),this},e.prototype.up=function(){if(this.isRoot)throw new Error("This node has no parent. Use doc() if you need to get the document object.");return this.parent},e.prototype.root=function(){var e;if(this.isRoot)return this;for(e=this.parent;!e.isRoot;)e=e.parent;return e},e.prototype.document=function(){return this.root().documentObject},e.prototype.end=function(e){return this.document().toString(e)},e.prototype.prev=function(){var e;if(this.isRoot)throw new Error("Root node has no siblings");if(e=this.parent.children.indexOf(this),1>e)throw new Error("Already at the first node");return this.parent.children[e-1]},e.prototype.next=function(){var e;if(this.isRoot)throw new Error("Root node has no siblings");if(e=this.parent.children.indexOf(this),-1===e||e===this.parent.children.length-1)throw new Error("Already at the last node");return this.parent.children[e+1]},e.prototype.clone=function(t){var r;return r=new e(this.parent,this.name,this.attributes,this.value),t&&this.children.forEach(function(e){var a;return a=e.clone(t),a.parent=r,r.children.push(a)}),r},e.prototype.importXMLBuilder=function(e){var t;return t=e.root().clone(!0),t.parent=this,this.children.push(t),t.isRoot=!1,this},e.prototype.attribute=function(e,t){var r;if(null==e)throw new Error("Missing attribute name");if(null==t)throw new Error("Missing attribute value");return e=""+e||"",t=""+t||"",null==(r=this.attributes)&&(this.attributes={}),this.attributes[e]=this.escape(t),this},e.prototype.removeAttribute=function(e){if(null==e)throw new Error("Missing attribute name");return e=""+e||"",delete this.attributes[e],this},e.prototype.toString=function(e,t){var r,a,o,n,i,s,u,c,p,m,l,d;s=null!=e&&e.pretty||!1,n=null!=e&&e.indent||" ",i=null!=e&&e.newline||"\n",t||(t=0),c=new Array(t+1).join(n),u="",s&&(u+=c),u+=null==this.value?"<"+this.name:""+this.value,l=this.attributes;for(r in l)a=l[r],u+="!DOCTYPE"===this.name?" "+a:" "+r+'="'+a+'"';if(0===this.children.length)null==this.value&&(u+="?xml"===this.name?"?>":"!DOCTYPE"===this.name?">":"/>"),s&&(u+=i);else if(s&&1===this.children.length&&this.children[0].value)u+=">",u+=this.children[0].value,u+="",u+=i;else{for(u+=">",s&&(u+=i),d=this.children,p=0,m=d.length;m>p;p++)o=d[p],u+=o.toString(e,t+1);s&&(u+=c),u+="",s&&(u+=i)}return u},e.prototype.escape=function(e){return e.replace(/&/g,"&").replace(//g,">").replace(/'/g,"'").replace(/"/g,""")},e.prototype.assertLegalChar=function(e){var t,r;if(t=/[\u0000-\u0008\u000B-\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE-\uFFFF]/,r=e.match(t))throw new Error("Invalid character ("+r+") in string: "+e)},e.prototype.is=function(e,t){var r;return r=Object.prototype.toString.call(e).slice(8,-1),null!=e&&r===t},e.prototype.ele=function(e,t,r){return this.element(e,t,r)},e.prototype.txt=function(e){return this.text(e)},e.prototype.dat=function(e){return this.cdata(e)},e.prototype.att=function(e,t){return this.attribute(e,t)},e.prototype.com=function(e){return this.comment(e)},e.prototype.doc=function(){return this.document()},e.prototype.e=function(e,t,r){return this.element(e,t,r)},e.prototype.t=function(e){return this.text(e)},e.prototype.d=function(e){return this.cdata(e)},e.prototype.a=function(e,t){return this.attribute(e,t)},e.prototype.c=function(e){return this.comment(e)},e.prototype.r=function(e){return this.raw(e)},e.prototype.u=function(){return this.up()},e}(),t.exports=e}).call(this)},{}],75:[function(e,t,r){(function(){var r;r=e("./XMLBuilder"),t.exports.create=function(e,t,a){return null!=e?new r(e,t,a).root():new r}}).call(this)},{"./XMLBuilder":73}]},{},[1]);