export.max.mjs

/*

JSON-stat Javascript Toolkit v. 0.13.13 (JSON-stat v. 2.0 ready) (ES6 module)
https://json-stat.com
https://github.com/badosa/JSON-stat

Copyright 2019 Xavier Badosa (https://xavierbadosa.com)

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.

*/

/* jshint newcap:false */

function isArray(o) {
	return Object.prototype.toString.call(o) === "[object Array]";
}
function jsonstat(o){
	//nodejs xhr gone
	var
		//sparse cube (value or status)
		//If only one value/status is provided it means same for all (if more than one, then missing values/statuses are nulled).
		normalize=function(s,len){
			var ret=[], l;

			if(typeof s==="string"){
				s=[s];
			}
			if(isArray(s)){
				if(s.length===len){ //normal case
					return s;
				}
				if(s.length===1){ //all obs same status
					for(l=0; l<len; l++){
						ret.push(s[0]);
					}
					return ret;
				}
			}

			//It's an object (sparse cube) or an incomplete array that must be filled with nulls
			for(l=0; l<len; l++){
				var e=(typeof s[l]==="undefined") ? null: s[l];
				ret.push(e);
			}
			return ret;
		},
		//For native dimension responses
		dimSize=function(cat){
			var c=( typeof cat.index==="undefined" ) ? cat.label : cat.index;
			return ( isArray(c) ) ? c.length : Object.keys(c).length;
		},
		ot, prop, ilen, i
	;

	this.length=0;
	this.id=[];
	if (o===null || typeof o==="undefined"){
		return;
	}

	this.class=o.class || "bundle";
	switch(this.class){
		case "bundle" : //Real bundle, or URL (bundle, dataset, collection, dimension), or error [nodejs: can't be a URL actually. Kept for symmetry.]
			var arr=[], ds=0;
			this.error=null;
			this.length=0;

			//URI assumed
			if(typeof o==="string"){
				console.log("Module does not accept a URI string, must be an object."); //nodejs
			}

			// Wrong input object (nodejs)
			if(o===null || typeof o!=="object"){
				this.class=null;
				return;
			}

			// Explicit error
			if(o.hasOwnProperty("error")){
				this.error=o.error;
				return;
			}

			//When o is a URI, class won't be set before the request
			//and it will enter the bundle case: once we have a response
			//if class is dataset we redirect to case "dataset". 0.7.5
			//[nodejs: can't be a URL actually. Kept for symmetry.]
			if(o.class==="dataset" || o.class==="collection" || o.class==="dimension"){
				return JSONstat(o);
			}

			for (prop in o){
				ds++;
				/* If sparse cube, we can't rely on value to check size
				if (isArray(o[prop].value)){
					a++;
				}
				*/
				arr.push(prop);
			}
			this.__tree__=o;
			this.length=ds;
			this.id=arr;
		break;

		case "dataset" :
			//It's a native response of class "dataset"
			if (!o.hasOwnProperty("__tree__")){
				this.__tree__=ot=o;
			}else{
				this.__tree__=ot=o.__tree__;
			}

			this.label=ot.label || null;
			this.note=ot.note || null; //v.0.7.0
			this.link=ot.link || null; //v.0.7.0
			this.href=ot.href || null; //v.0.7.0
			this.updated=ot.updated || null;
			this.source=ot.source || null; //v.0.5.0
			this.extension=ot.extension || null; //v.0.7.0

			//Sparse cube (If toTable() removed, this logic can be moved inside Data()
			//which is more efficient when retrieving a single value/status.
			var
				s,
				dsize=0, //data size
				size=ot.size || (ot.dimension && ot.dimension.size) //0.9.0 (JSON-stat 2.0)
			;

			this.size=size; //0.10.0

			if(ot.hasOwnProperty("value") && isArray(ot.value)){
				dsize=ot.value.length;
			}else{
				var length=1;
				for(s=size.length; s--;){
					length*=size[s];
				}
				dsize=length;
			}

			this.value=normalize(ot.value,dsize);
			this.status=(!(ot.hasOwnProperty("status"))) ? null : normalize(ot.status,dsize);

			// if dimensions are defined, id and size arrays are required and must have equal length
			if (ot.hasOwnProperty("dimension")){
				var
					otd=ot.dimension,
					otr=ot.role || (!ot.version && otd.role) || null, //0.9.0 (JSON-stat 2.0) - Added check for version 0.9.1: role only valid on dimension if no version
					otdi=ot.id || otd.id, //0.9.0 (JSON-stat 2.0)
					otdl=size.length,
					createRole=function(s){
						if(!otr.hasOwnProperty(s)){
							otr[s]=null;
						}
					}
				;

				if (
					!(isArray(otdi)) ||
					!(isArray(size)) ||
					otdi.length!=otdl
					){
					return;
				}

				this.length=otdl;
				this.id=otdi;

				if(otr){
					createRole("time");
					createRole("geo");
					createRole("metric");
					createRole("classification");
				}

				//If role not null, leave it as it is but add a classification role if it's null. Added in 0.7.1
				if (otr && otr.classification===null){
					var
						gmt=[],
						roles=["time","geo","metric"],
						//Replace with polyfill of Array.indefOf at some point?
						inArray=function(e, a){
							for(var i=a.length;i--;){
								if(e===a[i]){
									return true;
								}
							}
							return false;
						}
					;

					for(s=0; s<3; s++){
						var rr=otr[roles[s]];
						if(rr!==null){
							gmt=gmt.concat(rr);
						}
					}

					otr.classification=[];

					//not inverse looping to preserve dim order
					for(s=0; s<otdl; s++){
						if(!inArray(otdi[s], gmt)){
							otr.classification.push(otdi[s]);
						}
					}

					if(otr.classification.length===0){
						otr.classification=null;
					}
				}

				this.role=otr;

				this.n=dsize; //number of obs added in 0.4.2

				//If only one category, no need of index according to the spec
				//This actually will recreate an index even if there are more than one category and no index is provided
				//but because there's no guarantee that properties are retrieved in a particular order (even though it worked in Ch,FF,IE,Sa,Op)
				//(Main problem in fact is that you don't have to WRITE them in a particular order) the original order of categories could
				//theoretically be changed. That's why the procedure will only be valid when there's only one category.
				//Note: If toTable() is removed it would make more sense to move this loop inside Dimension() as it is not needed for Data().
				for(var d=0, len=this.length; d<len; d++){
					if (!(otd[otdi[d]].category.hasOwnProperty("index"))){
						var c=0;
						otd[otdi[d]].category.index={};
						for (prop in otd[otdi[d]].category.label){
							otd[otdi[d]].category.index[prop]=c++;
						}
					}else{
						// If index is array instead of object convert into object
						// That is: we normalize it (instead of defining a function depending on
						// index type to read categories -maybe in the future when indexOf can be
						// assumed for all browsers and default is array instead of object-)
						if(isArray(otd[otdi[d]].category.index)){
							var oindex={}, index=otd[otdi[d]].category.index;

							ilen=index.length;
							for (i=0; i<ilen; i++){
								oindex[index[i]]=i;
							}
							otd[otdi[d]].category.index=oindex;
						}
					}
				}
			}else{
				this.length=0;
			}
		break;
		case "dimension" :
			//It's a native response of class "dimension"
			if( !o.hasOwnProperty("__tree__") ){
				return JSONstat({
						"version": "2.0",
						"class": "dataset",
						"dimension": {
							d: o
						},
						"id": ["d"],
						"size": [ dimSize(o.category) ],
						"value": [ null ]
					}).Dimension(0)
				;
			}

			ot=o.__tree__;
			var cats=[], otc=ot.category;
			if(
				!ot.hasOwnProperty("category") //Already tested in the Dimension() / Category() ? method
				){
				return;
			}

			//If no category label, use IDs
			if(!otc.hasOwnProperty("label")){
				otc.label={};
				for (prop in otc.index){
					otc.label[prop]=prop;
				}
			}

			//Array conversion
			for (prop in otc.index){
				cats[otc.index[prop]]=prop; //0.4.3 cats.push(prop) won't do because order not in control when index was originally an array and was converted to object by the Toolkit.
			}

			this.__tree__=ot;
			//When no dimension label, undefined is returned.
			//Discarded options: null / dim
			this.label=ot.label || null;
			this.note=ot.note || null; //v.0.7.0
			this.link=ot.link || null; //v.0.7.0
			this.href=ot.href || null; //v.0.7.0
			this.id=cats;
			this.length=cats.length;
			this.role=o.role;
			this.hierarchy=otc.hasOwnProperty("child"); //0.6.0
			this.extension=ot.extension || null; //v.0.7.0
		break;
		case "category" :
			var par=o.child;

			//0.5.0 changed. It was autoreference: id. And length was 0 always
			this.id=par;
			this.length=(par===null) ? 0 : par.length;

			this.index=o.index;
			this.label=o.label;
			this.note=o.note || null; //v.0.7.0

			this.unit=o.unit; //v.0.5.0
			this.coordinates=o.coord; //v.0.5.0
		break;
		case "collection" : //0.8.0
			this.length=0;
			this.label=o.label || null;
			this.note=o.note || null;
			this.link=o.link || null;
			this.href=o.href || null;
			this.updated=o.updated || null;
			this.source=o.source || null;
			this.extension=o.extension || null;

			if(this.link!==null && o.link.item){
				var item=o.link.item;

				this.length=( isArray(item) ) ? item.length : 0;
				if(this.length){
					for(i=0; i<this.length; i++){
						this.id[i]=item[i].href;
					}
				}
			}
		break;
	}
}

jsonstat.prototype.Item=function(o){ //0.8.0
	if (this===null || this.class!=="collection" || !this.length){
		return null;
	}

	if(typeof o==="number"){
		if(o>this.length || o<0){
			return null;
		}
		return this.link.item[o];
	}

	var ret=[], func;

	if(typeof o==="object"){
		//Do not accept invalid objects (0.8.3)
		if(!o.class && !o.follow){
			return null;
		}
		if(o.class){
			//0.9.3 Embedded currently only valid with datasets (and JSON-stat 2.0)
			if(o.class==="dataset" && typeof o.embedded==="boolean"){
				//0.9.4 embedded===false added
				if(o.embedded===true){
					func=function(t,i,c){
						var item=t.link.item[i];
						if(
							c.class===item.class &&
							item.id && item.size && item.dimension //it seems like a full embedded dataset
						){
							ret.push(item);
						}
					};
				}else{
					func=function(t,i,c){
						var item=t.link.item[i];
						if(
							c.class===item.class &&
							(!item.id || !item.size || !item.dimension) //dataset reference only
						){
							ret.push(item);
						}
					};
				}
			}else{
				func=function(t,i,c){
					if(c.class===t.link.item[i].class){
						ret.push(t.link.item[i]);
					}
				};
			}
		}
		//{follow: true} not available in nodejs
	}else{ //not object, not number: void or string (ignore)
		func=function(t,i){
			ret.push(t.link.item[i]);
		};
	}

	for(var i=0; i<this.length; i++){
		func(this,i,o);
	}
	return ret;
};

jsonstat.prototype.Dataset=function(ds){
	if(this===null){
		return null;
	}

	//0.8.1 Dataset responses can be treated as bundle ones
	if(this.class==="dataset"){
		return (typeof ds!=="undefined") ? this : [this];
	}

	var
		len,
		ar=[],
		c=0
	;

	//0.9.3 Dataset collections can be managed as old bundles if they are embedded
	if(this.class==="collection"){
		var dscol=this.Item({"class": "dataset", "embedded": true});

		if(typeof ds==="undefined"){
			for(len=dscol.length; c<len; c++){
				ar.push(JSONstat(dscol[c]));
			}
			return ar;
		}

		//Dataset(2) means the 3rd embedded dataset in the collection
		if(typeof ds==="number" && ds>=0 && ds<dscol.length){
			return JSONstat(dscol[ds]);
		}

		//Dataset("http://...") selection by ID (href) for generalization's sake (probably not particularly useful) 0.9.9
		if(typeof ds==="string"){
			for(len=dscol.length; c<len; c++){
				if(dscol[c].href===ds){
					return JSONstat(dscol[c]);
				}
			}
		}

		return null;
	}

	if(this.class!=="bundle"){
		return null;
	}

	if(typeof ds==="undefined"){
		for(len=this.id.length; c<len; c++){
			ar.push(this.Dataset(this.id[c]));
		}
		return ar;
	}
	if(typeof ds==="number"){
		var num=this.id[ds];
		return (typeof num!=="undefined") ? this.Dataset(num) : null;
	}

	var tds=this.__tree__[ds];
	if(typeof tds==="undefined"){
		return null;
	}

	return new jsonstat({"class" : "dataset", "__tree__": tds});
};

jsonstat.prototype.Dimension=function(dim, bool){
	bool=(typeof bool==="boolean") ? bool : true; //0.12.2

	var
		ar=[],
		c,
		len=this.id.length,
		role=function(otr,dim){ //0.9.0 (JSON-stat 2.0)
			if(otr!==null){
				for(var prop in otr){
					for(var p=(otr[prop]!==null ? otr[prop].length : 0); p--;){
						if(otr[prop][p]===dim){
							return prop;
						}
					}
				}
			}
			return null;
		}
	;

	if (this===null || this.class!=="dataset"){
		return null;
	}
	if(typeof dim==="undefined"){
		for(c=0; c<len; c++){
			ar.push(this.Dimension(this.id[c]));
		}
		return ar;
	}
	if(typeof dim==="number"){
		var num=this.id[dim];
		return (typeof num!=="undefined") ? this.Dimension(num, bool) : null;
	}

	var otr=this.role;

	//currently only "role" is supported as filter criterion
	if(typeof dim==="object"){
		if(dim.hasOwnProperty("role")){
			for(c=0; c<len; c++){
				var oid=this.id[c];
				if(role(otr,oid)===dim.role){
					ar.push(this.Dimension(oid, bool));
				}
			}
			return (typeof ar[0]==="undefined") ? null : ar;
		}else{
			return null;
		}
	}

	var otd=this.__tree__.dimension;
	if(typeof otd==="undefined"){
		return null;
	}

	var otdd=otd[dim];
	if(typeof otdd==="undefined"){
		return null;
	}

	if(!bool){ //0.12.2
		return (function(index, label){
			var labels=[];
			for(var prop in index){
				labels[index[prop]]=label[prop];
			}
			return labels;
		})(otdd.category.index, otdd.category.label);
	}

	return new jsonstat({"class" : "dimension", "__tree__": otdd, "role": role(otr,dim)});
};

jsonstat.prototype.Category=function(cat){
	if (this===null || this.class!=="dimension"){
		return null;
	}
	if(typeof cat==="undefined"){
		var ar=[];
		for(var c=0, len=this.id.length; c<len; c++){
			ar.push(this.Category(this.id[c]));
		}
		return ar;
	}
	if(typeof cat==="number"){
		var num=this.id[cat];
		return (typeof num!=="undefined") ? this.Category(num) : null;
	}

	var oc=this.__tree__.category;
	if(typeof oc==="undefined"){
		return null;
	}
	var index=oc.index[cat];
	if(typeof index==="undefined"){
		return null;
	}

	var
		unit=(oc.unit && oc.unit[cat]) || null,
		coord=(oc.coordinates && oc.coordinates[cat]) || null,
		child=(oc.child && oc.child[cat]) || null,
		note=(oc.note && oc.note[cat]) || null
	;
	return new jsonstat({"class" : "category", "index": index, "label": oc.label[cat], "note": note, "child" : child, "unit" : unit, "coord" : coord});
};

jsonstat.prototype.Slice=function(filter){
	if(this===null || this.class!=="dataset"){
		return null;
	}
	if(typeof filter==="undefined"){
		return this;
	}

	//Convert {"gender": "M" } into [ ["gender", "M"] ]
	if(!isArray(filter)){
		var
			p,
			arr=[]
		;
		for (p in filter) {
			arr.push([ p, filter[p] ]);
		}

		filter=arr;
	}

	var
		ds=this,
		nfilters=filter.length,
		totbl=ds.toTable({field: "id", content: "id" , status: true}),
		statin=ds.status,
		head=totbl.shift(),
		error=false,
		value=[], statout=[],
		ndx=[], //dimndx, catndx
		lbl=[] //catlbl
	;

	filter.forEach(function(e){
		var dim=ds.Dimension( e[0] );

		//Wrong dimension ID
		if(dim===null){
			error=true;
			return;
		}

		var catndx=dim.id.indexOf( e[1] );

		//Wrong cat ID
		if(catndx===-1){
			error=true;
			return;
		}

		//e[0] dimid e[1] catid
		ndx.push( [ ds.id.indexOf( e[0] ), catndx ] );
		lbl.push( dim.Category( catndx ).label );
	});

	if(error){
		return null;
	}

	totbl.forEach(function(e){
		var
			tblr={},
			n=0,
			j
		;

		//Avoidable? Use a different .toTable()?
		for(j=e.length;j--;){
			tblr[head[j]]=e[j];
		}

		//Filter
		filter.forEach(function(f){
			if(tblr[ f[0] ]===f[1]){
				n++;
			}
		});

		if(nfilters===n){
			value.push(tblr.value);
			statout.push(tblr.status);
		}
	});

	ds.n=value.length;
	ds.value=ds.__tree__.value=value;
	ds.status=ds.__tree__.status=(statin!==null) ? statout : null;

	filter.forEach(function(e, i){
		ds.size[ ndx[i][0] ]=1; //dimndx
		ds.__tree__.dimension[ e[0] ].category.index={};//dimid
		ds.__tree__.dimension[ e[0] ].category.index[ e[1] ]=0; //dimid catid
		ds.__tree__.dimension[ e[0] ].category.label={};//dimid
		ds.__tree__.dimension[ e[0] ].category.label[ e[1] ]=lbl[i]; //catlbl
	});

	return ds;
};

jsonstat.prototype.Data=function(e, include){
	var
		i, ret=[], len,
		firstprop=function(o){
			for (var p in o) {
				if(o.hasOwnProperty(p)){
					return p;
				}
			}
		},
		dimObj2Array=function(thisds, sel, type){
			var
				a=[], i, obj={},
				dim=thisds.dimension,
				di=thisds.id || dim.id, //0.9.2 (JSON-stat 2.0)
				dsize=thisds.size || (dim && dim.size) //0.9.2 (JSON-stat 2.0)
			;

			//Convert [["gender", "T"],["birth", "T"]] into {gender: "T", birth: "T"}
			if(type==="array"){
				for(i=sel.length;i--;){
					obj[sel[i][0]]=sel[i][1];
				}
				sel=obj;
			}

			for (var d=0, len=di.length; d<len; d++){
				var id=di[d], cat=sel[id];
				//If dimension not defined and dim size=1, take first category (user not forced to specify single cat dimensions)
				a.push(typeof cat==="string" ? cat : dsize[d]===1 ? firstprop(dim[id].category.index) : null);
			}

			return a;
		}
	;

	if(this===null || this.class!=="dataset"){
		return null;
	}

	if(typeof e==="undefined"){
		//Before 0.4.2
		//return {"value" : this.value, "status": this.status, "label": tree.label, "length" : this.value.length};
		//Since 0.4.2: normalized as array of objects
		len=this.value.length;
		for(i=0; i<len; i++){
			ret.push(this.Data(i));
		}
		return ret;
	}

	//Since 0.10.1 status can be excluded. Default: true (=include status)
	if(typeof include!=="boolean"){
		include=true;
	}

	//Data By Position in original array
	if(typeof e==="number"){
		var num=this.value[e];

		if(typeof num==="undefined"){
			return null;
		}

		if(include){
			return { "value" : num, "status": (this.status) ? this.status[e] : null };
		}else{
			return num;
		}
	}

	var
		type="object", //default. If e is an array of arrays, type="array"
		tree=this.__tree__,
		n=tree.size || (tree.dimension && tree.dimension.size), //0.9.2 (JSON-stat 2.0)
		dims=n.length//same as this.length
	;

	if(isArray(e)){
		//DataByPosition in every dim
		//If more positions than needed are provided, they will be ignored.
		//Less positions than needed will return undefined
		if(!isArray(e[0])){
			if(this.length!==e.length){
				return null;
			}
			var
				mult=1,
				res=0,
				miss=[],
				nmiss=[]
			;
			//Validate dim index
			//And loop to find missing dimensions
			for(i=0; i<dims; i++){
				if(typeof e[i]!=="undefined"){
					if(typeof e[i]!=="number" || e[i]>=n[i]){
						return null;
					}
					//Used if normal case (miss.length===0)
					mult*=(i>0) ? n[(dims-i)] : 1;
					res+=mult*e[dims-i-1]; //simplified in 0.4.3
				}else{
					//Used if missing dimensions miss.length>0
					miss.push(i); //missing dims
					nmiss.push(n[i]); //missing dims size
				}
			}

			//If all dims are specified, go ahead as usual.
			//If one non-single dimension is missing create array of results
			//If more than one non-single dimension is missing, WARNING
			if(miss.length>1){
				return null;
			}
			if(miss.length===1){
				for(var c=0, clen=nmiss[0]; c<clen; c++){
					var na=[]; //New array
					for(i=0; i<dims; i++){
						if(i!==miss[0]){
							na.push(e[i]);
						}else{
							na.push(c);
						}
					}
					ret.push(this.Data(na, include));
				}
				return ret;
			}

			if(include){
				return {"value" : this.value[res], "status": (this.status) ? this.status[res] : null};
			}else{
				return this.value[res];
			}

		}else{
			//If array but not array of numbers, array of arrays is assumed
			//[ ["gender", "M"], ["year", "2011"] ]
			type="array";
		}
	}

	//Object { gender: "M", year: "2011" }
	var
		id=dimObj2Array(tree, e, type),
		pos=[],
		otd=tree.dimension,
		otdi=tree.id || otd.id //0.9.2 (JSON-stat 2.0)
	;

	for(i=0, len=id.length; i<len; i++){
		pos.push(otd[otdi[i]].category.index[id[i]]);
	}

	//Dimension cat undefined means a loop (by position) is necessary
	return this.Data(pos, include);
};

/*
	Transformation method: output in DataTable format (array or object)
	Setup: opts={by: null, bylabel: false, meta: false, drop: [], status: false, slabel: "Status", vlabel: "Value", field: "label", content: "label", type: "array"} (type values: "array" / "object" / "arrobj")
*/
jsonstat.prototype.toTable=function(opts, func){
	if(this===null || this.class!=="dataset"){
		return null;
	}

	if(arguments.length==1 && typeof opts==="function"){
		func=opts;
		opts=null;
	}

	//default: use label for field names and content instead of "id". "by", "prefix", drop & meta added on 0.13.0 (currently only for "arrobj", "by" cancels "unit"). "comma" is 0.13.2
	opts=opts || {field: "label", content: "label", vlabel: "Value", slabel: "Status", type: "array", status: false, unit: false, by: null, prefix: "", drop: [], meta: false, comma: false, bylabel: false};
	var
		totbl,
		dataset=this.__tree__,
		i, j, x,
		len,
		status=(opts.status===true) //0.13.1: be as strict as "meta": allow only booleans
	;

	if(typeof func==="function"){
		totbl=this.toTable(opts);
		var
			ret=[],
			start=(opts.type!=="array") ? 0 : 1, //first row is header in array and object
			arr=(opts.type!=="object") ? totbl.slice(start) : totbl.rows.slice(0)
		;

		len=arr.length;
		for(i=0; i<len; i++){
			var a=func.call(
				this, //0.5.3
				arr[i], //Discarded for efficiency: (opts.type!=='object') ? arr[i] : arr[i].c,
				i
			);
			if(typeof a!=="undefined"){
				ret.push(a);
			}
		}
		if(opts.type==='object'){
			return {cols: totbl.cols, rows: ret};
		}
		if(opts.type==='array'){
			ret.unshift(totbl[0]);
		}
		return ret;
	}

	if(opts.type==="arrobj"){
		totbl=this.toTable({field: "id", content: opts.content, status: status});

		var
			tbl=[],
			head=totbl.shift(),
			//0.12.3
			metric=dataset.role && dataset.role.metric,
			addUnits=function(){},
			metriclabels={},
			//0.13.0 "by" is ignored if it's not an existing dimension ID
			ds=this,
			ids=ds.id,
			by=(opts.by && ids.indexOf(opts.by)!==-1) ? opts.by : null,
			meta=(opts.meta===true),
			drop=(typeof opts.drop!=="undefined" && isArray(opts.drop)) ? opts.drop : [],
			comma=(opts.comma===true),
			bylabel=(opts.bylabel===true),
			formatResp=function(arr){
				if(meta){
					var obj={};

					ids.forEach(function(i){
						var d=ds.Dimension(i);

						obj[i]={
							"label": d.label,
							"role": d.role,
							"categories": { //diferent from JSON-stat on purpose: "id" is not "index" and "label" is different than JSON-stat categories' label.
								"id": d.id,
								"label": ds.Dimension(i, false)
							}
						};
					});

					return {
						"meta": {
							"label": ds.label,
							"source": ds.source,
							"updated": ds.updated,

							//0.13.1
							"id": ids,
							"status": status,
							"unit": opts.unit,
							"by": by,
							"bylabel": bylabel,
							"drop": by!==null && drop.length>0 ? drop : null,
							"prefix": by!==null ? (prefix || "") : null,
							//0.13.2
							"comma": comma,

							"dimensions": obj //different from JSON-stat on purpose: the content is different and this export format is addressed to people probably not familiar with the JSON-stat format
						},
						"data": arr
					};
				}else{
					//does nothing
					return arr;
				}
			}
		;

		//0.12.3 Include unit information if there's any (only if arrobj and 0.13.0 not "by")
		if(by===null && opts.unit && metric){
			if(opts.content!=="id"){
				for(var m=metric.length; m--;){
					var mdim=this.Dimension(metric[m]);
					metriclabels[metric[m]]={};

					for(var mm=mdim.length; mm--;){
						metriclabels[metric[m]][mdim.Category(mm).label]=mdim.id[mm];
					}
				}
			}

			addUnits=function(d, c){
				//array indexOf
				if(metric.indexOf(d)!==-1){
					var cat=dataset.dimension[d].category;
					/*0.13.9*/
					if(cat.unit){
						tblr.unit=cat.unit[opts.content!=="id" ? metriclabels[d][c] : c];
					}else{
						tblr.unit=null; /*when units requested but missing in the dataset, create "unit" property too*/
					}
				}
			};

			opts.unit=true; //normalized
		}else{
			opts.unit=false;
		}

		len=totbl.length;
		for(i=0; i<len; i++){ //Can't be done with i-- as we want to keep the original order
			var tblr={};
			for(j=totbl[i].length;j--;){
				tblr[head[j]]=totbl[i][j];
				addUnits(head[j], totbl[i][j]); //0.12.3
			}
			tbl.push(tblr);
		}

		//0.13.2
		if(comma){
			tbl.forEach(function(r){
				if(r.value!==null){
					r.value=(""+r.value).replace(".", ",");
				}
			});
		}

		//0.13.0
		//Categories' IDs of "by" dimension will be used as object properties: user can use "prefix" to avoid conflict with non-by dimensions' IDs
		if(by!==null){
			var
				save={},
				arr=[],
				labelid={},
				assignValue,
				prefix=(typeof opts.prefix!=="undefined") ? opts.prefix : ""
			;

			drop.forEach(function(id, i){
				//remove incorrect ids & ids for dimensions with size>1 from the drop array
				if( !ds.Dimension(id) || ds.Dimension(id).length>1 ){
					drop[i]="";
				}
			});

			var
				noby=ids.filter(function(i) {
					return i!==by && drop.indexOf(i)===-1;
				}),
				byDim=ds.Dimension(by),
				setId=function(row, noby){
					var a=[];

					noby.forEach(function(e){
						a.push(row[e]);
					});

					return a.join("\t");
				},
				setObj=function(row, noby){
					var obj={};

					noby.forEach(function(e){
						obj[e]=row[e];
					});

					return obj;
				}
			;

			if(opts.content!=="id"){
				//0.13.3
				if(bylabel){
					assignValue=function(save, id, row){
						save[id][ prefix+row[by] ]=row.value;
					}
				}else{
					byDim.Category().forEach(function(c, i){
						labelid[c.label]=byDim.id[i];
					});

					assignValue=function(save, id, row){
						save[id][ prefix+labelid[row[by]] ]=row.value;
					}
				}
			}else{
				assignValue=function(save, id, row){
					save[id][ prefix+row[by] ]=row.value;
				}
			}

			tbl.forEach(function(row){
				var id=setId(row, noby);

				if(typeof save[id]==="undefined"){
					save[id]=setObj(row, noby);
				}

				//We use a conditionally defined function to avoid an "if" inside the loop.
				assignValue(save, id, row, by);
			});

			for(var prop in save){
				arr.push(save[prop]);
			}

			status=false; //Incompatible with "by"
			return formatResp(arr);
		}

		return formatResp(tbl);
	}

	var
		addCol,
		addColValue,
		addRow,
		addRowValue,
		useid=(opts.field==="id")
	;

	if(opts.type==="object"){
		//Object
		var valuetype=(typeof this.value[0]==="number" || this.value[0]===null) ? "number" : "string"; //cell type inferred from first cell. If null, number is assumed (naif)

		addCol=function(dimid,dimlabel){
			var label=(useid && dimid) || dimlabel || dimid; //if userid then id; else label; then id if not label
			cols.push({id: dimid, label: label, type: "string"}); //currently not using datetime Google type (requires a Date object)
		};

		addColValue=function(str1,str2,status){
			var
				vlabel=(useid && "value") || str1 || "Value",
				slabel=(useid && "status") || str2 || "Status"
			;
			if(status){
				cols.push({id: "status", label: slabel, type: "string"});
			}
			cols.push({id: "value", label: vlabel, type: valuetype});
		};

		addRow=function(r){
			row.push({v: r});
		};

		addRowValue=function(r){
			//At the moment, no support for formatted values (f: formatted)
			row.push({v: r});
			rows.push({c: row});
		};

	}else{
		//Array
		addCol=function(dimid,dimlabel){
			var colid=(useid && dimid) || dimlabel || dimid; //if useid then id; else label; then id if not label
			cols.push(colid);
		};

		addColValue=function(str1,str2,status){
			var
				vlabel=(useid && "value") || str1 || "Value",
				slabel=(useid && "status") || str2 || "Status"
			;
			if(status){
				cols.push(slabel);
			}
			cols.push(vlabel);
			table.push(cols);
		};

		addRow=function(r){
			row.push(r);
		};

		addRowValue=function(r){
			row.push(r);
			table.push(row);
		};
	}

	var
		dd=dataset.dimension,
		ddi=dataset.id || dd.id, //0.9.5 (JSON-stat 2.0)
		dds=dataset.size || dd.size, //0.9.5 (JSON-stat 2.0)
		ddil=ddi.length
	;

	if (ddil!=dds.length){
		return false;
	}

	var dim=[], total=1, m=1, mult=[], dimexp=[], label=[], table=[], cols=[], rows=[];

	for (i=0; i<ddil; i++){
		var
			dimid=ddi[i],
			dimlabel=dd[dimid].label
		;

		addCol(dimid,dimlabel); //Global cols

		total*=dds[i];
		m*=dds[i];
		var cat=[];
		for (j=0; j<dds[i]; j++){
			for (var catid in dd[ddi[i]].category.index){
				if (dd[ddi[i]].category.index[catid]===j){
					var rowid=(opts.content!=="id" && dd[ddi[i]].category.label) ? dd[ddi[i]].category.label[catid] : catid; //id if not label (Maybe move label normalization from "dimension" to "dataset"?)
					cat.push(rowid);
				}
			}
		}
		dim.push(cat);
		mult.push(m);
	}
	addColValue(opts.vlabel,opts.slabel,status); //Global cols and table

	//end of inversion: now use dim array
	len=dim.length;
	for (i=0; i<len; i++){
		var catexp=[];
		for (var c=0, len2=dim[i].length; c<len2; c++){
			//get the label repetitions
			for (var n=0; n<total/mult[i]; n++){
				catexp.push(dim[i][c]);
			}
		}
		dimexp.push(catexp);
	}
	len=dimexp.length;
	for (i=0; i<len; i++){
		var l=[], e=0;
		for (x=0; x<total; x++){
			l.push(dimexp[i][e]);
			e++;
			if (e===dimexp[i].length){
				e=0;
			}
		}
		label.push(l);
	}
	for (x=0; x<total; x++){
		var row=[];
		len=dimexp.length;
		for (var d=0; d<len; d++){
			addRow(label[d][x]); //Global row
		}
		if(status){
			addRow(
				(this.status) ? this.status[x] : null
			);
		}
		addRowValue(this.value[x]); //Global row, rows and table
	}

	if(opts.type==="object"){
		return {cols: cols, rows: rows};
	}else{
		return table;
	}
};

jsonstat.prototype.node=function(){
	return this.__tree__;
};
jsonstat.prototype.toString=function(){
	return this.class;
};

export const version="0.13.13";
export function JSONstat(resp){
	return new jsonstat(resp);
}