diff --git a/packages/dicom/gdcm/image-sets-normalization.cxx b/packages/dicom/gdcm/image-sets-normalization.cxx index 72591c069..30c3db6a8 100644 --- a/packages/dicom/gdcm/image-sets-normalization.cxx +++ b/packages/dicom/gdcm/image-sets-normalization.cxx @@ -36,6 +36,7 @@ const std::set PATIENT_TAGS = { }; const std::set STUDY_TAGS = { + "0020|000D", // Study Instance UID "0008|0020", // Study Date "0008|0030", // Study Time "0008|1030", // Study Description @@ -56,6 +57,7 @@ const std::set NON_INSTANCE_TAGS = { "0010|1010", // Patient's Age "0010|1030", // Patient's Weight "0010|21b0", // Additional Patient's History + "0020|000D", // Study Instance UID "0008|0020", // Study Date "0008|0030", // Study Time "0008|1030", // Study Description @@ -65,8 +67,14 @@ const std::set NON_INSTANCE_TAGS = { "0008|0060", // Modality }; +const std::string STUDY_INSTANCE_UID = "0020|000D"; +const std::string SERIES_INSTANCE_UID = "0020|000e"; -rapidjson::Value mapToJsonObj(const itk::DICOMTagReader::TagMapType &tags, rapidjson::Document::AllocatorType &allocator) +using File = std::string; +using TagMap = itk::DICOMTagReader::TagMapType; +using FileToTags = std::map; + +rapidjson::Value mapToJsonObj(const TagMap &tags, rapidjson::Document::AllocatorType &allocator) { rapidjson::Value json(rapidjson::kObjectType); for (const auto &[tag, value] : tags) @@ -100,126 +108,181 @@ rapidjson::Value jsonFromTags(const itk::DICOMTagReader::TagMapType &tags, const return mapToJsonObj(filteredTags, allocator); } -int main(int argc, char *argv[]) +FileToTags readTags(const std::vector &files) { - itk::wasm::Pipeline pipeline("image-sets-normalization", "Group DICOM files into image sets", argc, argv); - - std::vector files; - pipeline.add_option("--files", files, "DICOM files")->required()->check(CLI::ExistingFile)->type_size(1, -1)->type_name("INPUT_BINARY_FILE"); - - itk::wasm::OutputTextStream imageSets; - pipeline.add_option("image-sets", imageSets, "Image sets JSON")->required()->type_name("OUTPUT_JSON"); - - ITK_WASM_PARSE(pipeline); - - std::vector volumes; - gdcm::Scanner s; - - const gdcm::Tag t1(0x0020, 0x000d); // Study Instance UID - const gdcm::Tag t2(0x0020, 0x000e); // Series Instance UID - const gdcm::Tag t3(0x0020, 0x0052); // Frame of Reference UID - const gdcm::Tag t4(0x0020, 0x0037); // Image Orientation (Patient) - - s.AddTag(t1); - s.AddTag(t2); - s.AddTag(t3); - s.AddTag(t4); - - bool b = s.Scan(files); - if (!b) + FileToTags fileToTags; + itk::DICOMTagReader tagReader; + for (const File &fileName : files) { - std::cerr << "Scanner failed" << std::endl; - return EXIT_FAILURE; + if (!tagReader.CanReadFile(fileName)) + { + std::cerr << "Could not read the input DICOM file: " << fileName << std::endl; + throw std::runtime_error("Could not read the input DICOM file: " + fileName); + } + tagReader.SetFileName(fileName); + const TagMap dicomTags = tagReader.ReadAllTags(); + fileToTags[fileName] = dicomTags; } + return fileToTags; +} - gdcm::DiscriminateVolume dv; - dv.ProcessIntoVolume(s); +using Volume = std::vector; +using Volumes = std::vector; +using ImageSets = std::vector; - std::vector sorted = dv.GetSortedFiles(); - for (gdcm::Directory::FilenamesType &volume : sorted) +bool isSameVolume(const TagMap &volumeTags, const TagMap &fileTags) +{ + const auto it1 = volumeTags.find(SERIES_INSTANCE_UID); + const auto it2 = fileTags.find(SERIES_INSTANCE_UID); + if (it1 == volumeTags.end() || it2 == fileTags.end()) { - volumes.push_back(volume); + return false; } + return it1->second == it2->second; +} - std::vector unsorted = dv.GetUnsortedFiles(); - for (gdcm::Directory::FilenamesType fileGroups : unsorted) +Volumes groupByVolume(const FileToTags &fileToTags) +{ + Volumes volumes; + for (const auto &[file, tags] : fileToTags) { - volumes.push_back(fileGroups); + Volume *matchingVolume = nullptr; + for (Volume &volume : volumes) + { + const File fileInVolume = *volume.begin(); + const TagMap volumeTags = fileToTags.at(fileInVolume); + if (isSameVolume(volumeTags, tags)) + { + matchingVolume = &volume; + break; + } + } + if (matchingVolume) + { + matchingVolume->push_back(file); + } + else + { + Volume newVolume({file}); + volumes.push_back(newVolume); + } } + return volumes; +} - rapidjson::Document imageSetsJson(rapidjson::kArrayType); - rapidjson::Document::AllocatorType &allocator = imageSetsJson.GetAllocator(); - - itk::DICOMTagReader tagReader; +bool isSameImageSet(const TagMap &imageSetTags, const TagMap &volumeTags) +{ + const auto it1 = imageSetTags.find(STUDY_INSTANCE_UID); + const auto it2 = volumeTags.find(STUDY_INSTANCE_UID); + if (it1 == imageSetTags.end() || it2 == volumeTags.end()) + { + return false; + } + return it1->second == it2->second; +} - // read all tags for file - for (const auto &fileNames : volumes) +ImageSets groupByImageSet(const Volumes &volumes, const FileToTags &fileToTags) +{ + ImageSets imageSets; + for (const Volume &volume : volumes) { - itk::DICOMTagReader::TagMapType dicomTags; // series/study/patent tags are pulled from last file - rapidjson::Value instances(rapidjson::kObjectType); - for (const auto &fileName : fileNames) + File file = *volume.begin(); + TagMap volumeTags = fileToTags.at(file); + Volumes *matchingImageSet = nullptr; + for (Volumes &volumes : imageSets) { - if (!tagReader.CanReadFile(fileName)) + const Volume volumeInImageSet = *volumes.begin(); + File fileInImageSet = *volumeInImageSet.begin(); + const TagMap imageSetTags = fileToTags.at(fileInImageSet); + if (isSameImageSet(imageSetTags, volumeTags)) { - std::cerr << "Could not read the input DICOM file: " << fileName << std::endl; - return EXIT_FAILURE; + matchingImageSet = &volumes; + break; } - tagReader.SetFileName(fileName); - dicomTags = tagReader.ReadAllTags(); + } + if (matchingImageSet) + { + matchingImageSet->push_back(volume); + } + else + { + Volumes newImageSet({volume}); + imageSets.push_back(newImageSet); + } + } + return imageSets; +} - // filter out patient, study, series tags - itk::DICOMTagReader::TagMapType instanceTags; - for (const auto &[tag, value] : dicomTags) +rapidjson::Document toJson(const ImageSets &imageSets, const FileToTags &fileToTags) +{ + rapidjson::Document imageSetsJson(rapidjson::kArrayType); + rapidjson::Document::AllocatorType &allocator = imageSetsJson.GetAllocator(); + TagMap dicomTags; + for (const Volumes &volumes : imageSets) + { + rapidjson::Value seriesById(rapidjson::kObjectType); + for (const Volume &volume : volumes) + { + rapidjson::Value instances(rapidjson::kObjectType); + for (const File &file : volume) { - if (NON_INSTANCE_TAGS.find(tag) == NON_INSTANCE_TAGS.end()) + dicomTags = fileToTags.at(file); + // filter out patient, study, series tags + itk::DICOMTagReader::TagMapType instanceTags; + for (const auto &[tag, value] : dicomTags) { - instanceTags[tag] = value; + if (NON_INSTANCE_TAGS.find(tag) == NON_INSTANCE_TAGS.end()) + { + instanceTags[tag] = value; + } } + rapidjson::Value instanceTagsJson = mapToJsonObj(instanceTags, allocator); + rapidjson::Value instance(rapidjson::kObjectType); + instance.AddMember("DICOM", instanceTagsJson, allocator); + + rapidjson::Value fileNameValue; + fileNameValue.SetString(file.c_str(), file.size(), allocator); + rapidjson::Value imageFrame(rapidjson::kObjectType); + imageFrame.AddMember("ID", fileNameValue, allocator); + rapidjson::Value imageFrames(rapidjson::kArrayType); + imageFrames.PushBack(imageFrame, allocator); + instance.AddMember("ImageFrames", imageFrames, allocator); + + // instance by UID under instances + TagMap::iterator it = dicomTags.find("0008|0018"); + if (it == dicomTags.end()) + { + std::cerr << "Instance UID not found in dicomTags" << std::endl; + throw std::runtime_error("Instance UID not found in dicomTags"); + } + const auto tag = it->second; + rapidjson::Value instanceId; + instanceId.SetString(tag.c_str(), tag.size(), allocator); + instances.AddMember(instanceId, instance, allocator); } - rapidjson::Value instanceTagsJson = mapToJsonObj(instanceTags, allocator); - rapidjson::Value instance(rapidjson::kObjectType); - instance.AddMember("DICOM", instanceTagsJson, allocator); - rapidjson::Value fileNameValue; - fileNameValue.SetString(fileName.c_str(), fileName.size(), allocator); - instance.AddMember("FileName", fileNameValue, allocator); - - // instance by UID under instances - itk::DICOMTagReader::TagMapType::iterator it = dicomTags.find("0008|0018"); - if (it == dicomTags.end()) - { - std::cerr << "Instance UID not found in dicomTags" << std::endl; - return EXIT_FAILURE; - } - const auto tag = it->second; - rapidjson::Value instanceId; - instanceId.SetString(tag.c_str(), tag.size(), allocator); - instances.AddMember(instanceId, instance, allocator); - } - rapidjson::Value seriesTags = jsonFromTags(dicomTags, SERIES_TAGS, allocator); - rapidjson::Value series(rapidjson::kObjectType); - series.AddMember("DICOM", seriesTags, allocator); - series.AddMember("Instances", instances, allocator); - // series by ID object - itk::DICOMTagReader::TagMapType::iterator it = dicomTags.find("0020|000e"); - if (it == dicomTags.end()) - { - std::cerr << "Series UID not found in dicomTags" << std::endl; - return EXIT_FAILURE; + // Series + rapidjson::Value seriesTags = jsonFromTags(dicomTags, SERIES_TAGS, allocator); + rapidjson::Value series(rapidjson::kObjectType); + series.AddMember("DICOM", seriesTags, allocator); + series.AddMember("Instances", instances, allocator); + + int volumeIndex = std::distance(volumes.begin(), std::find(volumes.begin(), volumes.end(), volume)); + const std::string seriesId = dicomTags.at(SERIES_INSTANCE_UID) + '.' + std::to_string(volumeIndex); + rapidjson::Value seriesIdJson; + seriesIdJson.SetString(seriesId.c_str(), seriesId.size(), allocator); + seriesById.AddMember(seriesIdJson, series, allocator); } - const auto tag = it->second; - rapidjson::Value seriesId; - seriesId.SetString(tag.c_str(), tag.size(), allocator); - rapidjson::Value seriesById(rapidjson::kObjectType); - seriesById.AddMember(seriesId, series, allocator); rapidjson::Value imageSet(rapidjson::kObjectType); + // Patient rapidjson::Value patient(rapidjson::kObjectType); rapidjson::Value patientTags = jsonFromTags(dicomTags, PATIENT_TAGS, allocator); patient.AddMember("DICOM", patientTags, allocator); imageSet.AddMember("Patient", patient, allocator); + // Study rapidjson::Value study(rapidjson::kObjectType); rapidjson::Value studyTagsJson = jsonFromTags(dicomTags, STUDY_TAGS, allocator); study.AddMember("DICOM", studyTagsJson, allocator); @@ -228,11 +291,31 @@ int main(int argc, char *argv[]) imageSetsJson.PushBack(imageSet, allocator); } + return imageSetsJson; +} + +int main(int argc, char *argv[]) +{ + itk::wasm::Pipeline pipeline("image-sets-normalization", "Group DICOM files into image sets", argc, argv); + + std::vector files; + pipeline.add_option("--files", files, "DICOM files")->required()->check(CLI::ExistingFile)->type_size(1, -1)->type_name("INPUT_BINARY_FILE"); + + itk::wasm::OutputTextStream imageSetsOutput; + pipeline.add_option("image-sets", imageSetsOutput, "Image sets JSON")->required()->type_name("OUTPUT_JSON"); + + ITK_WASM_PARSE(pipeline); + + const FileToTags fileToTags = readTags(files); + const Volumes volumes = groupByVolume(fileToTags); + const ImageSets imageSets = groupByImageSet(volumes, fileToTags); + + rapidjson::Document imageSetsJson = toJson(imageSets, fileToTags); rapidjson::StringBuffer stringBuffer; rapidjson::Writer writer(stringBuffer); imageSetsJson.Accept(writer); - imageSets.Get() << stringBuffer.GetString(); + imageSetsOutput.Get() << stringBuffer.GetString(); return EXIT_SUCCESS; } diff --git a/packages/dicom/python/itkwasm-dicom-emscripten/itkwasm_dicom_emscripten/js_package.py b/packages/dicom/python/itkwasm-dicom-emscripten/itkwasm_dicom_emscripten/js_package.py index 049de4ba5..27b02cfe2 100644 --- a/packages/dicom/python/itkwasm-dicom-emscripten/itkwasm_dicom_emscripten/js_package.py +++ b/packages/dicom/python/itkwasm-dicom-emscripten/itkwasm_dicom_emscripten/js_package.py @@ -3,6 +3,6 @@ from itkwasm.pyodide import JsPackageConfig, JsPackage from ._version import __version__ -default_js_module = """data:text/javascript;base64,var St=Object.defineProperty;var Ft=(A,e)=>{for(var t in e)St(A,t,{get:e[t],enumerable:!0})};var kt="6.0.1",kA=kt;var Rt={Int8:"int8",UInt8:"uint8",Int16:"int16",UInt16:"uint16",Int32:"int32",UInt32:"uint32",Int64:"int64",UInt64:"uint64",SizeValueType:"uint64",IdentifierType:"uint64",IndexValueType:"int64",OffsetValueType:"int64"},h=Rt;var bt={Float32:"float32",Float64:"float64",SpacePrecisionType:"float64"},M=bt;function Ut(A,e){let t=null;switch(A){case h.UInt8:{t=new Uint8Array(e);break}case h.Int8:{t=new Int8Array(e);break}case h.UInt16:{t=new Uint16Array(e);break}case h.Int16:{t=new Int16Array(e);break}case h.UInt32:{t=new Uint32Array(e);break}case h.Int32:{t=new Int32Array(e);break}case h.UInt64:{typeof globalThis.BigUint64Array=="function"?t=new BigUint64Array(e):t=new Uint8Array(e);break}case h.Int64:{typeof globalThis.BigInt64Array=="function"?t=new BigInt64Array(e):t=new Uint8Array(e);break}case M.Float32:{t=new Float32Array(e);break}case M.Float64:{t=new Float64Array(e);break}case"null":{t=null;break}case null:{t=null;break}default:throw new Error("Type is not supported as a TypedArray")}return t}var x=Ut;var Nt={Unknown:"Unknown",Scalar:"Scalar",RGB:"RGB",RGBA:"RGBA",Offset:"Offset",Vector:"Vector",Point:"Point",CovariantVector:"CovariantVector",SymmetricSecondRankTensor:"SymmetricSecondRankTensor",DiffusionTensor3D:"DiffusionTensor3D",Complex:"Complex",FixedArray:"FixedArray",Array:"Array",Matrix:"Matrix",VariableLengthVector:"VariableLengthVector",VariableSizeMatrix:"VariableSizeMatrix"},le=Nt;var RA=class{dimension;componentType;pixelType;components;constructor(e=2,t=h.UInt8,r=le.Scalar,n=1){this.dimension=e,this.componentType=t,this.pixelType=r,this.components=n}},Be=RA;function Gt(A,e,t,r,n){A[r+t*e]=n}var Ce=Gt;var bA=class{imageType;name="image";origin;spacing;direction;size;metadata;data;constructor(e=new Be){this.imageType=e;let t=e.dimension;this.origin=new Array(t),this.origin.fill(0),this.spacing=new Array(t),this.spacing.fill(1),this.direction=new Float64Array(t*t),this.direction.fill(0);for(let r=0;r<t;r++)Ce(this.direction,t,r,r,1);this.size=new Array(t),this.size.fill(0),this.metadata=new Map,this.data=null}},ce=bA;function Tt(A){if(A.length<1)throw Error("At least one images is required.");let e=A[0];if(e.data===null)throw Error("Image data is null.");let t=new ce(e.imageType);t.origin=Array.from(e.origin),t.spacing=Array.from(e.spacing);let r=t.imageType.dimension;t.direction=e.direction.slice();let n=r-1;t.size=Array.from(e.size);let i=A.reduce((s,a)=>s+a.size[n],0);t.size[n]=i;let o=t.size.reduce((s,a)=>s*a,1)*t.imageType.components,I=e.data.constructor;t.data=new I(o);let C=t.imageType.components;for(let s=0;s<t.size.length-1;s++)C*=t.size[s];let l=0;if(t.data!=null)for(let s=0;s<A.length;s++)t.data.set(A[s].data,C*l),l+=A[s].size[n];else throw Error("Could not create result image data.");return t}var UA=Tt;var NA=class{fcn;workerQueue;runInfo;constructor(e,t){this.fcn=t,this.workerQueue=new Array(e),this.workerQueue.fill(null),this.runInfo=[]}runTasks(e,t=null){let r={taskQueue:[],results:[],addingTasks:!1,postponed:!1,runningWorkers:0,index:0,completedTasks:0,progressCallback:t,canceled:!1};return this.runInfo.push(r),r.index=this.runInfo.length-1,{promise:new Promise((n,i)=>{r.resolve=n,r.reject=i,r.results=new Array(e.length),r.completedTasks=0,r.addingTasks=!0,e.forEach((o,I)=>{this.addTask(r.index,I,o)}),r.addingTasks=!1}),runId:r.index}}terminateWorkers(){for(let e=0;e<this.workerQueue.length;e++){let t=this.workerQueue[e];t?.terminate(),this.workerQueue[e]=null}}cancel(e){let t=this.runInfo[e];t!=null&&(t.canceled=!0)}addTask(e,t,r){let n=this.runInfo[e];if(n?.canceled===!0){n.reject("Remaining tasks canceled"),this.clearTask(n.index);return}if(this.workerQueue.length>0){let i=this.workerQueue.pop();n.runningWorkers++,r[r.length-1].webWorker=i,this.fcn(...r).then(({webWorker:o,...I})=>{if(this.workerQueue.push(o),this.runInfo[e]!==null){if(n.runningWorkers--,n.results[t]=I,n.completedTasks++,n.progressCallback!=null&&n.progressCallback(n.completedTasks,n.results.length),n.taskQueue.length>0){let C=n.taskQueue.shift();this.addTask(e,C[0],C[1])}else if(!n.addingTasks&&n.runningWorkers===0){let C=n.results;n.resolve(C),this.clearTask(n.index)}}}).catch(o=>{n.reject(o),this.clearTask(n.index)})}else n.runningWorkers!==0||n.postponed?n.taskQueue.push([t,r]):(n.postponed=!0,setTimeout(()=>{n.postponed=!1,this.addTask(n.index,t,r)},50))}clearTask(e){this.runInfo[e].results=[],this.runInfo[e].taskQueue=[],this.runInfo[e].progressCallback=null,this.runInfo[e].canceled=null,this.runInfo[e].reject=()=>{},this.runInfo[e].resolve=()=>{}}},GA=NA;var Lt={TextFile:"TextFile",BinaryFile:"BinaryFile",TextStream:"TextStream",BinaryStream:"BinaryStream",Image:"Image",Mesh:"Mesh",PolyData:"PolyData",JsonCompatible:"JsonCompatible"},f=Lt;var Ee=Symbol("Comlink.proxy"),xt=Symbol("Comlink.endpoint"),xA=Symbol("Comlink.releaseProxy"),TA=Symbol("Comlink.finalizer"),sA=Symbol("Comlink.thrown"),fe=A=>typeof A=="object"&&A!==null||typeof A=="function",Ot={canHandle:A=>fe(A)&&A[Ee],serialize(A){let{port1:e,port2:t}=new MessageChannel;return pe(A,e),[t,[t]]},deserialize(A){return A.start(),OA(A)}},Pt={canHandle:A=>fe(A)&&sA in A,serialize({value:A}){let e;return A instanceof Error?e={isError:!0,value:{message:A.message,name:A.name,stack:A.stack}}:e={isError:!1,value:A},[e,[]]},deserialize(A){throw A.isError?Object.assign(new Error(A.value.message),A.value):A.value}},Qe=new Map([["proxy",Ot],["throw",Pt]]);function Jt(A,e){for(let t of A)if(e===t||t==="*"||t instanceof RegExp&&t.test(e))return!0;return!1}function pe(A,e=globalThis,t=["*"]){e.addEventListener("message",function r(n){if(!n||!n.data)return;if(!Jt(t,n.origin)){console.warn(`Invalid origin '${n.origin}' for comlink proxy`);return}let{id:i,type:o,path:I}=Object.assign({path:[]},n.data),C=(n.data.argumentList||[]).map(H),l;try{let s=I.slice(0,-1).reduce((E,B)=>E[B],A),a=I.reduce((E,B)=>E[B],A);switch(o){case"GET":l=a;break;case"SET":s[I.slice(-1)[0]]=H(n.data.value),l=!0;break;case"APPLY":l=a.apply(s,C);break;case"CONSTRUCT":{let E=new a(...C);l=Kt(E)}break;case"ENDPOINT":{let{port1:E,port2:B}=new MessageChannel;pe(A,B),l=PA(E,[E])}break;case"RELEASE":l=void 0;break;default:return}}catch(s){l={value:s,[sA]:0}}Promise.resolve(l).catch(s=>({value:s,[sA]:0})).then(s=>{let[a,E]=lA(s);e.postMessage(Object.assign(Object.assign({},a),{id:i}),E),o==="RELEASE"&&(e.removeEventListener("message",r),de(e),TA in A&&typeof A[TA]=="function"&&A[TA]())}).catch(s=>{let[a,E]=lA({value:new TypeError("Unserializable return value"),[sA]:0});e.postMessage(Object.assign(Object.assign({},a),{id:i}),E)})}),e.start&&e.start()}function Ht(A){return A.constructor.name==="MessagePort"}function de(A){Ht(A)&&A.close()}function OA(A,e){return LA(A,[],e)}function aA(A){if(A)throw new Error("Proxy has been released and is not useable")}function me(A){return Y(A,{type:"RELEASE"}).then(()=>{de(A)})}var IA=new WeakMap,gA="FinalizationRegistry"in globalThis&&new FinalizationRegistry(A=>{let e=(IA.get(A)||0)-1;IA.set(A,e),e===0&&me(A)});function Mt(A,e){let t=(IA.get(e)||0)+1;IA.set(e,t),gA&&gA.register(A,e,A)}function Yt(A){gA&&gA.unregister(A)}function LA(A,e=[],t=function(){}){let r=!1,n=new Proxy(t,{get(i,o){if(aA(r),o===xA)return()=>{Yt(n),me(A),r=!0};if(o==="then"){if(e.length===0)return{then:()=>n};let I=Y(A,{type:"GET",path:e.map(C=>C.toString())}).then(H);return I.then.bind(I)}return LA(A,[...e,o])},set(i,o,I){aA(r);let[C,l]=lA(I);return Y(A,{type:"SET",path:[...e,o].map(s=>s.toString()),value:C},l).then(H)},apply(i,o,I){aA(r);let C=e[e.length-1];if(C===xt)return Y(A,{type:"ENDPOINT"}).then(H);if(C==="bind")return LA(A,e.slice(0,-1));let[l,s]=ue(I);return Y(A,{type:"APPLY",path:e.map(a=>a.toString()),argumentList:l},s).then(H)},construct(i,o){aA(r);let[I,C]=ue(o);return Y(A,{type:"CONSTRUCT",path:e.map(l=>l.toString()),argumentList:I},C).then(H)}});return Mt(n,A),n}function qt(A){return Array.prototype.concat.apply([],A)}function ue(A){let e=A.map(lA);return[e.map(t=>t[0]),qt(e.map(t=>t[1]))]}var he=new WeakMap;function PA(A,e){return he.set(A,e),A}function Kt(A){return Object.assign(A,{[Ee]:!0})}function lA(A){for(let[e,t]of Qe)if(t.canHandle(A)){let[r,n]=t.serialize(A);return[{type:"HANDLER",name:e,value:r},n]}return[{type:"RAW",value:A},he.get(A)||[]]}function H(A){switch(A.type){case"HANDLER":return Qe.get(A.name).deserialize(A.value);case"RAW":return A.value}}function Y(A,e,t){return new Promise(r=>{let n=Wt();A.addEventListener("message",function i(o){!o.data||!o.data.id||o.data.id!==n||(A.removeEventListener("message",i),r(o.data))}),A.start&&A.start(),A.postMessage(Object.assign({id:n},e),t)})}function Wt(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}function Z(A,e){return function(){return A.apply(e,arguments)}}var{toString:vt}=Object.prototype,{getPrototypeOf:MA}=Object,CA=(A=>e=>{let t=vt.call(e);return A[t]||(A[t]=t.slice(8,-1).toLowerCase())})(Object.create(null)),G=A=>(A=A.toLowerCase(),e=>CA(e)===A),cA=A=>e=>typeof e===A,{isArray:q}=Array,X=cA("undefined");function jt(A){return A!==null&&!X(A)&&A.constructor!==null&&!X(A.constructor)&&N(A.constructor.isBuffer)&&A.constructor.isBuffer(A)}var Se=G("ArrayBuffer");function _t(A){let e;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?e=ArrayBuffer.isView(A):e=A&&A.buffer&&Se(A.buffer),e}var zt=cA("string"),N=cA("function"),Fe=cA("number"),uA=A=>A!==null&&typeof A=="object",Vt=A=>A===!0||A===!1,BA=A=>{if(CA(A)!=="object")return!1;let e=MA(A);return(e===null||e===Object.prototype||Object.getPrototypeOf(e)===null)&&!(Symbol.toStringTag in A)&&!(Symbol.iterator in A)},Zt=G("Date"),Xt=G("File"),$t=G("Blob"),Ar=G("FileList"),er=A=>uA(A)&&N(A.pipe),tr=A=>{let e;return A&&(typeof FormData=="function"&&A instanceof FormData||N(A.append)&&((e=CA(A))==="formdata"||e==="object"&&N(A.toString)&&A.toString()==="[object FormData]"))},rr=G("URLSearchParams"),ir=A=>A.trim?A.trim():A.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,"");function $(A,e,{allOwnKeys:t=!1}={}){if(A===null||typeof A>"u")return;let r,n;if(typeof A!="object"&&(A=[A]),q(A))for(r=0,n=A.length;r<n;r++)e.call(null,A[r],r,A);else{let i=t?Object.getOwnPropertyNames(A):Object.keys(A),o=i.length,I;for(r=0;r<o;r++)I=i[r],e.call(null,A[I],I,A)}}function ke(A,e){e=e.toLowerCase();let t=Object.keys(A),r=t.length,n;for(;r-- >0;)if(n=t[r],e===n.toLowerCase())return n;return null}var Re=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global,be=A=>!X(A)&&A!==Re;function HA(){let{caseless:A}=be(this)&&this||{},e={},t=(r,n)=>{let i=A&&ke(e,n)||n;BA(e[i])&&BA(r)?e[i]=HA(e[i],r):BA(r)?e[i]=HA({},r):q(r)?e[i]=r.slice():e[i]=r};for(let r=0,n=arguments.length;r<n;r++)arguments[r]&&$(arguments[r],t);return e}var nr=(A,e,t,{allOwnKeys:r}={})=>($(e,(n,i)=>{t&&N(n)?A[i]=Z(n,t):A[i]=n},{allOwnKeys:r}),A),or=A=>(A.charCodeAt(0)===65279&&(A=A.slice(1)),A),ar=(A,e,t,r)=>{A.prototype=Object.create(e.prototype,r),A.prototype.constructor=A,Object.defineProperty(A,"super",{value:e.prototype}),t&&Object.assign(A.prototype,t)},sr=(A,e,t,r)=>{let n,i,o,I={};if(e=e||{},A==null)return e;do{for(n=Object.getOwnPropertyNames(A),i=n.length;i-- >0;)o=n[i],(!r||r(o,A,e))&&!I[o]&&(e[o]=A[o],I[o]=!0);A=t!==!1&&MA(A)}while(A&&(!t||t(A,e))&&A!==Object.prototype);return e},Ir=(A,e,t)=>{A=String(A),(t===void 0||t>A.length)&&(t=A.length),t-=e.length;let r=A.indexOf(e,t);return r!==-1&&r===t},gr=A=>{if(!A)return null;if(q(A))return A;let e=A.length;if(!Fe(e))return null;let t=new Array(e);for(;e-- >0;)t[e]=A[e];return t},lr=(A=>e=>A&&e instanceof A)(typeof Uint8Array<"u"&&MA(Uint8Array)),Br=(A,e)=>{let r=(A&&A[Symbol.iterator]).call(A),n;for(;(n=r.next())&&!n.done;){let i=n.value;e.call(A,i[0],i[1])}},Cr=(A,e)=>{let t,r=[];for(;(t=A.exec(e))!==null;)r.push(t);return r},cr=G("HTMLFormElement"),ur=A=>A.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,function(t,r,n){return r.toUpperCase()+n}),we=(({hasOwnProperty:A})=>(e,t)=>A.call(e,t))(Object.prototype),Er=G("RegExp"),Ue=(A,e)=>{let t=Object.getOwnPropertyDescriptors(A),r={};$(t,(n,i)=>{let o;(o=e(n,i,A))!==!1&&(r[i]=o||n)}),Object.defineProperties(A,r)},fr=A=>{Ue(A,(e,t)=>{if(N(A)&&["arguments","caller","callee"].indexOf(t)!==-1)return!1;let r=A[t];if(N(r)){if(e.enumerable=!1,"writable"in e){e.writable=!1;return}e.set||(e.set=()=>{throw Error("Can not rewrite read-only method '"+t+"'")})}})},Qr=(A,e)=>{let t={},r=n=>{n.forEach(i=>{t[i]=!0})};return q(A)?r(A):r(String(A).split(e)),t},pr=()=>{},dr=(A,e)=>(A=+A,Number.isFinite(A)?A:e),JA="abcdefghijklmnopqrstuvwxyz",De="0123456789",Ne={DIGIT:De,ALPHA:JA,ALPHA_DIGIT:JA+JA.toUpperCase()+De},mr=(A=16,e=Ne.ALPHA_DIGIT)=>{let t="",{length:r}=e;for(;A--;)t+=e[Math.random()*r|0];return t};function hr(A){return!!(A&&N(A.append)&&A[Symbol.toStringTag]==="FormData"&&A[Symbol.iterator])}var yr=A=>{let e=new Array(10),t=(r,n)=>{if(uA(r)){if(e.indexOf(r)>=0)return;if(!("toJSON"in r)){e[n]=r;let i=q(r)?[]:{};return $(r,(o,I)=>{let C=t(o,n+1);!X(C)&&(i[I]=C)}),e[n]=void 0,i}}return r};return t(A,0)},wr=G("AsyncFunction"),Dr=A=>A&&(uA(A)||N(A))&&N(A.then)&&N(A.catch),g={isArray:q,isArrayBuffer:Se,isBuffer:jt,isFormData:tr,isArrayBufferView:_t,isString:zt,isNumber:Fe,isBoolean:Vt,isObject:uA,isPlainObject:BA,isUndefined:X,isDate:Zt,isFile:Xt,isBlob:$t,isRegExp:Er,isFunction:N,isStream:er,isURLSearchParams:rr,isTypedArray:lr,isFileList:Ar,forEach:$,merge:HA,extend:nr,trim:ir,stripBOM:or,inherits:ar,toFlatObject:sr,kindOf:CA,kindOfTest:G,endsWith:Ir,toArray:gr,forEachEntry:Br,matchAll:Cr,isHTMLForm:cr,hasOwnProperty:we,hasOwnProp:we,reduceDescriptors:Ue,freezeMethods:fr,toObjectSet:Qr,toCamelCase:ur,noop:pr,toFiniteNumber:dr,findKey:ke,global:Re,isContextDefined:be,ALPHABET:Ne,generateString:mr,isSpecCompliantForm:hr,toJSONObject:yr,isAsyncFn:wr,isThenable:Dr};function K(A,e,t,r,n){Error.call(this),Error.captureStackTrace?Error.captureStackTrace(this,this.constructor):this.stack=new Error().stack,this.message=A,this.name="AxiosError",e&&(this.code=e),t&&(this.config=t),r&&(this.request=r),n&&(this.response=n)}g.inherits(K,Error,{toJSON:function(){return{message:this.message,name:this.name,description:this.description,number:this.number,fileName:this.fileName,lineNumber:this.lineNumber,columnNumber:this.columnNumber,stack:this.stack,config:g.toJSONObject(this.config),code:this.code,status:this.response&&this.response.status?this.response.status:null}}});var Ge=K.prototype,Te={};["ERR_BAD_OPTION_VALUE","ERR_BAD_OPTION","ECONNABORTED","ETIMEDOUT","ERR_NETWORK","ERR_FR_TOO_MANY_REDIRECTS","ERR_DEPRECATED","ERR_BAD_RESPONSE","ERR_BAD_REQUEST","ERR_CANCELED","ERR_NOT_SUPPORT","ERR_INVALID_URL"].forEach(A=>{Te[A]={value:A}});Object.defineProperties(K,Te);Object.defineProperty(Ge,"isAxiosError",{value:!0});K.from=(A,e,t,r,n,i)=>{let o=Object.create(Ge);return g.toFlatObject(A,o,function(C){return C!==Error.prototype},I=>I!=="isAxiosError"),K.call(o,A.message,e,t,r,n),o.cause=A,o.name=A.name,i&&Object.assign(o,i),o};var p=K;var EA=null;function YA(A){return g.isPlainObject(A)||g.isArray(A)}function xe(A){return g.endsWith(A,"[]")?A.slice(0,-2):A}function Le(A,e,t){return A?A.concat(e).map(function(n,i){return n=xe(n),!t&&i?"["+n+"]":n}).join(t?".":""):e}function Sr(A){return g.isArray(A)&&!A.some(YA)}var Fr=g.toFlatObject(g,{},null,function(e){return/^is[A-Z]/.test(e)});function kr(A,e,t){if(!g.isObject(A))throw new TypeError("target must be an object");e=e||new(EA||FormData),t=g.toFlatObject(t,{metaTokens:!0,dots:!1,indexes:!1},!1,function(c,Q){return!g.isUndefined(Q[c])});let r=t.metaTokens,n=t.visitor||s,i=t.dots,o=t.indexes,C=(t.Blob||typeof Blob<"u"&&Blob)&&g.isSpecCompliantForm(e);if(!g.isFunction(n))throw new TypeError("visitor must be a function");function l(u){if(u===null)return"";if(g.isDate(u))return u.toISOString();if(!C&&g.isBlob(u))throw new p("Blob is not supported. Use a Buffer instead.");return g.isArrayBuffer(u)||g.isTypedArray(u)?C&&typeof Blob=="function"?new Blob([u]):Buffer.from(u):u}function s(u,c,Q){let d=u;if(u&&!Q&&typeof u=="object"){if(g.endsWith(c,"{}"))c=r?c:c.slice(0,-2),u=JSON.stringify(u);else if(g.isArray(u)&&Sr(u)||(g.isFileList(u)||g.endsWith(c,"[]"))&&(d=g.toArray(u)))return c=xe(c),d.forEach(function(k,Dt){!(g.isUndefined(k)||k===null)&&e.append(o===!0?Le([c],Dt,i):o===null?c:c+"[]",l(k))}),!1}return YA(u)?!0:(e.append(Le(Q,c,i),l(u)),!1)}let a=[],E=Object.assign(Fr,{defaultVisitor:s,convertValue:l,isVisitable:YA});function B(u,c){if(!g.isUndefined(u)){if(a.indexOf(u)!==-1)throw Error("Circular reference detected in "+c.join("."));a.push(u),g.forEach(u,function(d,b){(!(g.isUndefined(d)||d===null)&&n.call(e,d,g.isString(b)?b.trim():b,c,E))===!0&&B(d,c?c.concat(b):[b])}),a.pop()}}if(!g.isObject(A))throw new TypeError("data must be an object");return B(A),e}var O=kr;function Oe(A){let e={"!":"%21","'":"%27","(":"%28",")":"%29","~":"%7E","%20":"+","%00":"\0"};return encodeURIComponent(A).replace(/[!'()~]|%20|%00/g,function(r){return e[r]})}function Pe(A,e){this._pairs=[],A&&O(A,this,e)}var Je=Pe.prototype;Je.append=function(e,t){this._pairs.push([e,t])};Je.toString=function(e){let t=e?function(r){return e.call(this,r,Oe)}:Oe;return this._pairs.map(function(n){return t(n[0])+"="+t(n[1])},"").join("&")};var fA=Pe;function Rr(A){return encodeURIComponent(A).replace(/%3A/gi,":").replace(/%24/g,"$").replace(/%2C/gi,",").replace(/%20/g,"+").replace(/%5B/gi,"[").replace(/%5D/gi,"]")}function AA(A,e,t){if(!e)return A;let r=t&&t.encode||Rr,n=t&&t.serialize,i;if(n?i=n(e,t):i=g.isURLSearchParams(e)?e.toString():new fA(e,t).toString(r),i){let o=A.indexOf("#");o!==-1&&(A=A.slice(0,o)),A+=(A.indexOf("?")===-1?"?":"&")+i}return A}var qA=class{constructor(){this.handlers=[]}use(e,t,r){return this.handlers.push({fulfilled:e,rejected:t,synchronous:r?r.synchronous:!1,runWhen:r?r.runWhen:null}),this.handlers.length-1}eject(e){this.handlers[e]&&(this.handlers[e]=null)}clear(){this.handlers&&(this.handlers=[])}forEach(e){g.forEach(this.handlers,function(r){r!==null&&e(r)})}},KA=qA;var QA={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1};var He=typeof URLSearchParams<"u"?URLSearchParams:fA;var Me=typeof FormData<"u"?FormData:null;var Ye=typeof Blob<"u"?Blob:null;var qe={isBrowser:!0,classes:{URLSearchParams:He,FormData:Me,Blob:Ye},protocols:["http","https","file","blob","url","data"]};var WA={};Ft(WA,{hasBrowserEnv:()=>Ke,hasStandardBrowserEnv:()=>br,hasStandardBrowserWebWorkerEnv:()=>Ur});var Ke=typeof window<"u"&&typeof document<"u",br=(A=>Ke&&["ReactNative","NativeScript","NS"].indexOf(A)<0)(typeof navigator<"u"&&navigator.product),Ur=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function";var D={...WA,...qe};function vA(A,e){return O(A,new D.classes.URLSearchParams,Object.assign({visitor:function(t,r,n,i){return D.isNode&&g.isBuffer(t)?(this.append(r,t.toString("base64")),!1):i.defaultVisitor.apply(this,arguments)}},e))}function Nr(A){return g.matchAll(/\w+|\[(\w*)]/g,A).map(e=>e[0]==="[]"?"":e[1]||e[0])}function Gr(A){let e={},t=Object.keys(A),r,n=t.length,i;for(r=0;r<n;r++)i=t[r],e[i]=A[i];return e}function Tr(A){function e(t,r,n,i){let o=t[i++],I=Number.isFinite(+o),C=i>=t.length;return o=!o&&g.isArray(n)?n.length:o,C?(g.hasOwnProp(n,o)?n[o]=[n[o],r]:n[o]=r,!I):((!n[o]||!g.isObject(n[o]))&&(n[o]=[]),e(t,r,n[o],i)&&g.isArray(n[o])&&(n[o]=Gr(n[o])),!I)}if(g.isFormData(A)&&g.isFunction(A.entries)){let t={};return g.forEachEntry(A,(r,n)=>{e(Nr(r),n,t,0)}),t}return null}var pA=Tr;function Lr(A,e,t){if(g.isString(A))try{return(e||JSON.parse)(A),g.trim(A)}catch(r){if(r.name!=="SyntaxError")throw r}return(t||JSON.stringify)(A)}var jA={transitional:QA,adapter:["xhr","http"],transformRequest:[function(e,t){let r=t.getContentType()||"",n=r.indexOf("application/json")>-1,i=g.isObject(e);if(i&&g.isHTMLForm(e)&&(e=new FormData(e)),g.isFormData(e))return n&&n?JSON.stringify(pA(e)):e;if(g.isArrayBuffer(e)||g.isBuffer(e)||g.isStream(e)||g.isFile(e)||g.isBlob(e))return e;if(g.isArrayBufferView(e))return e.buffer;if(g.isURLSearchParams(e))return t.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),e.toString();let I;if(i){if(r.indexOf("application/x-www-form-urlencoded")>-1)return vA(e,this.formSerializer).toString();if((I=g.isFileList(e))||r.indexOf("multipart/form-data")>-1){let C=this.env&&this.env.FormData;return O(I?{"files[]":e}:e,C&&new C,this.formSerializer)}}return i||n?(t.setContentType("application/json",!1),Lr(e)):e}],transformResponse:[function(e){let t=this.transitional||jA.transitional,r=t&&t.forcedJSONParsing,n=this.responseType==="json";if(e&&g.isString(e)&&(r&&!this.responseType||n)){let o=!(t&&t.silentJSONParsing)&&n;try{return JSON.parse(e)}catch(I){if(o)throw I.name==="SyntaxError"?p.from(I,p.ERR_BAD_RESPONSE,this,null,this.response):I}}return e}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:D.classes.FormData,Blob:D.classes.Blob},validateStatus:function(e){return e>=200&&e<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};g.forEach(["delete","get","head","post","put","patch"],A=>{jA.headers[A]={}});var W=jA;var xr=g.toObjectSet(["age","authorization","content-length","content-type","etag","expires","from","host","if-modified-since","if-unmodified-since","last-modified","location","max-forwards","proxy-authorization","referer","retry-after","user-agent"]),We=A=>{let e={},t,r,n;return A&&A.split(`
`).forEach(function(o){n=o.indexOf(":"),t=o.substring(0,n).trim().toLowerCase(),r=o.substring(n+1).trim(),!(!t||e[t]&&xr[t])&&(t==="set-cookie"?e[t]?e[t].push(r):e[t]=[r]:e[t]=e[t]?e[t]+", "+r:r)}),e};var ve=Symbol("internals");function eA(A){return A&&String(A).trim().toLowerCase()}function dA(A){return A===!1||A==null?A:g.isArray(A)?A.map(dA):String(A)}function Or(A){let e=Object.create(null),t=/([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g,r;for(;r=t.exec(A);)e[r[1]]=r[2];return e}var Pr=A=>/^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(A.trim());function _A(A,e,t,r,n){if(g.isFunction(r))return r.call(this,e,t);if(n&&(e=t),!!g.isString(e)){if(g.isString(r))return e.indexOf(r)!==-1;if(g.isRegExp(r))return r.test(e)}}function Jr(A){return A.trim().toLowerCase().replace(/([a-z\d])(\w*)/g,(e,t,r)=>t.toUpperCase()+r)}function Hr(A,e){let t=g.toCamelCase(" "+e);["get","set","has"].forEach(r=>{Object.defineProperty(A,r+t,{value:function(n,i,o){return this[r].call(this,e,n,i,o)},configurable:!0})})}var v=class{constructor(e){e&&this.set(e)}set(e,t,r){let n=this;function i(I,C,l){let s=eA(C);if(!s)throw new Error("header name must be a non-empty string");let a=g.findKey(n,s);(!a||n[a]===void 0||l===!0||l===void 0&&n[a]!==!1)&&(n[a||C]=dA(I))}let o=(I,C)=>g.forEach(I,(l,s)=>i(l,s,C));return g.isPlainObject(e)||e instanceof this.constructor?o(e,t):g.isString(e)&&(e=e.trim())&&!Pr(e)?o(We(e),t):e!=null&&i(t,e,r),this}get(e,t){if(e=eA(e),e){let r=g.findKey(this,e);if(r){let n=this[r];if(!t)return n;if(t===!0)return Or(n);if(g.isFunction(t))return t.call(this,n,r);if(g.isRegExp(t))return t.exec(n);throw new TypeError("parser must be boolean|regexp|function")}}}has(e,t){if(e=eA(e),e){let r=g.findKey(this,e);return!!(r&&this[r]!==void 0&&(!t||_A(this,this[r],r,t)))}return!1}delete(e,t){let r=this,n=!1;function i(o){if(o=eA(o),o){let I=g.findKey(r,o);I&&(!t||_A(r,r[I],I,t))&&(delete r[I],n=!0)}}return g.isArray(e)?e.forEach(i):i(e),n}clear(e){let t=Object.keys(this),r=t.length,n=!1;for(;r--;){let i=t[r];(!e||_A(this,this[i],i,e,!0))&&(delete this[i],n=!0)}return n}normalize(e){let t=this,r={};return g.forEach(this,(n,i)=>{let o=g.findKey(r,i);if(o){t[o]=dA(n),delete t[i];return}let I=e?Jr(i):String(i).trim();I!==i&&delete t[i],t[I]=dA(n),r[I]=!0}),this}concat(...e){return this.constructor.concat(this,...e)}toJSON(e){let t=Object.create(null);return g.forEach(this,(r,n)=>{r!=null&&r!==!1&&(t[n]=e&&g.isArray(r)?r.join(", "):r)}),t}[Symbol.iterator](){return Object.entries(this.toJSON())[Symbol.iterator]()}toString(){return Object.entries(this.toJSON()).map(([e,t])=>e+": "+t).join(`
`)}get[Symbol.toStringTag](){return"AxiosHeaders"}static from(e){return e instanceof this?e:new this(e)}static concat(e,...t){let r=new this(e);return t.forEach(n=>r.set(n)),r}static accessor(e){let r=(this[ve]=this[ve]={accessors:{}}).accessors,n=this.prototype;function i(o){let I=eA(o);r[I]||(Hr(n,o),r[I]=!0)}return g.isArray(e)?e.forEach(i):i(e),this}};v.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);g.reduceDescriptors(v.prototype,({value:A},e)=>{let t=e[0].toUpperCase()+e.slice(1);return{get:()=>A,set(r){this[t]=r}}});g.freezeMethods(v);var S=v;function tA(A,e){let t=this||W,r=e||t,n=S.from(r.headers),i=r.data;return g.forEach(A,function(I){i=I.call(t,i,n.normalize(),e?e.status:void 0)}),n.normalize(),i}function rA(A){return!!(A&&A.__CANCEL__)}function je(A,e,t){p.call(this,A??"canceled",p.ERR_CANCELED,e,t),this.name="CanceledError"}g.inherits(je,p,{__CANCEL__:!0});var P=je;function zA(A,e,t){let r=t.config.validateStatus;!t.status||!r||r(t.status)?A(t):e(new p("Request failed with status code "+t.status,[p.ERR_BAD_REQUEST,p.ERR_BAD_RESPONSE][Math.floor(t.status/100)-4],t.config,t.request,t))}var _e=D.hasStandardBrowserEnv?{write(A,e,t,r,n,i){let o=[A+"="+encodeURIComponent(e)];g.isNumber(t)&&o.push("expires="+new Date(t).toGMTString()),g.isString(r)&&o.push("path="+r),g.isString(n)&&o.push("domain="+n),i===!0&&o.push("secure"),document.cookie=o.join("; ")},read(A){let e=document.cookie.match(new RegExp("(^|;\\s*)("+A+")=([^;]*)"));return e?decodeURIComponent(e[3]):null},remove(A){this.write(A,"",Date.now()-864e5)}}:{write(){},read(){return null},remove(){}};function VA(A){return/^([a-z][a-z\d+\-.]*:)?\/\//i.test(A)}function ZA(A,e){return e?A.replace(/\/+$/,"")+"/"+e.replace(/^\/+/,""):A}function iA(A,e){return A&&!VA(e)?ZA(A,e):e}var ze=D.hasStandardBrowserEnv?function(){let e=/(msie|trident)/i.test(navigator.userAgent),t=document.createElement("a"),r;function n(i){let o=i;return e&&(t.setAttribute("href",o),o=t.href),t.setAttribute("href",o),{href:t.href,protocol:t.protocol?t.protocol.replace(/:$/,""):"",host:t.host,search:t.search?t.search.replace(/^\?/,""):"",hash:t.hash?t.hash.replace(/^#/,""):"",hostname:t.hostname,port:t.port,pathname:t.pathname.charAt(0)==="/"?t.pathname:"/"+t.pathname}}return r=n(window.location.href),function(o){let I=g.isString(o)?n(o):o;return I.protocol===r.protocol&&I.host===r.host}}():function(){return function(){return!0}}();function XA(A){let e=/^([-+\w]{1,25})(:?\/\/|:)/.exec(A);return e&&e[1]||""}function Mr(A,e){A=A||10;let t=new Array(A),r=new Array(A),n=0,i=0,o;return e=e!==void 0?e:1e3,function(C){let l=Date.now(),s=r[i];o||(o=l),t[n]=C,r[n]=l;let a=i,E=0;for(;a!==n;)E+=t[a++],a=a%A;if(n=(n+1)%A,n===i&&(i=(i+1)%A),l-o<e)return;let B=s&&l-s;return B?Math.round(E*1e3/B):void 0}}var Ve=Mr;function Ze(A,e){let t=0,r=Ve(50,250);return n=>{let i=n.loaded,o=n.lengthComputable?n.total:void 0,I=i-t,C=r(I),l=i<=o;t=i;let s={loaded:i,total:o,progress:o?i/o:void 0,bytes:I,rate:C||void 0,estimated:C&&o&&l?(o-i)/C:void 0,event:n};s[e?"download":"upload"]=!0,A(s)}}var Yr=typeof XMLHttpRequest<"u",Xe=Yr&&function(A){return new Promise(function(t,r){let n=A.data,i=S.from(A.headers).normalize(),{responseType:o,withXSRFToken:I}=A,C;function l(){A.cancelToken&&A.cancelToken.unsubscribe(C),A.signal&&A.signal.removeEventListener("abort",C)}let s;if(g.isFormData(n)){if(D.hasStandardBrowserEnv||D.hasStandardBrowserWebWorkerEnv)i.setContentType(!1);else if((s=i.getContentType())!==!1){let[c,...Q]=s?s.split(";").map(d=>d.trim()).filter(Boolean):[];i.setContentType([c||"multipart/form-data",...Q].join("; "))}}let a=new XMLHttpRequest;if(A.auth){let c=A.auth.username||"",Q=A.auth.password?unescape(encodeURIComponent(A.auth.password)):"";i.set("Authorization","Basic "+btoa(c+":"+Q))}let E=iA(A.baseURL,A.url);a.open(A.method.toUpperCase(),AA(E,A.params,A.paramsSerializer),!0),a.timeout=A.timeout;function B(){if(!a)return;let c=S.from("getAllResponseHeaders"in a&&a.getAllResponseHeaders()),d={data:!o||o==="text"||o==="json"?a.responseText:a.response,status:a.status,statusText:a.statusText,headers:c,config:A,request:a};zA(function(k){t(k),l()},function(k){r(k),l()},d),a=null}if("onloadend"in a?a.onloadend=B:a.onreadystatechange=function(){!a||a.readyState!==4||a.status===0&&!(a.responseURL&&a.responseURL.indexOf("file:")===0)||setTimeout(B)},a.onabort=function(){a&&(r(new p("Request aborted",p.ECONNABORTED,A,a)),a=null)},a.onerror=function(){r(new p("Network Error",p.ERR_NETWORK,A,a)),a=null},a.ontimeout=function(){let Q=A.timeout?"timeout of "+A.timeout+"ms exceeded":"timeout exceeded",d=A.transitional||QA;A.timeoutErrorMessage&&(Q=A.timeoutErrorMessage),r(new p(Q,d.clarifyTimeoutError?p.ETIMEDOUT:p.ECONNABORTED,A,a)),a=null},D.hasStandardBrowserEnv&&(I&&g.isFunction(I)&&(I=I(A)),I||I!==!1&&ze(E))){let c=A.xsrfHeaderName&&A.xsrfCookieName&&_e.read(A.xsrfCookieName);c&&i.set(A.xsrfHeaderName,c)}n===void 0&&i.setContentType(null),"setRequestHeader"in a&&g.forEach(i.toJSON(),function(Q,d){a.setRequestHeader(d,Q)}),g.isUndefined(A.withCredentials)||(a.withCredentials=!!A.withCredentials),o&&o!=="json"&&(a.responseType=A.responseType),typeof A.onDownloadProgress=="function"&&a.addEventListener("progress",Ze(A.onDownloadProgress,!0)),typeof A.onUploadProgress=="function"&&a.upload&&a.upload.addEventListener("progress",Ze(A.onUploadProgress)),(A.cancelToken||A.signal)&&(C=c=>{a&&(r(!c||c.type?new P(null,A,a):c),a.abort(),a=null)},A.cancelToken&&A.cancelToken.subscribe(C),A.signal&&(A.signal.aborted?C():A.signal.addEventListener("abort",C)));let u=XA(E);if(u&&D.protocols.indexOf(u)===-1){r(new p("Unsupported protocol "+u+":",p.ERR_BAD_REQUEST,A));return}a.send(n||null)})};var $A={http:EA,xhr:Xe};g.forEach($A,(A,e)=>{if(A){try{Object.defineProperty(A,"name",{value:e})}catch{}Object.defineProperty(A,"adapterName",{value:e})}});var $e=A=>`- ${A}`,qr=A=>g.isFunction(A)||A===null||A===!1,mA={getAdapter:A=>{A=g.isArray(A)?A:[A];let{length:e}=A,t,r,n={};for(let i=0;i<e;i++){t=A[i];let o;if(r=t,!qr(t)&&(r=$A[(o=String(t)).toLowerCase()],r===void 0))throw new p(`Unknown adapter '${o}'`);if(r)break;n[o||"#"+i]=r}if(!r){let i=Object.entries(n).map(([I,C])=>`adapter ${I} `+(C===!1?"is not supported by the environment":"is not available in the build")),o=e?i.length>1?`since :
`+i.map($e).join(`
`):" "+$e(i[0]):"as no adapter specified";throw new p("There is no suitable adapter to dispatch the request "+o,"ERR_NOT_SUPPORT")}return r},adapters:$A};function Ae(A){if(A.cancelToken&&A.cancelToken.throwIfRequested(),A.signal&&A.signal.aborted)throw new P(null,A)}function hA(A){return Ae(A),A.headers=S.from(A.headers),A.data=tA.call(A,A.transformRequest),["post","put","patch"].indexOf(A.method)!==-1&&A.headers.setContentType("application/x-www-form-urlencoded",!1),mA.getAdapter(A.adapter||W.adapter)(A).then(function(r){return Ae(A),r.data=tA.call(A,A.transformResponse,r),r.headers=S.from(r.headers),r},function(r){return rA(r)||(Ae(A),r&&r.response&&(r.response.data=tA.call(A,A.transformResponse,r.response),r.response.headers=S.from(r.response.headers))),Promise.reject(r)})}var At=A=>A instanceof S?A.toJSON():A;function L(A,e){e=e||{};let t={};function r(l,s,a){return g.isPlainObject(l)&&g.isPlainObject(s)?g.merge.call({caseless:a},l,s):g.isPlainObject(s)?g.merge({},s):g.isArray(s)?s.slice():s}function n(l,s,a){if(g.isUndefined(s)){if(!g.isUndefined(l))return r(void 0,l,a)}else return r(l,s,a)}function i(l,s){if(!g.isUndefined(s))return r(void 0,s)}function o(l,s){if(g.isUndefined(s)){if(!g.isUndefined(l))return r(void 0,l)}else return r(void 0,s)}function I(l,s,a){if(a in e)return r(l,s);if(a in A)return r(void 0,l)}let C={url:i,method:i,data:i,baseURL:o,transformRequest:o,transformResponse:o,paramsSerializer:o,timeout:o,timeoutMessage:o,withCredentials:o,withXSRFToken:o,adapter:o,responseType:o,xsrfCookieName:o,xsrfHeaderName:o,onUploadProgress:o,onDownloadProgress:o,decompress:o,maxContentLength:o,maxBodyLength:o,beforeRedirect:o,transport:o,httpAgent:o,httpsAgent:o,cancelToken:o,socketPath:o,responseEncoding:o,validateStatus:I,headers:(l,s)=>n(At(l),At(s),!0)};return g.forEach(Object.keys(Object.assign({},A,e)),function(s){let a=C[s]||n,E=a(A[s],e[s],s);g.isUndefined(E)&&a!==I||(t[s]=E)}),t}var yA="1.6.2";var ee={};["object","boolean","number","function","string","symbol"].forEach((A,e)=>{ee[A]=function(r){return typeof r===A||"a"+(e<1?"n ":" ")+A}});var et={};ee.transitional=function(e,t,r){function n(i,o){return"[Axios v"+yA+"] Transitional option '"+i+"'"+o+(r?". "+r:"")}return(i,o,I)=>{if(e===!1)throw new p(n(o," has been removed"+(t?" in "+t:"")),p.ERR_DEPRECATED);return t&&!et[o]&&(et[o]=!0,console.warn(n(o," has been deprecated since v"+t+" and will be removed in the near future"))),e?e(i,o,I):!0}};function Kr(A,e,t){if(typeof A!="object")throw new p("options must be an object",p.ERR_BAD_OPTION_VALUE);let r=Object.keys(A),n=r.length;for(;n-- >0;){let i=r[n],o=e[i];if(o){let I=A[i],C=I===void 0||o(I,i,A);if(C!==!0)throw new p("option "+i+" must be "+C,p.ERR_BAD_OPTION_VALUE);continue}if(t!==!0)throw new p("Unknown option "+i,p.ERR_BAD_OPTION)}}var wA={assertOptions:Kr,validators:ee};var J=wA.validators,j=class{constructor(e){this.defaults=e,this.interceptors={request:new KA,response:new KA}}request(e,t){typeof e=="string"?(t=t||{},t.url=e):t=e||{},t=L(this.defaults,t);let{transitional:r,paramsSerializer:n,headers:i}=t;r!==void 0&&wA.assertOptions(r,{silentJSONParsing:J.transitional(J.boolean),forcedJSONParsing:J.transitional(J.boolean),clarifyTimeoutError:J.transitional(J.boolean)},!1),n!=null&&(g.isFunction(n)?t.paramsSerializer={serialize:n}:wA.assertOptions(n,{encode:J.function,serialize:J.function},!0)),t.method=(t.method||this.defaults.method||"get").toLowerCase();let o=i&&g.merge(i.common,i[t.method]);i&&g.forEach(["delete","get","head","post","put","patch","common"],u=>{delete i[u]}),t.headers=S.concat(o,i);let I=[],C=!0;this.interceptors.request.forEach(function(c){typeof c.runWhen=="function"&&c.runWhen(t)===!1||(C=C&&c.synchronous,I.unshift(c.fulfilled,c.rejected))});let l=[];this.interceptors.response.forEach(function(c){l.push(c.fulfilled,c.rejected)});let s,a=0,E;if(!C){let u=[hA.bind(this),void 0];for(u.unshift.apply(u,I),u.push.apply(u,l),E=u.length,s=Promise.resolve(t);a<E;)s=s.then(u[a++],u[a++]);return s}E=I.length;let B=t;for(a=0;a<E;){let u=I[a++],c=I[a++];try{B=u(B)}catch(Q){c.call(this,Q);break}}try{s=hA.call(this,B)}catch(u){return Promise.reject(u)}for(a=0,E=l.length;a<E;)s=s.then(l[a++],l[a++]);return s}getUri(e){e=L(this.defaults,e);let t=iA(e.baseURL,e.url);return AA(t,e.params,e.paramsSerializer)}};g.forEach(["delete","get","head","options"],function(e){j.prototype[e]=function(t,r){return this.request(L(r||{},{method:e,url:t,data:(r||{}).data}))}});g.forEach(["post","put","patch"],function(e){function t(r){return function(i,o,I){return this.request(L(I||{},{method:e,headers:r?{"Content-Type":"multipart/form-data"}:{},url:i,data:o}))}}j.prototype[e]=t(),j.prototype[e+"Form"]=t(!0)});var nA=j;var te=class A{constructor(e){if(typeof e!="function")throw new TypeError("executor must be a function.");let t;this.promise=new Promise(function(i){t=i});let r=this;this.promise.then(n=>{if(!r._listeners)return;let i=r._listeners.length;for(;i-- >0;)r._listeners[i](n);r._listeners=null}),this.promise.then=n=>{let i,o=new Promise(I=>{r.subscribe(I),i=I}).then(n);return o.cancel=function(){r.unsubscribe(i)},o},e(function(i,o,I){r.reason||(r.reason=new P(i,o,I),t(r.reason))})}throwIfRequested(){if(this.reason)throw this.reason}subscribe(e){if(this.reason){e(this.reason);return}this._listeners?this._listeners.push(e):this._listeners=[e]}unsubscribe(e){if(!this._listeners)return;let t=this._listeners.indexOf(e);t!==-1&&this._listeners.splice(t,1)}static source(){let e;return{token:new A(function(n){e=n}),cancel:e}}},tt=te;function re(A){return function(t){return A.apply(null,t)}}function ie(A){return g.isObject(A)&&A.isAxiosError===!0}var ne={Continue:100,SwitchingProtocols:101,Processing:102,EarlyHints:103,Ok:200,Created:201,Accepted:202,NonAuthoritativeInformation:203,NoContent:204,ResetContent:205,PartialContent:206,MultiStatus:207,AlreadyReported:208,ImUsed:226,MultipleChoices:300,MovedPermanently:301,Found:302,SeeOther:303,NotModified:304,UseProxy:305,Unused:306,TemporaryRedirect:307,PermanentRedirect:308,BadRequest:400,Unauthorized:401,PaymentRequired:402,Forbidden:403,NotFound:404,MethodNotAllowed:405,NotAcceptable:406,ProxyAuthenticationRequired:407,RequestTimeout:408,Conflict:409,Gone:410,LengthRequired:411,PreconditionFailed:412,PayloadTooLarge:413,UriTooLong:414,UnsupportedMediaType:415,RangeNotSatisfiable:416,ExpectationFailed:417,ImATeapot:418,MisdirectedRequest:421,UnprocessableEntity:422,Locked:423,FailedDependency:424,TooEarly:425,UpgradeRequired:426,PreconditionRequired:428,TooManyRequests:429,RequestHeaderFieldsTooLarge:431,UnavailableForLegalReasons:451,InternalServerError:500,NotImplemented:501,BadGateway:502,ServiceUnavailable:503,GatewayTimeout:504,HttpVersionNotSupported:505,VariantAlsoNegotiates:506,InsufficientStorage:507,LoopDetected:508,NotExtended:510,NetworkAuthenticationRequired:511};Object.entries(ne).forEach(([A,e])=>{ne[e]=A});var rt=ne;function it(A){let e=new nA(A),t=Z(nA.prototype.request,e);return g.extend(t,nA.prototype,e,{allOwnKeys:!0}),g.extend(t,e,null,{allOwnKeys:!0}),t.create=function(n){return it(L(A,n))},t}var m=it(W);m.Axios=nA;m.CanceledError=P;m.CancelToken=tt;m.isCancel=rA;m.VERSION=yA;m.toFormData=O;m.AxiosError=p;m.Cancel=m.CanceledError;m.all=function(e){return Promise.all(e)};m.spread=re;m.isAxiosError=ie;m.mergeConfig=L;m.AxiosHeaders=S;m.formToJSON=A=>pA(g.isHTMLForm(A)?new FormData(A):A);m.getAdapter=mA.getAdapter;m.HttpStatusCode=rt;m.default=m;var _=m;var{Axios:La,AxiosError:xa,CanceledError:Oa,isCancel:Pa,CancelToken:Ja,VERSION:Ha,all:Ma,Cancel:Ya,isAxiosError:qa,spread:Ka,toFormData:Wa,AxiosHeaders:va,HttpStatusCode:ja,formToJSON:_a,getAdapter:za,mergeConfig:Va}=_;async function Wr(A,e){let t=A,r=null;if(t===null)r=new Worker(new URL("./web-workers/itk-wasm-pipeline.worker.js",import.meta.url),{type:"module"});else if(t.startsWith("http")){let n=await _.get(t,{responseType:"blob",params:e}),i=URL.createObjectURL(n.data);r=new Worker(i,{type:"module"})}else r=new Worker(t,{type:"module"});return r}var oA=Wr;function nt(A){let e=OA(A),t=A;return t.terminated=!1,t.workerProxy=e,t.originalTerminate=t.terminate,t.terminate=()=>{t.terminated=!0,t.workerProxy[xA](),t.originalTerminate()},{workerProxy:e,worker:t}}async function vr(A,e,t){let r;if(A!=null){let i=A;return i.workerProxy!==void 0?(r=i.workerProxy,{workerProxy:r,worker:i}):nt(A)}let n=await oA(e,t);return nt(n)}var ot=vr;async function jr(A,e,t){let r="unknown";typeof A!="string"?r=A.href:A.startsWith("http")?r=A:r=typeof e<"u"?`${e}/${A}`:A,r.endsWith(".js")&&(r=r.substring(0,r.length-3)),r.endsWith(".wasm")&&(r=r.substring(0,r.length-5));let n=`${r}.wasm`,o=(await _.get(n,{responseType:"arraybuffer",params:t})).data;return(await import(`${r}.js`)).default({wasmBinary:o})}var at=jr;var st=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,5,1,96,0,1,123,3,2,1,0,10,10,1,8,0,65,0,253,15,253,98,11]));var lt=typeof globalThis.SharedArrayBuffer=="function",It=new TextEncoder,gt=new TextDecoder("utf-8");function _r(A,e){let t={flags:"r",encoding:"binary"},r=A.fs_open(e,t.flags),i=A.fs_stat(e).size,o=null;lt?o=new SharedArrayBuffer(i):o=new ArrayBuffer(i);let I=new Uint8Array(o);return A.fs_read(r,I,0,i,0),A.fs_close(r),I}function Bt(A,e,t){let r=null;lt?r=new SharedArrayBuffer(t):r=new ArrayBuffer(t);let n=new Uint8Array(r),i=new Uint8Array(A.HEAPU8.buffer,e,t);return n.set(i),n}function y(A,e,t,r){let n=0;return e!==null&&(n=A.ccall("itk_wasm_input_array_alloc","number",["number","number","number","number"],[0,t,r,e.buffer.byteLength]),A.HEAPU8.set(new Uint8Array(e.buffer),n)),n}function z(A,e,t){let r=JSON.stringify(e),n=A.ccall("itk_wasm_input_json_alloc","number",["number","number","number"],[0,t,r.length]);A.writeAsciiToMemory(r,n,!1)}function U(A,e,t,r){let n=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,e,t]),i=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,e,t]),o=Bt(A,n,i);return x(r,o.buffer)}function oe(A,e){let t=A.ccall("itk_wasm_output_json_address","number",["number","number"],[0,e]),r=A.AsciiToString(t);return JSON.parse(r)}function zr(A,e,t,r){r!=null&&r.length>0&&r.forEach(function(l,s){switch(l.type){case f.TextStream:{let a=It.encode(l.data.data),E=y(A,a,s,0),B={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${E}`};z(A,B,s);break}case f.JsonCompatible:{let a=It.encode(JSON.stringify(l.data)),E=y(A,a,s,0),B={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${E}`};z(A,B,s);break}case f.BinaryStream:{let a=l.data.data,E=y(A,a,s,0),B={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${E}`};z(A,B,s);break}case f.TextFile:{A.fs_writeFile(l.data.path,l.data.data);break}case f.BinaryFile:{A.fs_writeFile(l.data.path,l.data.data);break}case f.Image:{let a=l.data,E=y(A,a.data,s,0),B=y(A,a.direction,s,1),u=typeof a.metadata?.entries<"u"?JSON.stringify(Array.from(a.metadata.entries())):"[]",c={imageType:a.imageType,name:a.name,origin:a.origin,spacing:a.spacing,direction:`data:application/vnd.itk.address,0:${B}`,size:a.size,data:`data:application/vnd.itk.address,0:${E}`,metadata:u};z(A,c,s);break}case f.Mesh:{let a=l.data,E=y(A,a.points,s,0),B=y(A,a.cells,s,1),u=y(A,a.pointData,s,2),c=y(A,a.cellData,s,3),Q={meshType:a.meshType,name:a.name,numberOfPoints:a.numberOfPoints,points:`data:application/vnd.itk.address,0:${E}`,numberOfCells:a.numberOfCells,cells:`data:application/vnd.itk.address,0:${B}`,cellBufferSize:a.cellBufferSize,numberOfPointPixels:a.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${u}`,numberOfCellPixels:a.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${c}`};z(A,Q,s);break}case f.PolyData:{let a=l.data,E=y(A,a.points,s,0),B=y(A,a.vertices,s,1),u=y(A,a.lines,s,2),c=y(A,a.polygons,s,3),Q=y(A,a.triangleStrips,s,4),d=y(A,a.pointData,s,5),b=y(A,a.pointData,s,6),k={polyDataType:a.polyDataType,name:a.name,numberOfPoints:a.numberOfPoints,points:`data:application/vnd.itk.address,0:${E}`,verticesBufferSize:a.verticesBufferSize,vertices:`data:application/vnd.itk.address,0:${B}`,linesBufferSize:a.linesBufferSize,lines:`data:application/vnd.itk.address,0:${u}`,polygonsBufferSize:a.polygonsBufferSize,polygons:`data:application/vnd.itk.address,0:${c}`,triangleStripsBufferSize:a.triangleStripsBufferSize,triangleStrips:`data:application/vnd.itk.address,0:${Q}`,numberOfPointPixels:a.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${d}`,numberOfCellPixels:a.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${b}`};z(A,k,s);break}default:throw Error("Unsupported input InterfaceType")}}),A.resetModuleStdout(),A.resetModuleStderr();let n=A.stackSave(),i=0;try{i=A.callMain(e.slice())}catch(l){throw typeof l=="number"&&(console.log("Exception while running pipeline:"),console.log("stdout:",A.getModuleStdout()),console.error("stderr:",A.getModuleStderr()),typeof A.getExceptionMessage<"u"?console.error("exception:",A.getExceptionMessage(l)):console.error("Build module in Debug mode for exception message information.")),l}finally{A.stackRestore(n)}let o=A.getModuleStdout(),I=A.getModuleStderr(),C=[];return t!=null&&t.length>0&&i===0&&t.forEach(function(l,s){let a=null;switch(l.type){case f.TextStream:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,s,0]),u=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,s,0]),c=new Uint8Array(A.HEAPU8.buffer,B,u);a={data:gt.decode(c)};break}case f.JsonCompatible:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,s,0]),u=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,s,0]),c=new Uint8Array(A.HEAPU8.buffer,B,u);a=JSON.parse(gt.decode(c));break}case f.BinaryStream:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,s,0]),u=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,s,0]);a={data:Bt(A,B,u)};break}case f.TextFile:{a={path:l.data.path,data:A.fs_readFile(l.data.path,{encoding:"utf8"})};break}case f.BinaryFile:{a={path:l.data.path,data:_r(A,l.data.path)};break}case f.Image:{let B=oe(A,s);B.data=U(A,s,0,B.imageType.componentType),B.direction=U(A,s,1,M.Float64),B.metadata=new Map(B.metadata),a=B;break}case f.Mesh:{let B=oe(A,s);B.numberOfPoints>0?B.points=U(A,s,0,B.meshType.pointComponentType):B.points=x(B.meshType.pointComponentType,new ArrayBuffer(0)),B.numberOfCells>0?B.cells=U(A,s,1,B.meshType.cellComponentType):B.cells=x(B.meshType.cellComponentType,new ArrayBuffer(0)),B.numberOfPointPixels>0?B.pointData=U(A,s,2,B.meshType.pointPixelComponentType):B.pointData=x(B.meshType.pointPixelComponentType,new ArrayBuffer(0)),B.numberOfCellPixels>0?B.cellData=U(A,s,3,B.meshType.cellPixelComponentType):B.cellData=x(B.meshType.cellPixelComponentType,new ArrayBuffer(0)),a=B;break}case f.PolyData:{let B=oe(A,s);B.numberOfPoints>0?B.points=U(A,s,0,M.Float32):B.points=new Float32Array,B.verticesBufferSize>0?B.vertices=U(A,s,1,h.UInt32):B.vertices=new Uint32Array,B.linesBufferSize>0?B.lines=U(A,s,2,h.UInt32):B.lines=new Uint32Array,B.polygonsBufferSize>0?B.polygons=U(A,s,3,h.UInt32):B.polygons=new Uint32Array,B.triangleStripsBufferSize>0?B.triangleStrips=U(A,s,4,h.UInt32):B.triangleStrips=new Uint32Array,B.numberOfPointPixels>0?B.pointData=U(A,s,5,B.polyDataType.pointPixelComponentType):B.pointData=x(B.polyDataType.pointPixelComponentType,new ArrayBuffer(0)),B.numberOfCellPixels>0?B.cellData=U(A,s,6,B.polyDataType.cellPixelComponentType):B.cellData=x(B.polyDataType.cellPixelComponentType,new ArrayBuffer(0)),a=B;break}default:throw Error("Unsupported output InterfaceType")}let E={type:l.type,data:a};C.push(E)}),{returnValue:i,stdout:o,stderr:I,outputs:C}}var Ct=zr;var Vr=typeof globalThis.SharedArrayBuffer<"u";function Zr(A,e){if(A==null)return[];let t=[];for(let r=0;r<A.length;r++){let n=Xr(A[r],e);n!==null&&t.push(n)}return t}function Xr(A,e){if(A==null)return null;let t=null;return A.buffer!==void 0?t=A.buffer:A.byteLength!==void 0&&(t=A),Vr&&t instanceof SharedArrayBuffer?null:e?t:t.slice(0)}var ct=Zr;function $r(A){return[A.data,A.direction]}var ut=$r;function Ai(A){return[A.points,A.pointData,A.cells,A.cellData]}var Et=Ai;function ei(A){return[A.points,A.vertices,A.lines,A.polygons,A.triangleStrips,A.pointData,A.cellData]}var ft=ei;var ti;function DA(){return ti}var ri;function Qt(){return ri}var ii;function SA(){return ii}var ae=new Map;function ni(){let A=SA();return typeof A>"u"&&(A=null),A}function pt(){let A=DA();return typeof A>"u"&&(A=new URL("/pipelines",document.location.origin).href),A}function FA(){let A=Qt();return typeof A>"u"&&(A={}),A}async function oi(A,e,t){let r=A,n=A;if(typeof A!="string"&&(r=new URL(A.href),n=r.href),ae.has(n))return ae.get(n);{let i=await at(A,e?.toString()??pt(),t??FA());return ae.set(n,i),i}}async function ai(A,e,t,r,n){if(!await st()){let Q="WebAssembly SIMD support is required -- please update your browser.";throw alert(Q),new Error(Q)}let i=n?.webWorker??null;if(i===!1){let Q=await oi(A.toString(),n?.pipelineBaseUrl,n?.pipelineQueryParams??FA());return Ct(Q,e,t,r)}let o=i,I=n?.pipelineWorkerUrl??ni(),C=typeof I!="string"&&typeof I?.href<"u"?I.href:I,{workerProxy:l,worker:s}=await ot(o,C,n?.pipelineQueryParams??FA());o=s;let a=[];r!=null&&r.length>0&&r.forEach(function(Q){if(Q.type===f.BinaryStream){let d=Q.data.data;a.push(d)}else if(Q.type===f.BinaryFile){let d=Q.data.data;a.push(d)}else if(Q.type===f.Image){let d=Q.data;d.data!==null&&a.push(...ut(d))}else if(Q.type===f.Mesh){let d=Q.data;a.push(...Et(d))}else if(Q.type===f.PolyData){let d=Q.data;a.push(...ft(d))}});let E=n?.pipelineBaseUrl??pt(),B=typeof E!="string"&&typeof E?.href<"u"?E.href:E,u=r!=null?PA(r,ct(a,n?.noCopy)):null,c=await l.runPipeline(A.toString(),B,e,t,u,n?.pipelineQueryParams??FA());return{returnValue:c.returnValue,stdout:c.stdout,stderr:c.stderr,outputs:c.outputs,webWorker:o}}var F=ai;var si=null;function dt(){return si}var se,Ii=`https://cdn.jsdelivr.net/npm/@itk-wasm/dicom@${kA}/dist/pipelines`;function Hs(A){se=A}function R(){if(typeof se<"u")return se;let A=DA();return typeof A<"u"?A:Ii}var Ie,gi=null;function mt(A){Ie=A}function w(){if(typeof Ie<"u")return Ie;let A=SA();return typeof A<"u"?A:gi}var V=null;async function ht(){let A=w(),e=typeof A!="string"&&typeof A?.href<"u"?A.href:A;V=await oA(e)}function js(A){V=A}async function T(){if(V!==null)return V.terminated&&await ht(),V;let A=dt();return A!==null?A:(await ht(),V)}async function li(A,e,t={}){let r=[{type:f.JsonCompatible},{type:f.Image}],n=A;if(A instanceof File){let k=await A.arrayBuffer();n={path:A.name,data:new Uint8Array(k)}}let i=e;if(e instanceof File){let k=await e.arrayBuffer();i={path:e.name,data:new Uint8Array(k)}}let o=[{type:f.BinaryFile,data:n},{type:f.BinaryFile,data:i}],I=[],C=n.path;I.push(C);let l=i.path;I.push(l);let s="0";I.push(s);let a="1";I.push(a),I.push("--memory-io"),t.colorOutput&&t.colorOutput&&I.push("--color-output"),t.configFile&&I.push("--config-file",t.configFile.toString()),t.frame&&I.push("--frame",t.frame.toString()),t.noPresentationStateOutput&&t.noPresentationStateOutput&&I.push("--no-presentation-state-output"),t.noBitmapOutput&&t.noBitmapOutput&&I.push("--no-bitmap-output");let E="apply-presentation-state-to-image",B=t?.webWorker;B===void 0&&(B=await T());let{webWorker:u,returnValue:c,stderr:Q,outputs:d}=await F(E,I,r,o,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:B,noCopy:t?.noCopy});if(c!==0&&Q!=="")throw new Error(Q);return{webWorker:u,presentationStateOutStream:d[0]?.data,outputImage:d[1]?.data}}var Bi=li;async function Ci(A,e={}){let t=[{type:f.BinaryStream}],r=A;if(A instanceof File){let c=await A.arrayBuffer();r={path:A.name,data:new Uint8Array(c)}}let n=[{type:f.BinaryFile,data:r}],i=[],o=r.path;i.push(o);let I="0";i.push(I),i.push("--memory-io"),e.readFileOnly&&e.readFileOnly&&i.push("--read-file-only"),e.readDataset&&e.readDataset&&i.push("--read-dataset"),e.readXferAuto&&e.readXferAuto&&i.push("--read-xfer-auto"),e.readXferDetect&&e.readXferDetect&&i.push("--read-xfer-detect"),e.readXferLittle&&e.readXferLittle&&i.push("--read-xfer-little"),e.readXferBig&&e.readXferBig&&i.push("--read-xfer-big"),e.readXferImplicit&&e.readXferImplicit&&i.push("--read-xfer-implicit"),e.acceptOddLength&&e.acceptOddLength&&i.push("--accept-odd-length"),e.assumeEvenLength&&e.assumeEvenLength&&i.push("--assume-even-length"),e.enableCp246&&e.enableCp246&&i.push("--enable-cp246"),e.disableCp246&&e.disableCp246&&i.push("--disable-cp246"),e.retainUn&&e.retainUn&&i.push("--retain-un"),e.convertUn&&e.convertUn&&i.push("--convert-un"),e.enableCorrection&&e.enableCorrection&&i.push("--enable-correction"),e.disableCorrection&&e.disableCorrection&&i.push("--disable-correction");let C="read-dicom-encapsulated-pdf",l=e?.webWorker;l===void 0&&(l=await T());let{webWorker:s,returnValue:a,stderr:E,outputs:B}=await F(C,i,t,n,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:l,noCopy:e?.noCopy});if(a!==0&&E!=="")throw new Error(E);return{webWorker:s,pdfBinaryOutput:(B[0]?.data).data}}var ci=Ci;async function ui(A,e={}){let t=[{type:f.TextStream}],r=A;if(A instanceof File){let c=await A.arrayBuffer();r={path:A.name,data:new Uint8Array(c)}}let n=[{type:f.BinaryFile,data:r}],i=[],o=r.path;i.push(o);let I="0";if(i.push(I),i.push("--memory-io"),e.readFileOnly&&e.readFileOnly&&i.push("--read-file-only"),e.readDataset&&e.readDataset&&i.push("--read-dataset"),e.readXferAuto&&e.readXferAuto&&i.push("--read-xfer-auto"),e.readXferDetect&&e.readXferDetect&&i.push("--read-xfer-detect"),e.readXferLittle&&e.readXferLittle&&i.push("--read-xfer-little"),e.readXferBig&&e.readXferBig&&i.push("--read-xfer-big"),e.readXferImplicit&&e.readXferImplicit&&i.push("--read-xfer-implicit"),e.processingDetails&&e.processingDetails&&i.push("--processing-details"),e.unknownRelationship&&e.unknownRelationship&&i.push("--unknown-relationship"),e.invalidItemValue&&e.invalidItemValue&&i.push("--invalid-item-value"),e.ignoreConstraints&&e.ignoreConstraints&&i.push("--ignore-constraints"),e.ignoreItemErrors&&e.ignoreItemErrors&&i.push("--ignore-item-errors"),e.skipInvalidItems&&e.skipInvalidItems&&i.push("--skip-invalid-items"),e.disableVrChecker&&e.disableVrChecker&&i.push("--disable-vr-checker"),e.charsetRequire&&e.charsetRequire&&i.push("--charset-require"),e.charsetAssume&&i.push("--charset-assume",e.charsetAssume.toString()),e.charsetCheckAll&&e.charsetCheckAll&&i.push("--charset-check-all"),e.convertToUtf8&&e.convertToUtf8&&i.push("--convert-to-utf8"),e.urlPrefix&&i.push("--url-prefix",e.urlPrefix.toString()),e.html32&&e.html32&&i.push("--html-32"),e.html40&&e.html40&&i.push("--html-40"),e.xhtml11&&e.xhtml11&&i.push("--xhtml-11"),e.addDocumentType&&e.addDocumentType&&i.push("--add-document-type"),e.cssReference){let c=n.length.toString();n.push({type:f.TextStream,data:{data:e.cssReference}}),i.push("--css-reference",c)}if(e.cssFile){let c=e.cssFile,Q=c;if(c instanceof File){let b=await c.arrayBuffer();Q={path:c.name,data:new TextDecoder().decode(b)}}i.push("--css-file"),n.push({type:f.TextFile,data:Q});let d=c instanceof File?c.name:c.path;i.push(d)}e.expandInline&&e.expandInline&&i.push("--expand-inline"),e.neverExpandInline&&e.neverExpandInline&&i.push("--never-expand-inline"),e.alwaysExpandInline&&e.alwaysExpandInline&&i.push("--always-expand-inline"),e.renderFullData&&e.renderFullData&&i.push("--render-full-data"),e.sectionTitleInline&&e.sectionTitleInline&&i.push("--section-title-inline"),e.documentTypeTitle&&e.documentTypeTitle&&i.push("--document-type-title"),e.patientInfoTitle&&e.patientInfoTitle&&i.push("--patient-info-title"),e.noDocumentHeader&&e.noDocumentHeader&&i.push("--no-document-header"),e.renderInlineCodes&&e.renderInlineCodes&&i.push("--render-inline-codes"),e.conceptNameCodes&&e.conceptNameCodes&&i.push("--concept-name-codes"),e.numericUnitCodes&&e.numericUnitCodes&&i.push("--numeric-unit-codes"),e.codeValueUnit&&e.codeValueUnit&&i.push("--code-value-unit"),e.codeMeaningUnit&&e.codeMeaningUnit&&i.push("--code-meaning-unit"),e.renderAllCodes&&e.renderAllCodes&&i.push("--render-all-codes"),e.codeDetailsTooltip&&e.codeDetailsTooltip&&i.push("--code-details-tooltip");let C="structured-report-to-html",l=e?.webWorker;l===void 0&&(l=await T());let{webWorker:s,returnValue:a,stderr:E,outputs:B}=await F(C,i,t,n,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:l,noCopy:e?.noCopy});if(a!==0&&E!=="")throw new Error(E);return{webWorker:s,outputText:(B[0]?.data).data}}var Ei=ui;async function fi(A,e={}){let t=[{type:f.TextStream}],r=A;if(A instanceof File){let c=await A.arrayBuffer();r={path:A.name,data:new Uint8Array(c)}}let n=[{type:f.BinaryFile,data:r}],i=[],o=r.path;i.push(o);let I="0";i.push(I),i.push("--memory-io"),e.unknownRelationship&&e.unknownRelationship&&i.push("--unknown-relationship"),e.invalidItemValue&&e.invalidItemValue&&i.push("--invalid-item-value"),e.ignoreConstraints&&e.ignoreConstraints&&i.push("--ignore-constraints"),e.ignoreItemErrors&&e.ignoreItemErrors&&i.push("--ignore-item-errors"),e.skipInvalidItems&&e.skipInvalidItems&&i.push("--skip-invalid-items"),e.noDocumentHeader&&e.noDocumentHeader&&i.push("--no-document-header"),e.numberNestedItems&&e.numberNestedItems&&i.push("--number-nested-items"),e.shortenLongValues&&e.shortenLongValues&&i.push("--shorten-long-values"),e.printInstanceUid&&e.printInstanceUid&&i.push("--print-instance-uid"),e.printSopclassShort&&e.printSopclassShort&&i.push("--print-sopclass-short"),e.printSopclassLong&&e.printSopclassLong&&i.push("--print-sopclass-long"),e.printSopclassUid&&e.printSopclassUid&&i.push("--print-sopclass-uid"),e.printAllCodes&&e.printAllCodes&&i.push("--print-all-codes"),e.printInvalidCodes&&e.printInvalidCodes&&i.push("--print-invalid-codes"),e.printTemplateId&&e.printTemplateId&&i.push("--print-template-id"),e.indicateEnhanced&&e.indicateEnhanced&&i.push("--indicate-enhanced"),e.printColor&&e.printColor&&i.push("--print-color");let C="structured-report-to-text",l=e?.webWorker;l===void 0&&(l=await T());let{webWorker:s,returnValue:a,stderr:E,outputs:B}=await F(C,i,t,n,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:l,noCopy:e?.noCopy});if(a!==0&&E!=="")throw new Error(E);return{webWorker:s,outputText:(B[0]?.data).data}}var Qi=fi;async function pi(A,e={}){let t=[{type:f.JsonCompatible}],r=A;if(A instanceof File){let u=await A.arrayBuffer();r={path:A.name,data:new Uint8Array(u)}}let n=[{type:f.BinaryFile,data:r}],i=[],o=r.path;i.push(o);let I="0";if(i.push(I),i.push("--memory-io"),typeof e.tagsToRead<"u"){let u=n.length.toString();n.push({type:f.JsonCompatible,data:e.tagsToRead}),i.push("--tags-to-read",u)}let C="read-dicom-tags",{webWorker:l,returnValue:s,stderr:a,outputs:E}=await F(C,i,t,n,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:e?.webWorker??null});if(s!==0)throw new Error(a);return{webWorker:l,tags:E[0].data}}var di=pi;async function mi(A,e=!1,t={}){let r=[{type:f.Image},{type:f.JsonCompatible}],n=[],i=[],o="0";i.push(o);let I="1";i.push(I),i.push("--memory-io"),i.push("--input-images"),A.forEach(u=>{n.push({type:f.BinaryFile,data:u}),i.push(u.path)}),typeof e<"u"&&e&&i.push("--single-sorted-series");let C="read-image-dicom-file-series",{webWorker:l,returnValue:s,stderr:a,outputs:E}=await F(C,i,r,n,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:t?.webWorker??null});if(s!==0)throw new Error(a);return{webWorker:l,outputImage:E[0].data,sortedFilenames:E[1].data}}var ge=mi;var hi=typeof globalThis.navigator?.hardwareConcurrency=="number"?globalThis.navigator.hardwareConcurrency:4,yt=8;async function yi(A={inputImages:[]}){let e=A.webWorkerPool??null;e===null&&(e=new GA(hi,ge));let t=[];if(A.inputImages.length<1)throw new Error('"input-images" option must have a length > 1');if(await Promise.all(A.inputImages.map(async r=>{let n=r;if(r instanceof File){let i=await r.arrayBuffer();n={path:r.name,data:new Uint8Array(i)}}t.push(n)})),A.singleSortedSeries){let r=[];for(let C=0;C<t.length;C+=yt){let l=t.slice(C,C+yt);r.push([l,A.singleSortedSeries,{}])}let n=await e.runTasks(r).promise,i=n.map(C=>C.outputImage),o=n.reduce((C,l)=>C.concat(l.sortedFilenames),[]);return{outputImage:UA(i),webWorkerPool:e,sortedFilenames:o}}else{let r=[[t,A.singleSortedSeries,{}]],n=await e.runTasks(r).promise;return{outputImage:n[0].outputImage,webWorkerPool:e,sortedFilenames:n[0].sortedFilenames}}}var wi=yi;async function Di(A={files:[]}){let e=[{type:f.JsonCompatible}],t=[],r=[],n="0";if(r.push(n),r.push("--memory-io"),A.files){if(A.files.length<1)throw new Error('"files" option must have a length > 1');r.push("--files"),await Promise.all(A.files.map(async E=>{let B=E;if(E instanceof File){let c=await E.arrayBuffer();B={path:E.name,data:new Uint8Array(c)}}t.push({type:f.BinaryFile,data:B});let u=E instanceof File?E.name:B.path;r.push(u)}))}let i="image-sets-normalization",o=A?.webWorker;o===void 0&&(o=await T());let{webWorker:I,returnValue:C,stderr:l,outputs:s}=await F(i,r,e,t,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:o,noCopy:A?.noCopy});if(C!==0&&l!=="")throw new Error(l);return{webWorker:I,imageSetsMetadata:s[0]?.data}}var Si=Di;var wt='data:text/javascript;charset=utf-8,var tt=Object.defineProperty;var et=(A,I)=>{for(var t in I)tt(A,t,{get:I[t],enumerable:!0})};var vA=Symbol("Comlink.proxy"),gt=Symbol("Comlink.endpoint"),rt=Symbol("Comlink.releaseProxy"),mA=Symbol("Comlink.finalizer"),eA=Symbol("Comlink.thrown"),$A=A=>typeof A=="object"&&A!==null||typeof A=="function",it={canHandle:A=>$A(A)&&A[vA],serialize(A){let{port1:I,port2:t}=new MessageChannel;return oA(A,I),[t,[t]]},deserialize(A){return A.start(),st(A)}},ot={canHandle:A=>$A(A)&&eA in A,serialize({value:A}){let I;return A instanceof Error?I={isError:!0,value:{message:A.message,name:A.name,stack:A.stack}}:I={isError:!1,value:A},[I,[]]},deserialize(A){throw A.isError?Object.assign(new Error(A.value.message),A.value):A.value}},AI=new Map([["proxy",it],["throw",ot]]);function Bt(A,I){for(let t of A)if(I===t||t==="*"||t instanceof RegExp&&t.test(I))return!0;return!1}function oA(A,I=globalThis,t=["*"]){I.addEventListener("message",function e(g){if(!g||!g.data)return;if(!Bt(t,g.origin)){console.warn(`Invalid origin \'${g.origin}\' for comlink proxy`);return}let{id:r,type:i,path:s}=Object.assign({path:[]},g.data),a=(g.data.argumentList||[]).map(b),n;try{let C=s.slice(0,-1).reduce((f,Q)=>f[Q],A),o=s.reduce((f,Q)=>f[Q],A);switch(i){case"GET":n=o;break;case"SET":C[s.slice(-1)[0]]=b(g.data.value),n=!0;break;case"APPLY":n=o.apply(C,a);break;case"CONSTRUCT":{let f=new o(...a);n=at(f)}break;case"ENDPOINT":{let{port1:f,port2:Q}=new MessageChannel;oA(A,Q),n=SA(f,[f])}break;case"RELEASE":n=void 0;break;default:return}}catch(C){n={value:C,[eA]:0}}Promise.resolve(n).catch(C=>({value:C,[eA]:0})).then(C=>{let[o,f]=iA(C);I.postMessage(Object.assign(Object.assign({},o),{id:r}),f),i==="RELEASE"&&(I.removeEventListener("message",e),II(I),mA in A&&typeof A[mA]=="function"&&A[mA]())}).catch(C=>{let[o,f]=iA({value:new TypeError("Unserializable return value"),[eA]:0});I.postMessage(Object.assign(Object.assign({},o),{id:r}),f)})}),I.start&&I.start()}function Ct(A){return A.constructor.name==="MessagePort"}function II(A){Ct(A)&&A.close()}function st(A,I){return pA(A,[],I)}function tA(A){if(A)throw new Error("Proxy has been released and is not useable")}function tI(A){return M(A,{type:"RELEASE"}).then(()=>{II(A)})}var gA=new WeakMap,rA="FinalizationRegistry"in globalThis&&new FinalizationRegistry(A=>{let I=(gA.get(A)||0)-1;gA.set(A,I),I===0&&tI(A)});function Qt(A,I){let t=(gA.get(I)||0)+1;gA.set(I,t),rA&&rA.register(A,I,A)}function nt(A){rA&&rA.unregister(A)}function pA(A,I=[],t=function(){}){let e=!1,g=new Proxy(t,{get(r,i){if(tA(e),i===rt)return()=>{nt(g),tI(A),e=!0};if(i==="then"){if(I.length===0)return{then:()=>g};let s=M(A,{type:"GET",path:I.map(a=>a.toString())}).then(b);return s.then.bind(s)}return pA(A,[...I,i])},set(r,i,s){tA(e);let[a,n]=iA(s);return M(A,{type:"SET",path:[...I,i].map(C=>C.toString()),value:a},n).then(b)},apply(r,i,s){tA(e);let a=I[I.length-1];if(a===gt)return M(A,{type:"ENDPOINT"}).then(b);if(a==="bind")return pA(A,I.slice(0,-1));let[n,C]=_A(s);return M(A,{type:"APPLY",path:I.map(o=>o.toString()),argumentList:n},C).then(b)},construct(r,i){tA(e);let[s,a]=_A(i);return M(A,{type:"CONSTRUCT",path:I.map(n=>n.toString()),argumentList:s},a).then(b)}});return Qt(g,A),g}function Et(A){return Array.prototype.concat.apply([],A)}function _A(A){let I=A.map(iA);return[I.map(t=>t[0]),Et(I.map(t=>t[1]))]}var eI=new WeakMap;function SA(A,I){return eI.set(A,I),A}function at(A){return Object.assign(A,{[vA]:!0})}function iA(A){for(let[I,t]of AI)if(t.canHandle(A)){let[e,g]=t.serialize(A);return[{type:"HANDLER",name:I,value:e},g]}return[{type:"RAW",value:A},eI.get(A)||[]]}function b(A){switch(A.type){case"HANDLER":return AI.get(A.name).deserialize(A.value);case"RAW":return A.value}}function M(A,I,t){return new Promise(e=>{let g=ct();A.addEventListener("message",function r(i){!i.data||!i.data.id||i.data.id!==g||(A.removeEventListener("message",r),e(i.data))}),A.start&&A.start(),A.postMessage(Object.assign({id:g},I),t)})}function ct(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}function W(A,I){return function(){return A.apply(I,arguments)}}var{toString:ft}=Object.prototype,{getPrototypeOf:NA}=Object,CA=(A=>I=>{let t=ft.call(I);return A[t]||(A[t]=t.slice(8,-1).toLowerCase())})(Object.create(null)),U=A=>(A=A.toLowerCase(),I=>CA(I)===A),sA=A=>I=>typeof I===A,{isArray:q}=Array,Z=sA("undefined");function lt(A){return A!==null&&!Z(A)&&A.constructor!==null&&!Z(A.constructor)&&F(A.constructor.isBuffer)&&A.constructor.isBuffer(A)}var oI=U("ArrayBuffer");function Dt(A){let I;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?I=ArrayBuffer.isView(A):I=A&&A.buffer&&oI(A.buffer),I}var ut=sA("string"),F=sA("function"),BI=sA("number"),QA=A=>A!==null&&typeof A=="object",ht=A=>A===!0||A===!1,BA=A=>{if(CA(A)!=="object")return!1;let I=NA(A);return(I===null||I===Object.prototype||Object.getPrototypeOf(I)===null)&&!(Symbol.toStringTag in A)&&!(Symbol.iterator in A)},dt=U("Date"),yt=U("File"),wt=U("Blob"),mt=U("FileList"),pt=A=>QA(A)&&F(A.pipe),St=A=>{let I;return A&&(typeof FormData=="function"&&A instanceof FormData||F(A.append)&&((I=CA(A))==="formdata"||I==="object"&&F(A.toString)&&A.toString()==="[object FormData]"))},Ft=U("URLSearchParams"),Rt=A=>A.trim?A.trim():A.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,"");function V(A,I,{allOwnKeys:t=!1}={}){if(A===null||typeof A>"u")return;let e,g;if(typeof A!="object"&&(A=[A]),q(A))for(e=0,g=A.length;e<g;e++)I.call(null,A[e],e,A);else{let r=t?Object.getOwnPropertyNames(A):Object.keys(A),i=r.length,s;for(e=0;e<i;e++)s=r[e],I.call(null,A[s],s,A)}}function CI(A,I){I=I.toLowerCase();let t=Object.keys(A),e=t.length,g;for(;e-- >0;)if(g=t[e],I===g.toLowerCase())return g;return null}var sI=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global,QI=A=>!Z(A)&&A!==sI;function RA(){let{caseless:A}=QI(this)&&this||{},I={},t=(e,g)=>{let r=A&&CI(I,g)||g;BA(I[r])&&BA(e)?I[r]=RA(I[r],e):BA(e)?I[r]=RA({},e):q(e)?I[r]=e.slice():I[r]=e};for(let e=0,g=arguments.length;e<g;e++)arguments[e]&&V(arguments[e],t);return I}var Nt=(A,I,t,{allOwnKeys:e}={})=>(V(I,(g,r)=>{t&&F(g)?A[r]=W(g,t):A[r]=g},{allOwnKeys:e}),A),Ut=A=>(A.charCodeAt(0)===65279&&(A=A.slice(1)),A),Gt=(A,I,t,e)=>{A.prototype=Object.create(I.prototype,e),A.prototype.constructor=A,Object.defineProperty(A,"super",{value:I.prototype}),t&&Object.assign(A.prototype,t)},kt=(A,I,t,e)=>{let g,r,i,s={};if(I=I||{},A==null)return I;do{for(g=Object.getOwnPropertyNames(A),r=g.length;r-- >0;)i=g[r],(!e||e(i,A,I))&&!s[i]&&(I[i]=A[i],s[i]=!0);A=t!==!1&&NA(A)}while(A&&(!t||t(A,I))&&A!==Object.prototype);return I},Lt=(A,I,t)=>{A=String(A),(t===void 0||t>A.length)&&(t=A.length),t-=I.length;let e=A.indexOf(I,t);return e!==-1&&e===t},Jt=A=>{if(!A)return null;if(q(A))return A;let I=A.length;if(!BI(I))return null;let t=new Array(I);for(;I-- >0;)t[I]=A[I];return t},Ht=(A=>I=>A&&I instanceof A)(typeof Uint8Array<"u"&&NA(Uint8Array)),Yt=(A,I)=>{let e=(A&&A[Symbol.iterator]).call(A),g;for(;(g=e.next())&&!g.done;){let r=g.value;I.call(A,r[0],r[1])}},bt=(A,I)=>{let t,e=[];for(;(t=A.exec(I))!==null;)e.push(t);return e},Mt=U("HTMLFormElement"),qt=A=>A.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,function(t,e,g){return e.toUpperCase()+g}),rI=(({hasOwnProperty:A})=>(I,t)=>A.call(I,t))(Object.prototype),Kt=U("RegExp"),nI=(A,I)=>{let t=Object.getOwnPropertyDescriptors(A),e={};V(t,(g,r)=>{let i;(i=I(g,r,A))!==!1&&(e[r]=i||g)}),Object.defineProperties(A,e)},Ot=A=>{nI(A,(I,t)=>{if(F(A)&&["arguments","caller","callee"].indexOf(t)!==-1)return!1;let e=A[t];if(F(e)){if(I.enumerable=!1,"writable"in I){I.writable=!1;return}I.set||(I.set=()=>{throw Error("Can not rewrite read-only method \'"+t+"\'")})}})},Tt=(A,I)=>{let t={},e=g=>{g.forEach(r=>{t[r]=!0})};return q(A)?e(A):e(String(A).split(I)),t},xt=()=>{},Pt=(A,I)=>(A=+A,Number.isFinite(A)?A:I),FA="abcdefghijklmnopqrstuvwxyz",iI="0123456789",EI={DIGIT:iI,ALPHA:FA,ALPHA_DIGIT:FA+FA.toUpperCase()+iI},jt=(A=16,I=EI.ALPHA_DIGIT)=>{let t="",{length:e}=I;for(;A--;)t+=I[Math.random()*e|0];return t};function Wt(A){return!!(A&&F(A.append)&&A[Symbol.toStringTag]==="FormData"&&A[Symbol.iterator])}var Zt=A=>{let I=new Array(10),t=(e,g)=>{if(QA(e)){if(I.indexOf(e)>=0)return;if(!("toJSON"in e)){I[g]=e;let r=q(e)?[]:{};return V(e,(i,s)=>{let a=t(i,g+1);!Z(a)&&(r[s]=a)}),I[g]=void 0,r}}return e};return t(A,0)},Vt=U("AsyncFunction"),Xt=A=>A&&(QA(A)||F(A))&&F(A.then)&&F(A.catch),B={isArray:q,isArrayBuffer:oI,isBuffer:lt,isFormData:St,isArrayBufferView:Dt,isString:ut,isNumber:BI,isBoolean:ht,isObject:QA,isPlainObject:BA,isUndefined:Z,isDate:dt,isFile:yt,isBlob:wt,isRegExp:Kt,isFunction:F,isStream:pt,isURLSearchParams:Ft,isTypedArray:Ht,isFileList:mt,forEach:V,merge:RA,extend:Nt,trim:Rt,stripBOM:Ut,inherits:Gt,toFlatObject:kt,kindOf:CA,kindOfTest:U,endsWith:Lt,toArray:Jt,forEachEntry:Yt,matchAll:bt,isHTMLForm:Mt,hasOwnProperty:rI,hasOwnProp:rI,reduceDescriptors:nI,freezeMethods:Ot,toObjectSet:Tt,toCamelCase:qt,noop:xt,toFiniteNumber:Pt,findKey:CI,global:sI,isContextDefined:QI,ALPHABET:EI,generateString:jt,isSpecCompliantForm:Wt,toJSONObject:Zt,isAsyncFn:Vt,isThenable:Xt};function K(A,I,t,e,g){Error.call(this),Error.captureStackTrace?Error.captureStackTrace(this,this.constructor):this.stack=new Error().stack,this.message=A,this.name="AxiosError",I&&(this.code=I),t&&(this.config=t),e&&(this.request=e),g&&(this.response=g)}B.inherits(K,Error,{toJSON:function(){return{message:this.message,name:this.name,description:this.description,number:this.number,fileName:this.fileName,lineNumber:this.lineNumber,columnNumber:this.columnNumber,stack:this.stack,config:B.toJSONObject(this.config),code:this.code,status:this.response&&this.response.status?this.response.status:null}}});var aI=K.prototype,cI={};["ERR_BAD_OPTION_VALUE","ERR_BAD_OPTION","ECONNABORTED","ETIMEDOUT","ERR_NETWORK","ERR_FR_TOO_MANY_REDIRECTS","ERR_DEPRECATED","ERR_BAD_RESPONSE","ERR_BAD_REQUEST","ERR_CANCELED","ERR_NOT_SUPPORT","ERR_INVALID_URL"].forEach(A=>{cI[A]={value:A}});Object.defineProperties(K,cI);Object.defineProperty(aI,"isAxiosError",{value:!0});K.from=(A,I,t,e,g,r)=>{let i=Object.create(aI);return B.toFlatObject(A,i,function(a){return a!==Error.prototype},s=>s!=="isAxiosError"),K.call(i,A.message,I,t,e,g),i.cause=A,i.name=A.name,r&&Object.assign(i,r),i};var l=K;var nA=null;function UA(A){return B.isPlainObject(A)||B.isArray(A)}function lI(A){return B.endsWith(A,"[]")?A.slice(0,-2):A}function fI(A,I,t){return A?A.concat(I).map(function(g,r){return g=lI(g),!t&&r?"["+g+"]":g}).join(t?".":""):I}function zt(A){return B.isArray(A)&&!A.some(UA)}var _t=B.toFlatObject(B,{},null,function(I){return/^is[A-Z]/.test(I)});function vt(A,I,t){if(!B.isObject(A))throw new TypeError("target must be an object");I=I||new(nA||FormData),t=B.toFlatObject(t,{metaTokens:!0,dots:!1,indexes:!1},!1,function(c,u){return!B.isUndefined(u[c])});let e=t.metaTokens,g=t.visitor||C,r=t.dots,i=t.indexes,a=(t.Blob||typeof Blob<"u"&&Blob)&&B.isSpecCompliantForm(I);if(!B.isFunction(g))throw new TypeError("visitor must be a function");function n(E){if(E===null)return"";if(B.isDate(E))return E.toISOString();if(!a&&B.isBlob(E))throw new l("Blob is not supported. Use a Buffer instead.");return B.isArrayBuffer(E)||B.isTypedArray(E)?a&&typeof Blob=="function"?new Blob([E]):Buffer.from(E):E}function C(E,c,u){let d=E;if(E&&!u&&typeof E=="object"){if(B.endsWith(c,"{}"))c=e?c:c.slice(0,-2),E=JSON.stringify(E);else if(B.isArray(E)&&zt(E)||(B.isFileList(E)||B.endsWith(c,"[]"))&&(d=B.toArray(E)))return c=lI(c),d.forEach(function(N,It){!(B.isUndefined(N)||N===null)&&I.append(i===!0?fI([c],It,r):i===null?c:c+"[]",n(N))}),!1}return UA(E)?!0:(I.append(fI(u,c,r),n(E)),!1)}let o=[],f=Object.assign(_t,{defaultVisitor:C,convertValue:n,isVisitable:UA});function Q(E,c){if(!B.isUndefined(E)){if(o.indexOf(E)!==-1)throw Error("Circular reference detected in "+c.join("."));o.push(E),B.forEach(E,function(d,R){(!(B.isUndefined(d)||d===null)&&g.call(I,d,B.isString(R)?R.trim():R,c,f))===!0&&Q(d,c?c.concat(R):[R])}),o.pop()}}if(!B.isObject(A))throw new TypeError("data must be an object");return Q(A),I}var L=vt;function DI(A){let I={"!":"%2521","\'":"%2527","(":"%2528",")":"%2529","~":"%257E","%2520":"+","%2500":"\\0"};return encodeURIComponent(A).replace(/[!\'()~]|%2520|%2500/g,function(e){return I[e]})}function uI(A,I){this._pairs=[],A&&L(A,this,I)}var hI=uI.prototype;hI.append=function(I,t){this._pairs.push([I,t])};hI.toString=function(I){let t=I?function(e){return I.call(this,e,DI)}:DI;return this._pairs.map(function(g){return t(g[0])+"="+t(g[1])},"").join("&")};var EA=uI;function $t(A){return encodeURIComponent(A).replace(/%253A/gi,":").replace(/%2524/g,"$").replace(/%252C/gi,",").replace(/%2520/g,"+").replace(/%255B/gi,"[").replace(/%255D/gi,"]")}function X(A,I,t){if(!I)return A;let e=t&&t.encode||$t,g=t&&t.serialize,r;if(g?r=g(I,t):r=B.isURLSearchParams(I)?I.toString():new EA(I,t).toString(e),r){let i=A.indexOf("%23");i!==-1&&(A=A.slice(0,i)),A+=(A.indexOf("?")===-1?"?":"&")+r}return A}var GA=class{constructor(){this.handlers=[]}use(I,t,e){return this.handlers.push({fulfilled:I,rejected:t,synchronous:e?e.synchronous:!1,runWhen:e?e.runWhen:null}),this.handlers.length-1}eject(I){this.handlers[I]&&(this.handlers[I]=null)}clear(){this.handlers&&(this.handlers=[])}forEach(I){B.forEach(this.handlers,function(e){e!==null&&I(e)})}},kA=GA;var aA={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1};var dI=typeof URLSearchParams<"u"?URLSearchParams:EA;var yI=typeof FormData<"u"?FormData:null;var wI=typeof Blob<"u"?Blob:null;var mI={isBrowser:!0,classes:{URLSearchParams:dI,FormData:yI,Blob:wI},protocols:["http","https","file","blob","url","data"]};var LA={};et(LA,{hasBrowserEnv:()=>pI,hasStandardBrowserEnv:()=>Ae,hasStandardBrowserWebWorkerEnv:()=>Ie});var pI=typeof window<"u"&&typeof document<"u",Ae=(A=>pI&&["ReactNative","NativeScript","NS"].indexOf(A)<0)(typeof navigator<"u"&&navigator.product),Ie=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function";var w={...LA,...mI};function JA(A,I){return L(A,new w.classes.URLSearchParams,Object.assign({visitor:function(t,e,g,r){return w.isNode&&B.isBuffer(t)?(this.append(e,t.toString("base64")),!1):r.defaultVisitor.apply(this,arguments)}},I))}function te(A){return B.matchAll(/\\w+|\\[(\\w*)]/g,A).map(I=>I[0]==="[]"?"":I[1]||I[0])}function ee(A){let I={},t=Object.keys(A),e,g=t.length,r;for(e=0;e<g;e++)r=t[e],I[r]=A[r];return I}function ge(A){function I(t,e,g,r){let i=t[r++],s=Number.isFinite(+i),a=r>=t.length;return i=!i&&B.isArray(g)?g.length:i,a?(B.hasOwnProp(g,i)?g[i]=[g[i],e]:g[i]=e,!s):((!g[i]||!B.isObject(g[i]))&&(g[i]=[]),I(t,e,g[i],r)&&B.isArray(g[i])&&(g[i]=ee(g[i])),!s)}if(B.isFormData(A)&&B.isFunction(A.entries)){let t={};return B.forEachEntry(A,(e,g)=>{I(te(e),g,t,0)}),t}return null}var cA=ge;function re(A,I,t){if(B.isString(A))try{return(I||JSON.parse)(A),B.trim(A)}catch(e){if(e.name!=="SyntaxError")throw e}return(t||JSON.stringify)(A)}var HA={transitional:aA,adapter:["xhr","http"],transformRequest:[function(I,t){let e=t.getContentType()||"",g=e.indexOf("application/json")>-1,r=B.isObject(I);if(r&&B.isHTMLForm(I)&&(I=new FormData(I)),B.isFormData(I))return g&&g?JSON.stringify(cA(I)):I;if(B.isArrayBuffer(I)||B.isBuffer(I)||B.isStream(I)||B.isFile(I)||B.isBlob(I))return I;if(B.isArrayBufferView(I))return I.buffer;if(B.isURLSearchParams(I))return t.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),I.toString();let s;if(r){if(e.indexOf("application/x-www-form-urlencoded")>-1)return JA(I,this.formSerializer).toString();if((s=B.isFileList(I))||e.indexOf("multipart/form-data")>-1){let a=this.env&&this.env.FormData;return L(s?{"files[]":I}:I,a&&new a,this.formSerializer)}}return r||g?(t.setContentType("application/json",!1),re(I)):I}],transformResponse:[function(I){let t=this.transitional||HA.transitional,e=t&&t.forcedJSONParsing,g=this.responseType==="json";if(I&&B.isString(I)&&(e&&!this.responseType||g)){let i=!(t&&t.silentJSONParsing)&&g;try{return JSON.parse(I)}catch(s){if(i)throw s.name==="SyntaxError"?l.from(s,l.ERR_BAD_RESPONSE,this,null,this.response):s}}return I}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:w.classes.FormData,Blob:w.classes.Blob},validateStatus:function(I){return I>=200&&I<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};B.forEach(["delete","get","head","post","put","patch"],A=>{HA.headers[A]={}});var O=HA;var ie=B.toObjectSet(["age","authorization","content-length","content-type","etag","expires","from","host","if-modified-since","if-unmodified-since","last-modified","location","max-forwards","proxy-authorization","referer","retry-after","user-agent"]),SI=A=>{let I={},t,e,g;return A&&A.split(`%0A`).forEach(function(i){g=i.indexOf(":"),t=i.substring(0,g).trim().toLowerCase(),e=i.substring(g+1).trim(),!(!t||I[t]&&ie[t])&&(t==="set-cookie"?I[t]?I[t].push(e):I[t]=[e]:I[t]=I[t]?I[t]+", "+e:e)}),I};var FI=Symbol("internals");function z(A){return A&&String(A).trim().toLowerCase()}function fA(A){return A===!1||A==null?A:B.isArray(A)?A.map(fA):String(A)}function oe(A){let I=Object.create(null),t=/([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g,e;for(;e=t.exec(A);)I[e[1]]=e[2];return I}var Be=A=>/^[-_a-zA-Z0-9^`|~,!%23$%&\'*+.]+$/.test(A.trim());function YA(A,I,t,e,g){if(B.isFunction(e))return e.call(this,I,t);if(g&&(I=t),!!B.isString(I)){if(B.isString(e))return I.indexOf(e)!==-1;if(B.isRegExp(e))return e.test(I)}}function Ce(A){return A.trim().toLowerCase().replace(/([a-z\\d])(\\w*)/g,(I,t,e)=>t.toUpperCase()+e)}function se(A,I){let t=B.toCamelCase(" "+I);["get","set","has"].forEach(e=>{Object.defineProperty(A,e+t,{value:function(g,r,i){return this[e].call(this,I,g,r,i)},configurable:!0})})}var T=class{constructor(I){I&&this.set(I)}set(I,t,e){let g=this;function r(s,a,n){let C=z(a);if(!C)throw new Error("header name must be a non-empty string");let o=B.findKey(g,C);(!o||g[o]===void 0||n===!0||n===void 0&&g[o]!==!1)&&(g[o||a]=fA(s))}let i=(s,a)=>B.forEach(s,(n,C)=>r(n,C,a));return B.isPlainObject(I)||I instanceof this.constructor?i(I,t):B.isString(I)&&(I=I.trim())&&!Be(I)?i(SI(I),t):I!=null&&r(t,I,e),this}get(I,t){if(I=z(I),I){let e=B.findKey(this,I);if(e){let g=this[e];if(!t)return g;if(t===!0)return oe(g);if(B.isFunction(t))return t.call(this,g,e);if(B.isRegExp(t))return t.exec(g);throw new TypeError("parser must be boolean|regexp|function")}}}has(I,t){if(I=z(I),I){let e=B.findKey(this,I);return!!(e&&this[e]!==void 0&&(!t||YA(this,this[e],e,t)))}return!1}delete(I,t){let e=this,g=!1;function r(i){if(i=z(i),i){let s=B.findKey(e,i);s&&(!t||YA(e,e[s],s,t))&&(delete e[s],g=!0)}}return B.isArray(I)?I.forEach(r):r(I),g}clear(I){let t=Object.keys(this),e=t.length,g=!1;for(;e--;){let r=t[e];(!I||YA(this,this[r],r,I,!0))&&(delete this[r],g=!0)}return g}normalize(I){let t=this,e={};return B.forEach(this,(g,r)=>{let i=B.findKey(e,r);if(i){t[i]=fA(g),delete t[r];return}let s=I?Ce(r):String(r).trim();s!==r&&delete t[r],t[s]=fA(g),e[s]=!0}),this}concat(...I){return this.constructor.concat(this,...I)}toJSON(I){let t=Object.create(null);return B.forEach(this,(e,g)=>{e!=null&&e!==!1&&(t[g]=I&&B.isArray(e)?e.join(", "):e)}),t}[Symbol.iterator](){return Object.entries(this.toJSON())[Symbol.iterator]()}toString(){return Object.entries(this.toJSON()).map(([I,t])=>I+": "+t).join(`%0A`)}get[Symbol.toStringTag](){return"AxiosHeaders"}static from(I){return I instanceof this?I:new this(I)}static concat(I,...t){let e=new this(I);return t.forEach(g=>e.set(g)),e}static accessor(I){let e=(this[FI]=this[FI]={accessors:{}}).accessors,g=this.prototype;function r(i){let s=z(i);e[s]||(se(g,i),e[s]=!0)}return B.isArray(I)?I.forEach(r):r(I),this}};T.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);B.reduceDescriptors(T.prototype,({value:A},I)=>{let t=I[0].toUpperCase()+I.slice(1);return{get:()=>A,set(e){this[t]=e}}});B.freezeMethods(T);var m=T;function _(A,I){let t=this||O,e=I||t,g=m.from(e.headers),r=e.data;return B.forEach(A,function(s){r=s.call(t,r,g.normalize(),I?I.status:void 0)}),g.normalize(),r}function v(A){return!!(A&&A.__CANCEL__)}function RI(A,I,t){l.call(this,A??"canceled",l.ERR_CANCELED,I,t),this.name="CanceledError"}B.inherits(RI,l,{__CANCEL__:!0});var J=RI;function bA(A,I,t){let e=t.config.validateStatus;!t.status||!e||e(t.status)?A(t):I(new l("Request failed with status code "+t.status,[l.ERR_BAD_REQUEST,l.ERR_BAD_RESPONSE][Math.floor(t.status/100)-4],t.config,t.request,t))}var NI=w.hasStandardBrowserEnv?{write(A,I,t,e,g,r){let i=[A+"="+encodeURIComponent(I)];B.isNumber(t)&&i.push("expires="+new Date(t).toGMTString()),B.isString(e)&&i.push("path="+e),B.isString(g)&&i.push("domain="+g),r===!0&&i.push("secure"),document.cookie=i.join("; ")},read(A){let I=document.cookie.match(new RegExp("(^|;\\\\s*)("+A+")=([^;]*)"));return I?decodeURIComponent(I[3]):null},remove(A){this.write(A,"",Date.now()-864e5)}}:{write(){},read(){return null},remove(){}};function MA(A){return/^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(A)}function qA(A,I){return I?A.replace(/\\/+$/,"")+"/"+I.replace(/^\\/+/,""):A}function $(A,I){return A&&!MA(I)?qA(A,I):I}var UI=w.hasStandardBrowserEnv?function(){let I=/(msie|trident)/i.test(navigator.userAgent),t=document.createElement("a"),e;function g(r){let i=r;return I&&(t.setAttribute("href",i),i=t.href),t.setAttribute("href",i),{href:t.href,protocol:t.protocol?t.protocol.replace(/:$/,""):"",host:t.host,search:t.search?t.search.replace(/^\\?/,""):"",hash:t.hash?t.hash.replace(/^%23/,""):"",hostname:t.hostname,port:t.port,pathname:t.pathname.charAt(0)==="/"?t.pathname:"/"+t.pathname}}return e=g(window.location.href),function(i){let s=B.isString(i)?g(i):i;return s.protocol===e.protocol&&s.host===e.host}}():function(){return function(){return!0}}();function KA(A){let I=/^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(A);return I&&I[1]||""}function Qe(A,I){A=A||10;let t=new Array(A),e=new Array(A),g=0,r=0,i;return I=I!==void 0?I:1e3,function(a){let n=Date.now(),C=e[r];i||(i=n),t[g]=a,e[g]=n;let o=r,f=0;for(;o!==g;)f+=t[o++],o=o%A;if(g=(g+1)%A,g===r&&(r=(r+1)%A),n-i<I)return;let Q=C&&n-C;return Q?Math.round(f*1e3/Q):void 0}}var GI=Qe;function kI(A,I){let t=0,e=GI(50,250);return g=>{let r=g.loaded,i=g.lengthComputable?g.total:void 0,s=r-t,a=e(s),n=r<=i;t=r;let C={loaded:r,total:i,progress:i?r/i:void 0,bytes:s,rate:a||void 0,estimated:a&&i&&n?(i-r)/a:void 0,event:g};C[I?"download":"upload"]=!0,A(C)}}var ne=typeof XMLHttpRequest<"u",LI=ne&&function(A){return new Promise(function(t,e){let g=A.data,r=m.from(A.headers).normalize(),{responseType:i,withXSRFToken:s}=A,a;function n(){A.cancelToken&&A.cancelToken.unsubscribe(a),A.signal&&A.signal.removeEventListener("abort",a)}let C;if(B.isFormData(g)){if(w.hasStandardBrowserEnv||w.hasStandardBrowserWebWorkerEnv)r.setContentType(!1);else if((C=r.getContentType())!==!1){let[c,...u]=C?C.split(";").map(d=>d.trim()).filter(Boolean):[];r.setContentType([c||"multipart/form-data",...u].join("; "))}}let o=new XMLHttpRequest;if(A.auth){let c=A.auth.username||"",u=A.auth.password?unescape(encodeURIComponent(A.auth.password)):"";r.set("Authorization","Basic "+btoa(c+":"+u))}let f=$(A.baseURL,A.url);o.open(A.method.toUpperCase(),X(f,A.params,A.paramsSerializer),!0),o.timeout=A.timeout;function Q(){if(!o)return;let c=m.from("getAllResponseHeaders"in o&&o.getAllResponseHeaders()),d={data:!i||i==="text"||i==="json"?o.responseText:o.response,status:o.status,statusText:o.statusText,headers:c,config:A,request:o};bA(function(N){t(N),n()},function(N){e(N),n()},d),o=null}if("onloadend"in o?o.onloadend=Q:o.onreadystatechange=function(){!o||o.readyState!==4||o.status===0&&!(o.responseURL&&o.responseURL.indexOf("file:")===0)||setTimeout(Q)},o.onabort=function(){o&&(e(new l("Request aborted",l.ECONNABORTED,A,o)),o=null)},o.onerror=function(){e(new l("Network Error",l.ERR_NETWORK,A,o)),o=null},o.ontimeout=function(){let u=A.timeout?"timeout of "+A.timeout+"ms exceeded":"timeout exceeded",d=A.transitional||aA;A.timeoutErrorMessage&&(u=A.timeoutErrorMessage),e(new l(u,d.clarifyTimeoutError?l.ETIMEDOUT:l.ECONNABORTED,A,o)),o=null},w.hasStandardBrowserEnv&&(s&&B.isFunction(s)&&(s=s(A)),s||s!==!1&&UI(f))){let c=A.xsrfHeaderName&&A.xsrfCookieName&&NI.read(A.xsrfCookieName);c&&r.set(A.xsrfHeaderName,c)}g===void 0&&r.setContentType(null),"setRequestHeader"in o&&B.forEach(r.toJSON(),function(u,d){o.setRequestHeader(d,u)}),B.isUndefined(A.withCredentials)||(o.withCredentials=!!A.withCredentials),i&&i!=="json"&&(o.responseType=A.responseType),typeof A.onDownloadProgress=="function"&&o.addEventListener("progress",kI(A.onDownloadProgress,!0)),typeof A.onUploadProgress=="function"&&o.upload&&o.upload.addEventListener("progress",kI(A.onUploadProgress)),(A.cancelToken||A.signal)&&(a=c=>{o&&(e(!c||c.type?new J(null,A,o):c),o.abort(),o=null)},A.cancelToken&&A.cancelToken.subscribe(a),A.signal&&(A.signal.aborted?a():A.signal.addEventListener("abort",a)));let E=KA(f);if(E&&w.protocols.indexOf(E)===-1){e(new l("Unsupported protocol "+E+":",l.ERR_BAD_REQUEST,A));return}o.send(g||null)})};var OA={http:nA,xhr:LI};B.forEach(OA,(A,I)=>{if(A){try{Object.defineProperty(A,"name",{value:I})}catch{}Object.defineProperty(A,"adapterName",{value:I})}});var JI=A=>`- ${A}`,Ee=A=>B.isFunction(A)||A===null||A===!1,lA={getAdapter:A=>{A=B.isArray(A)?A:[A];let{length:I}=A,t,e,g={};for(let r=0;r<I;r++){t=A[r];let i;if(e=t,!Ee(t)&&(e=OA[(i=String(t)).toLowerCase()],e===void 0))throw new l(`Unknown adapter \'${i}\'`);if(e)break;g[i||"%23"+r]=e}if(!e){let r=Object.entries(g).map(([s,a])=>`adapter ${s} `+(a===!1?"is not supported by the environment":"is not available in the build")),i=I?r.length>1?`since :%0A`+r.map(JI).join(`%0A`):" "+JI(r[0]):"as no adapter specified";throw new l("There is no suitable adapter to dispatch the request "+i,"ERR_NOT_SUPPORT")}return e},adapters:OA};function TA(A){if(A.cancelToken&&A.cancelToken.throwIfRequested(),A.signal&&A.signal.aborted)throw new J(null,A)}function DA(A){return TA(A),A.headers=m.from(A.headers),A.data=_.call(A,A.transformRequest),["post","put","patch"].indexOf(A.method)!==-1&&A.headers.setContentType("application/x-www-form-urlencoded",!1),lA.getAdapter(A.adapter||O.adapter)(A).then(function(e){return TA(A),e.data=_.call(A,A.transformResponse,e),e.headers=m.from(e.headers),e},function(e){return v(e)||(TA(A),e&&e.response&&(e.response.data=_.call(A,A.transformResponse,e.response),e.response.headers=m.from(e.response.headers))),Promise.reject(e)})}var HI=A=>A instanceof m?A.toJSON():A;function G(A,I){I=I||{};let t={};function e(n,C,o){return B.isPlainObject(n)&&B.isPlainObject(C)?B.merge.call({caseless:o},n,C):B.isPlainObject(C)?B.merge({},C):B.isArray(C)?C.slice():C}function g(n,C,o){if(B.isUndefined(C)){if(!B.isUndefined(n))return e(void 0,n,o)}else return e(n,C,o)}function r(n,C){if(!B.isUndefined(C))return e(void 0,C)}function i(n,C){if(B.isUndefined(C)){if(!B.isUndefined(n))return e(void 0,n)}else return e(void 0,C)}function s(n,C,o){if(o in I)return e(n,C);if(o in A)return e(void 0,n)}let a={url:r,method:r,data:r,baseURL:i,transformRequest:i,transformResponse:i,paramsSerializer:i,timeout:i,timeoutMessage:i,withCredentials:i,withXSRFToken:i,adapter:i,responseType:i,xsrfCookieName:i,xsrfHeaderName:i,onUploadProgress:i,onDownloadProgress:i,decompress:i,maxContentLength:i,maxBodyLength:i,beforeRedirect:i,transport:i,httpAgent:i,httpsAgent:i,cancelToken:i,socketPath:i,responseEncoding:i,validateStatus:s,headers:(n,C)=>g(HI(n),HI(C),!0)};return B.forEach(Object.keys(Object.assign({},A,I)),function(C){let o=a[C]||g,f=o(A[C],I[C],C);B.isUndefined(f)&&o!==s||(t[C]=f)}),t}var uA="1.6.2";var xA={};["object","boolean","number","function","string","symbol"].forEach((A,I)=>{xA[A]=function(e){return typeof e===A||"a"+(I<1?"n ":" ")+A}});var YI={};xA.transitional=function(I,t,e){function g(r,i){return"[Axios v"+uA+"] Transitional option \'"+r+"\'"+i+(e?". "+e:"")}return(r,i,s)=>{if(I===!1)throw new l(g(i," has been removed"+(t?" in "+t:"")),l.ERR_DEPRECATED);return t&&!YI[i]&&(YI[i]=!0,console.warn(g(i," has been deprecated since v"+t+" and will be removed in the near future"))),I?I(r,i,s):!0}};function ae(A,I,t){if(typeof A!="object")throw new l("options must be an object",l.ERR_BAD_OPTION_VALUE);let e=Object.keys(A),g=e.length;for(;g-- >0;){let r=e[g],i=I[r];if(i){let s=A[r],a=s===void 0||i(s,r,A);if(a!==!0)throw new l("option "+r+" must be "+a,l.ERR_BAD_OPTION_VALUE);continue}if(t!==!0)throw new l("Unknown option "+r,l.ERR_BAD_OPTION)}}var hA={assertOptions:ae,validators:xA};var H=hA.validators,x=class{constructor(I){this.defaults=I,this.interceptors={request:new kA,response:new kA}}request(I,t){typeof I=="string"?(t=t||{},t.url=I):t=I||{},t=G(this.defaults,t);let{transitional:e,paramsSerializer:g,headers:r}=t;e!==void 0&&hA.assertOptions(e,{silentJSONParsing:H.transitional(H.boolean),forcedJSONParsing:H.transitional(H.boolean),clarifyTimeoutError:H.transitional(H.boolean)},!1),g!=null&&(B.isFunction(g)?t.paramsSerializer={serialize:g}:hA.assertOptions(g,{encode:H.function,serialize:H.function},!0)),t.method=(t.method||this.defaults.method||"get").toLowerCase();let i=r&&B.merge(r.common,r[t.method]);r&&B.forEach(["delete","get","head","post","put","patch","common"],E=>{delete r[E]}),t.headers=m.concat(i,r);let s=[],a=!0;this.interceptors.request.forEach(function(c){typeof c.runWhen=="function"&&c.runWhen(t)===!1||(a=a&&c.synchronous,s.unshift(c.fulfilled,c.rejected))});let n=[];this.interceptors.response.forEach(function(c){n.push(c.fulfilled,c.rejected)});let C,o=0,f;if(!a){let E=[DA.bind(this),void 0];for(E.unshift.apply(E,s),E.push.apply(E,n),f=E.length,C=Promise.resolve(t);o<f;)C=C.then(E[o++],E[o++]);return C}f=s.length;let Q=t;for(o=0;o<f;){let E=s[o++],c=s[o++];try{Q=E(Q)}catch(u){c.call(this,u);break}}try{C=DA.call(this,Q)}catch(E){return Promise.reject(E)}for(o=0,f=n.length;o<f;)C=C.then(n[o++],n[o++]);return C}getUri(I){I=G(this.defaults,I);let t=$(I.baseURL,I.url);return X(t,I.params,I.paramsSerializer)}};B.forEach(["delete","get","head","options"],function(I){x.prototype[I]=function(t,e){return this.request(G(e||{},{method:I,url:t,data:(e||{}).data}))}});B.forEach(["post","put","patch"],function(I){function t(e){return function(r,i,s){return this.request(G(s||{},{method:I,headers:e?{"Content-Type":"multipart/form-data"}:{},url:r,data:i}))}}x.prototype[I]=t(),x.prototype[I+"Form"]=t(!0)});var AA=x;var PA=class A{constructor(I){if(typeof I!="function")throw new TypeError("executor must be a function.");let t;this.promise=new Promise(function(r){t=r});let e=this;this.promise.then(g=>{if(!e._listeners)return;let r=e._listeners.length;for(;r-- >0;)e._listeners[r](g);e._listeners=null}),this.promise.then=g=>{let r,i=new Promise(s=>{e.subscribe(s),r=s}).then(g);return i.cancel=function(){e.unsubscribe(r)},i},I(function(r,i,s){e.reason||(e.reason=new J(r,i,s),t(e.reason))})}throwIfRequested(){if(this.reason)throw this.reason}subscribe(I){if(this.reason){I(this.reason);return}this._listeners?this._listeners.push(I):this._listeners=[I]}unsubscribe(I){if(!this._listeners)return;let t=this._listeners.indexOf(I);t!==-1&&this._listeners.splice(t,1)}static source(){let I;return{token:new A(function(g){I=g}),cancel:I}}},bI=PA;function jA(A){return function(t){return A.apply(null,t)}}function WA(A){return B.isObject(A)&&A.isAxiosError===!0}var ZA={Continue:100,SwitchingProtocols:101,Processing:102,EarlyHints:103,Ok:200,Created:201,Accepted:202,NonAuthoritativeInformation:203,NoContent:204,ResetContent:205,PartialContent:206,MultiStatus:207,AlreadyReported:208,ImUsed:226,MultipleChoices:300,MovedPermanently:301,Found:302,SeeOther:303,NotModified:304,UseProxy:305,Unused:306,TemporaryRedirect:307,PermanentRedirect:308,BadRequest:400,Unauthorized:401,PaymentRequired:402,Forbidden:403,NotFound:404,MethodNotAllowed:405,NotAcceptable:406,ProxyAuthenticationRequired:407,RequestTimeout:408,Conflict:409,Gone:410,LengthRequired:411,PreconditionFailed:412,PayloadTooLarge:413,UriTooLong:414,UnsupportedMediaType:415,RangeNotSatisfiable:416,ExpectationFailed:417,ImATeapot:418,MisdirectedRequest:421,UnprocessableEntity:422,Locked:423,FailedDependency:424,TooEarly:425,UpgradeRequired:426,PreconditionRequired:428,TooManyRequests:429,RequestHeaderFieldsTooLarge:431,UnavailableForLegalReasons:451,InternalServerError:500,NotImplemented:501,BadGateway:502,ServiceUnavailable:503,GatewayTimeout:504,HttpVersionNotSupported:505,VariantAlsoNegotiates:506,InsufficientStorage:507,LoopDetected:508,NotExtended:510,NetworkAuthenticationRequired:511};Object.entries(ZA).forEach(([A,I])=>{ZA[I]=A});var MI=ZA;function qI(A){let I=new AA(A),t=W(AA.prototype.request,I);return B.extend(t,AA.prototype,I,{allOwnKeys:!0}),B.extend(t,I,null,{allOwnKeys:!0}),t.create=function(g){return qI(G(A,g))},t}var h=qI(O);h.Axios=AA;h.CanceledError=J;h.CancelToken=bI;h.isCancel=v;h.VERSION=uA;h.toFormData=L;h.AxiosError=l;h.Cancel=h.CanceledError;h.all=function(I){return Promise.all(I)};h.spread=jA;h.isAxiosError=WA;h.mergeConfig=G;h.AxiosHeaders=m;h.formToJSON=A=>cA(B.isHTMLForm(A)?new FormData(A):A);h.getAdapter=lA.getAdapter;h.HttpStatusCode=MI;h.default=h;var dA=h;var{Axios:oi,AxiosError:Bi,CanceledError:Ci,isCancel:si,CancelToken:Qi,VERSION:ni,all:Ei,Cancel:ai,isAxiosError:ci,spread:fi,toFormData:li,AxiosHeaders:Di,HttpStatusCode:ui,formToJSON:hi,getAdapter:di,mergeConfig:yi}=dA;var IA,k,XA,VA={env:{emscripten_notify_memory_growth:function(A){XA=new Uint8Array(k.exports.memory.buffer)}}},yA=class{init(){return IA||(typeof fetch<"u"?IA=fetch("data:application/wasm;base64,"+KI).then(I=>I.arrayBuffer()).then(I=>WebAssembly.instantiate(I,VA)).then(this._init):IA=WebAssembly.instantiate(Buffer.from(KI,"base64"),VA).then(this._init),IA)}_init(I){k=I.instance,VA.env.emscripten_notify_memory_growth(0)}decode(I,t=0){if(!k)throw new Error("ZSTDDecoder: Await .init() before decoding.");let e=I.byteLength,g=k.exports.malloc(e);XA.set(I,g),t=t||Number(k.exports.ZSTD_findDecompressedSize(g,e));let r=k.exports.malloc(t),i=k.exports.ZSTD_decompress(r,t,g,e),s=XA.slice(r,r+i);return k.exports.free(g),k.exports.free(r),s}},KI="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";var OI=new yA,TI=!1;async function ce(A,I,t){let e=null;typeof A!="string"?e=A.href:A.startsWith("http")?e=A:e=`${I}/${A}`,e.endsWith(".js")&&(e=e.substring(0,e.length-3)),e.endsWith(".wasm")&&(e=e.substring(0,e.length-5));let g=`${e}.wasm`,r=await dA.get(`${g}.zst`,{responseType:"arraybuffer",params:t});TI||(await OI.init(),TI=!0);let s=OI.decode(new Uint8Array(r.data)).buffer;return(await import(`${e}.js`)).default({wasmBinary:s})}var xI=ce;var wA=new Map;async function fe(A,I,t){let e=A,g=A,r=null;return typeof A!="string"&&(e=new URL(A.href),g=e.href),wA.has(g)?r=await wA.get(g):(wA.set(g,xI(e,I,t)),r=await wA.get(g)),r}var PI=fe;var le={TextFile:"TextFile",BinaryFile:"BinaryFile",TextStream:"TextStream",BinaryStream:"BinaryStream",Image:"Image",Mesh:"Mesh",PolyData:"PolyData",JsonCompatible:"JsonCompatible"},D=le;var De={Int8:"int8",UInt8:"uint8",Int16:"int16",UInt16:"uint16",Int32:"int32",UInt32:"uint32",Int64:"int64",UInt64:"uint64",SizeValueType:"uint64",IdentifierType:"uint64",IndexValueType:"int64",OffsetValueType:"int64"},p=De;var ue={Float32:"float32",Float64:"float64",SpacePrecisionType:"float64"},P=ue;function he(A,I){let t=null;switch(A){case p.UInt8:{t=new Uint8Array(I);break}case p.Int8:{t=new Int8Array(I);break}case p.UInt16:{t=new Uint16Array(I);break}case p.Int16:{t=new Int16Array(I);break}case p.UInt32:{t=new Uint32Array(I);break}case p.Int32:{t=new Int32Array(I);break}case p.UInt64:{typeof globalThis.BigUint64Array=="function"?t=new BigUint64Array(I):t=new Uint8Array(I);break}case p.Int64:{typeof globalThis.BigInt64Array=="function"?t=new BigInt64Array(I):t=new Uint8Array(I);break}case P.Float32:{t=new Float32Array(I);break}case P.Float64:{t=new Float64Array(I);break}case"null":{t=null;break}case null:{t=null;break}default:throw new Error("Type is not supported as a TypedArray")}return t}var Y=he;var ZI=typeof globalThis.SharedArrayBuffer=="function",jI=new TextEncoder,WI=new TextDecoder("utf-8");function de(A,I){let t={flags:"r",encoding:"binary"},e=A.fs_open(I,t.flags),r=A.fs_stat(I).size,i=null;ZI?i=new SharedArrayBuffer(r):i=new ArrayBuffer(r);let s=new Uint8Array(i);return A.fs_read(e,s,0,r,0),A.fs_close(e),s}function VI(A,I,t){let e=null;ZI?e=new SharedArrayBuffer(t):e=new ArrayBuffer(t);let g=new Uint8Array(e),r=new Uint8Array(A.HEAPU8.buffer,I,t);return g.set(r),g}function y(A,I,t,e){let g=0;return I!==null&&(g=A.ccall("itk_wasm_input_array_alloc","number",["number","number","number","number"],[0,t,e,I.buffer.byteLength]),A.HEAPU8.set(new Uint8Array(I.buffer),g)),g}function j(A,I,t){let e=JSON.stringify(I),g=A.ccall("itk_wasm_input_json_alloc","number",["number","number","number"],[0,t,e.length]);A.writeAsciiToMemory(e,g,!1)}function S(A,I,t,e){let g=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,I,t]),r=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,I,t]),i=VI(A,g,r);return Y(e,i.buffer)}function zA(A,I){let t=A.ccall("itk_wasm_output_json_address","number",["number","number"],[0,I]),e=A.AsciiToString(t);return JSON.parse(e)}function ye(A,I,t,e){e!=null&&e.length>0&&e.forEach(function(n,C){switch(n.type){case D.TextStream:{let o=jI.encode(n.data.data),f=y(A,o,C,0),Q={size:o.buffer.byteLength,data:`data:application/vnd.itk.address,0:${f}`};j(A,Q,C);break}case D.JsonCompatible:{let o=jI.encode(JSON.stringify(n.data)),f=y(A,o,C,0),Q={size:o.buffer.byteLength,data:`data:application/vnd.itk.address,0:${f}`};j(A,Q,C);break}case D.BinaryStream:{let o=n.data.data,f=y(A,o,C,0),Q={size:o.buffer.byteLength,data:`data:application/vnd.itk.address,0:${f}`};j(A,Q,C);break}case D.TextFile:{A.fs_writeFile(n.data.path,n.data.data);break}case D.BinaryFile:{A.fs_writeFile(n.data.path,n.data.data);break}case D.Image:{let o=n.data,f=y(A,o.data,C,0),Q=y(A,o.direction,C,1),E=typeof o.metadata?.entries<"u"?JSON.stringify(Array.from(o.metadata.entries())):"[]",c={imageType:o.imageType,name:o.name,origin:o.origin,spacing:o.spacing,direction:`data:application/vnd.itk.address,0:${Q}`,size:o.size,data:`data:application/vnd.itk.address,0:${f}`,metadata:E};j(A,c,C);break}case D.Mesh:{let o=n.data,f=y(A,o.points,C,0),Q=y(A,o.cells,C,1),E=y(A,o.pointData,C,2),c=y(A,o.cellData,C,3),u={meshType:o.meshType,name:o.name,numberOfPoints:o.numberOfPoints,points:`data:application/vnd.itk.address,0:${f}`,numberOfCells:o.numberOfCells,cells:`data:application/vnd.itk.address,0:${Q}`,cellBufferSize:o.cellBufferSize,numberOfPointPixels:o.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${E}`,numberOfCellPixels:o.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${c}`};j(A,u,C);break}case D.PolyData:{let o=n.data,f=y(A,o.points,C,0),Q=y(A,o.vertices,C,1),E=y(A,o.lines,C,2),c=y(A,o.polygons,C,3),u=y(A,o.triangleStrips,C,4),d=y(A,o.pointData,C,5),R=y(A,o.pointData,C,6),N={polyDataType:o.polyDataType,name:o.name,numberOfPoints:o.numberOfPoints,points:`data:application/vnd.itk.address,0:${f}`,verticesBufferSize:o.verticesBufferSize,vertices:`data:application/vnd.itk.address,0:${Q}`,linesBufferSize:o.linesBufferSize,lines:`data:application/vnd.itk.address,0:${E}`,polygonsBufferSize:o.polygonsBufferSize,polygons:`data:application/vnd.itk.address,0:${c}`,triangleStripsBufferSize:o.triangleStripsBufferSize,triangleStrips:`data:application/vnd.itk.address,0:${u}`,numberOfPointPixels:o.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${d}`,numberOfCellPixels:o.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${R}`};j(A,N,C);break}default:throw Error("Unsupported input InterfaceType")}}),A.resetModuleStdout(),A.resetModuleStderr();let g=A.stackSave(),r=0;try{r=A.callMain(I.slice())}catch(n){throw typeof n=="number"&&(console.log("Exception while running pipeline:"),console.log("stdout:",A.getModuleStdout()),console.error("stderr:",A.getModuleStderr()),typeof A.getExceptionMessage<"u"?console.error("exception:",A.getExceptionMessage(n)):console.error("Build module in Debug mode for exception message information.")),n}finally{A.stackRestore(g)}let i=A.getModuleStdout(),s=A.getModuleStderr(),a=[];return t!=null&&t.length>0&&r===0&&t.forEach(function(n,C){let o=null;switch(n.type){case D.TextStream:{let Q=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,C,0]),E=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,C,0]),c=new Uint8Array(A.HEAPU8.buffer,Q,E);o={data:WI.decode(c)};break}case D.JsonCompatible:{let Q=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,C,0]),E=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,C,0]),c=new Uint8Array(A.HEAPU8.buffer,Q,E);o=JSON.parse(WI.decode(c));break}case D.BinaryStream:{let Q=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,C,0]),E=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,C,0]);o={data:VI(A,Q,E)};break}case D.TextFile:{o={path:n.data.path,data:A.fs_readFile(n.data.path,{encoding:"utf8"})};break}case D.BinaryFile:{o={path:n.data.path,data:de(A,n.data.path)};break}case D.Image:{let Q=zA(A,C);Q.data=S(A,C,0,Q.imageType.componentType),Q.direction=S(A,C,1,P.Float64),Q.metadata=new Map(Q.metadata),o=Q;break}case D.Mesh:{let Q=zA(A,C);Q.numberOfPoints>0?Q.points=S(A,C,0,Q.meshType.pointComponentType):Q.points=Y(Q.meshType.pointComponentType,new ArrayBuffer(0)),Q.numberOfCells>0?Q.cells=S(A,C,1,Q.meshType.cellComponentType):Q.cells=Y(Q.meshType.cellComponentType,new ArrayBuffer(0)),Q.numberOfPointPixels>0?Q.pointData=S(A,C,2,Q.meshType.pointPixelComponentType):Q.pointData=Y(Q.meshType.pointPixelComponentType,new ArrayBuffer(0)),Q.numberOfCellPixels>0?Q.cellData=S(A,C,3,Q.meshType.cellPixelComponentType):Q.cellData=Y(Q.meshType.cellPixelComponentType,new ArrayBuffer(0)),o=Q;break}case D.PolyData:{let Q=zA(A,C);Q.numberOfPoints>0?Q.points=S(A,C,0,P.Float32):Q.points=new Float32Array,Q.verticesBufferSize>0?Q.vertices=S(A,C,1,p.UInt32):Q.vertices=new Uint32Array,Q.linesBufferSize>0?Q.lines=S(A,C,2,p.UInt32):Q.lines=new Uint32Array,Q.polygonsBufferSize>0?Q.polygons=S(A,C,3,p.UInt32):Q.polygons=new Uint32Array,Q.triangleStripsBufferSize>0?Q.triangleStrips=S(A,C,4,p.UInt32):Q.triangleStrips=new Uint32Array,Q.numberOfPointPixels>0?Q.pointData=S(A,C,5,Q.polyDataType.pointPixelComponentType):Q.pointData=Y(Q.polyDataType.pointPixelComponentType,new ArrayBuffer(0)),Q.numberOfCellPixels>0?Q.cellData=S(A,C,6,Q.polyDataType.cellPixelComponentType):Q.cellData=Y(Q.polyDataType.cellPixelComponentType,new ArrayBuffer(0)),o=Q;break}default:throw Error("Unsupported output InterfaceType")}let f={type:n.type,data:o};a.push(f)}),{returnValue:r,stdout:i,stderr:s,outputs:a}}var XI=ye;var we=typeof globalThis.SharedArrayBuffer<"u";function me(A,I){if(A==null)return[];let t=[];for(let e=0;e<A.length;e++){let g=pe(A[e],I);g!==null&&t.push(g)}return t}function pe(A,I){if(A==null)return null;let t=null;return A.buffer!==void 0?t=A.buffer:A.byteLength!==void 0&&(t=A),we&&t instanceof SharedArrayBuffer?null:I?t:t.slice(0)}var zI=me;function Se(A){return[A.data,A.direction]}var _I=Se;function Fe(A){return[A.points,A.pointData,A.cells,A.cellData]}var vI=Fe;function Re(A){return[A.points,A.vertices,A.lines,A.polygons,A.triangleStrips,A.pointData,A.cellData]}var $I=Re;async function Ne(A,I,t,e){let g=XI(A,I,t,e),r=[];return g.outputs.forEach(function(i){if(i.type===D.BinaryStream||i.type===D.BinaryFile){let s=i.data;r.push(s)}else if(i.type===D.Image){let s=i.data;r.push(..._I(s))}else if(i.type===D.Mesh){let s=i.data;r.push(...vI(s))}else if(i.type===D.PolyData){let s=i.data;r.push(...$I(s))}}),SA(g,zI(r,!0))}var At=Ne;var Ue={runPipeline:async function(A,I,t,e,g,r){let i=await PI(A,I,r);return await At(i,t,e,g)}};oA(Ue);%0A/*! Bundled license information:%0A%0Acomlink/dist/esm/comlink.mjs:%0A  (**%0A   * @license%0A   * Copyright 2019 Google LLC%0A   * SPDX-License-Identifier: Apache-2.0%0A   *)%0A*/%0A';mt(wt);export{Bi as applyPresentationStateToImage,T as getDefaultWebWorker,w as getPipelineWorkerUrl,R as getPipelinesBaseUrl,Si as imageSetsNormalization,ci as readDicomEncapsulatedPdf,di as readDicomTags,wi as readImageDicomFileSeries,ge as readImageDicomFileSeriesWorkerFunction,js as setDefaultWebWorker,mt as setPipelineWorkerUrl,Hs as setPipelinesBaseUrl,Ei as structuredReportToHtml,Qi as structuredReportToText,kA as version};
/*! Bundled license information:

comlink/dist/esm/comlink.mjs:
  (**
   * @license
   * Copyright 2019 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   *)
*/
""" +default_js_module = """data:text/javascript;base64,var St=Object.defineProperty;var Ft=(A,e)=>{for(var t in e)St(A,t,{get:e[t],enumerable:!0})};var kt="6.0.1",kA=kt;var Rt={Int8:"int8",UInt8:"uint8",Int16:"int16",UInt16:"uint16",Int32:"int32",UInt32:"uint32",Int64:"int64",UInt64:"uint64",SizeValueType:"uint64",IdentifierType:"uint64",IndexValueType:"int64",OffsetValueType:"int64"},h=Rt;var bt={Float32:"float32",Float64:"float64",SpacePrecisionType:"float64"},M=bt;function Ut(A,e){let t=null;switch(A){case h.UInt8:{t=new Uint8Array(e);break}case h.Int8:{t=new Int8Array(e);break}case h.UInt16:{t=new Uint16Array(e);break}case h.Int16:{t=new Int16Array(e);break}case h.UInt32:{t=new Uint32Array(e);break}case h.Int32:{t=new Int32Array(e);break}case h.UInt64:{typeof globalThis.BigUint64Array=="function"?t=new BigUint64Array(e):t=new Uint8Array(e);break}case h.Int64:{typeof globalThis.BigInt64Array=="function"?t=new BigInt64Array(e):t=new Uint8Array(e);break}case M.Float32:{t=new Float32Array(e);break}case M.Float64:{t=new Float64Array(e);break}case"null":{t=null;break}case null:{t=null;break}default:throw new Error("Type is not supported as a TypedArray")}return t}var x=Ut;var Nt={Unknown:"Unknown",Scalar:"Scalar",RGB:"RGB",RGBA:"RGBA",Offset:"Offset",Vector:"Vector",Point:"Point",CovariantVector:"CovariantVector",SymmetricSecondRankTensor:"SymmetricSecondRankTensor",DiffusionTensor3D:"DiffusionTensor3D",Complex:"Complex",FixedArray:"FixedArray",Array:"Array",Matrix:"Matrix",VariableLengthVector:"VariableLengthVector",VariableSizeMatrix:"VariableSizeMatrix"},le=Nt;var RA=class{dimension;componentType;pixelType;components;constructor(e=2,t=h.UInt8,r=le.Scalar,n=1){this.dimension=e,this.componentType=t,this.pixelType=r,this.components=n}},Be=RA;function Gt(A,e,t,r,n){A[r+t*e]=n}var Ce=Gt;var bA=class{imageType;name="image";origin;spacing;direction;size;metadata;data;constructor(e=new Be){this.imageType=e;let t=e.dimension;this.origin=new Array(t),this.origin.fill(0),this.spacing=new Array(t),this.spacing.fill(1),this.direction=new Float64Array(t*t),this.direction.fill(0);for(let r=0;r<t;r++)Ce(this.direction,t,r,r,1);this.size=new Array(t),this.size.fill(0),this.metadata=new Map,this.data=null}},ce=bA;function Tt(A){if(A.length<1)throw Error("At least one images is required.");let e=A[0];if(e.data===null)throw Error("Image data is null.");let t=new ce(e.imageType);t.origin=Array.from(e.origin),t.spacing=Array.from(e.spacing);let r=t.imageType.dimension;t.direction=e.direction.slice();let n=r-1;t.size=Array.from(e.size);let i=A.reduce((s,a)=>s+a.size[n],0);t.size[n]=i;let o=t.size.reduce((s,a)=>s*a,1)*t.imageType.components,I=e.data.constructor;t.data=new I(o);let C=t.imageType.components;for(let s=0;s<t.size.length-1;s++)C*=t.size[s];let l=0;if(t.data!=null)for(let s=0;s<A.length;s++)t.data.set(A[s].data,C*l),l+=A[s].size[n];else throw Error("Could not create result image data.");return t}var UA=Tt;var NA=class{fcn;workerQueue;runInfo;constructor(e,t){this.fcn=t,this.workerQueue=new Array(e),this.workerQueue.fill(null),this.runInfo=[]}runTasks(e,t=null){let r={taskQueue:[],results:[],addingTasks:!1,postponed:!1,runningWorkers:0,index:0,completedTasks:0,progressCallback:t,canceled:!1};return this.runInfo.push(r),r.index=this.runInfo.length-1,{promise:new Promise((n,i)=>{r.resolve=n,r.reject=i,r.results=new Array(e.length),r.completedTasks=0,r.addingTasks=!0,e.forEach((o,I)=>{this.addTask(r.index,I,o)}),r.addingTasks=!1}),runId:r.index}}terminateWorkers(){for(let e=0;e<this.workerQueue.length;e++){let t=this.workerQueue[e];t?.terminate(),this.workerQueue[e]=null}}cancel(e){let t=this.runInfo[e];t!=null&&(t.canceled=!0)}addTask(e,t,r){let n=this.runInfo[e];if(n?.canceled===!0){n.reject("Remaining tasks canceled"),this.clearTask(n.index);return}if(this.workerQueue.length>0){let i=this.workerQueue.pop();n.runningWorkers++,r[r.length-1].webWorker=i,this.fcn(...r).then(({webWorker:o,...I})=>{if(this.workerQueue.push(o),this.runInfo[e]!==null){if(n.runningWorkers--,n.results[t]=I,n.completedTasks++,n.progressCallback!=null&&n.progressCallback(n.completedTasks,n.results.length),n.taskQueue.length>0){let C=n.taskQueue.shift();this.addTask(e,C[0],C[1])}else if(!n.addingTasks&&n.runningWorkers===0){let C=n.results;n.resolve(C),this.clearTask(n.index)}}}).catch(o=>{n.reject(o),this.clearTask(n.index)})}else n.runningWorkers!==0||n.postponed?n.taskQueue.push([t,r]):(n.postponed=!0,setTimeout(()=>{n.postponed=!1,this.addTask(n.index,t,r)},50))}clearTask(e){this.runInfo[e].results=[],this.runInfo[e].taskQueue=[],this.runInfo[e].progressCallback=null,this.runInfo[e].canceled=null,this.runInfo[e].reject=()=>{},this.runInfo[e].resolve=()=>{}}},GA=NA;var Lt={TextFile:"TextFile",BinaryFile:"BinaryFile",TextStream:"TextStream",BinaryStream:"BinaryStream",Image:"Image",Mesh:"Mesh",PolyData:"PolyData",JsonCompatible:"JsonCompatible"},f=Lt;var Ee=Symbol("Comlink.proxy"),xt=Symbol("Comlink.endpoint"),xA=Symbol("Comlink.releaseProxy"),TA=Symbol("Comlink.finalizer"),sA=Symbol("Comlink.thrown"),fe=A=>typeof A=="object"&&A!==null||typeof A=="function",Ot={canHandle:A=>fe(A)&&A[Ee],serialize(A){let{port1:e,port2:t}=new MessageChannel;return pe(A,e),[t,[t]]},deserialize(A){return A.start(),OA(A)}},Pt={canHandle:A=>fe(A)&&sA in A,serialize({value:A}){let e;return A instanceof Error?e={isError:!0,value:{message:A.message,name:A.name,stack:A.stack}}:e={isError:!1,value:A},[e,[]]},deserialize(A){throw A.isError?Object.assign(new Error(A.value.message),A.value):A.value}},Qe=new Map([["proxy",Ot],["throw",Pt]]);function Jt(A,e){for(let t of A)if(e===t||t==="*"||t instanceof RegExp&&t.test(e))return!0;return!1}function pe(A,e=globalThis,t=["*"]){e.addEventListener("message",function r(n){if(!n||!n.data)return;if(!Jt(t,n.origin)){console.warn(`Invalid origin '${n.origin}' for comlink proxy`);return}let{id:i,type:o,path:I}=Object.assign({path:[]},n.data),C=(n.data.argumentList||[]).map(H),l;try{let s=I.slice(0,-1).reduce((E,B)=>E[B],A),a=I.reduce((E,B)=>E[B],A);switch(o){case"GET":l=a;break;case"SET":s[I.slice(-1)[0]]=H(n.data.value),l=!0;break;case"APPLY":l=a.apply(s,C);break;case"CONSTRUCT":{let E=new a(...C);l=Kt(E)}break;case"ENDPOINT":{let{port1:E,port2:B}=new MessageChannel;pe(A,B),l=PA(E,[E])}break;case"RELEASE":l=void 0;break;default:return}}catch(s){l={value:s,[sA]:0}}Promise.resolve(l).catch(s=>({value:s,[sA]:0})).then(s=>{let[a,E]=lA(s);e.postMessage(Object.assign(Object.assign({},a),{id:i}),E),o==="RELEASE"&&(e.removeEventListener("message",r),de(e),TA in A&&typeof A[TA]=="function"&&A[TA]())}).catch(s=>{let[a,E]=lA({value:new TypeError("Unserializable return value"),[sA]:0});e.postMessage(Object.assign(Object.assign({},a),{id:i}),E)})}),e.start&&e.start()}function Ht(A){return A.constructor.name==="MessagePort"}function de(A){Ht(A)&&A.close()}function OA(A,e){return LA(A,[],e)}function aA(A){if(A)throw new Error("Proxy has been released and is not useable")}function me(A){return Y(A,{type:"RELEASE"}).then(()=>{de(A)})}var IA=new WeakMap,gA="FinalizationRegistry"in globalThis&&new FinalizationRegistry(A=>{let e=(IA.get(A)||0)-1;IA.set(A,e),e===0&&me(A)});function Mt(A,e){let t=(IA.get(e)||0)+1;IA.set(e,t),gA&&gA.register(A,e,A)}function Yt(A){gA&&gA.unregister(A)}function LA(A,e=[],t=function(){}){let r=!1,n=new Proxy(t,{get(i,o){if(aA(r),o===xA)return()=>{Yt(n),me(A),r=!0};if(o==="then"){if(e.length===0)return{then:()=>n};let I=Y(A,{type:"GET",path:e.map(C=>C.toString())}).then(H);return I.then.bind(I)}return LA(A,[...e,o])},set(i,o,I){aA(r);let[C,l]=lA(I);return Y(A,{type:"SET",path:[...e,o].map(s=>s.toString()),value:C},l).then(H)},apply(i,o,I){aA(r);let C=e[e.length-1];if(C===xt)return Y(A,{type:"ENDPOINT"}).then(H);if(C==="bind")return LA(A,e.slice(0,-1));let[l,s]=ue(I);return Y(A,{type:"APPLY",path:e.map(a=>a.toString()),argumentList:l},s).then(H)},construct(i,o){aA(r);let[I,C]=ue(o);return Y(A,{type:"CONSTRUCT",path:e.map(l=>l.toString()),argumentList:I},C).then(H)}});return Mt(n,A),n}function qt(A){return Array.prototype.concat.apply([],A)}function ue(A){let e=A.map(lA);return[e.map(t=>t[0]),qt(e.map(t=>t[1]))]}var he=new WeakMap;function PA(A,e){return he.set(A,e),A}function Kt(A){return Object.assign(A,{[Ee]:!0})}function lA(A){for(let[e,t]of Qe)if(t.canHandle(A)){let[r,n]=t.serialize(A);return[{type:"HANDLER",name:e,value:r},n]}return[{type:"RAW",value:A},he.get(A)||[]]}function H(A){switch(A.type){case"HANDLER":return Qe.get(A.name).deserialize(A.value);case"RAW":return A.value}}function Y(A,e,t){return new Promise(r=>{let n=Wt();A.addEventListener("message",function i(o){!o.data||!o.data.id||o.data.id!==n||(A.removeEventListener("message",i),r(o.data))}),A.start&&A.start(),A.postMessage(Object.assign({id:n},e),t)})}function Wt(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}function Z(A,e){return function(){return A.apply(e,arguments)}}var{toString:vt}=Object.prototype,{getPrototypeOf:MA}=Object,CA=(A=>e=>{let t=vt.call(e);return A[t]||(A[t]=t.slice(8,-1).toLowerCase())})(Object.create(null)),G=A=>(A=A.toLowerCase(),e=>CA(e)===A),cA=A=>e=>typeof e===A,{isArray:q}=Array,X=cA("undefined");function jt(A){return A!==null&&!X(A)&&A.constructor!==null&&!X(A.constructor)&&N(A.constructor.isBuffer)&&A.constructor.isBuffer(A)}var Se=G("ArrayBuffer");function _t(A){let e;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?e=ArrayBuffer.isView(A):e=A&&A.buffer&&Se(A.buffer),e}var zt=cA("string"),N=cA("function"),Fe=cA("number"),uA=A=>A!==null&&typeof A=="object",Vt=A=>A===!0||A===!1,BA=A=>{if(CA(A)!=="object")return!1;let e=MA(A);return(e===null||e===Object.prototype||Object.getPrototypeOf(e)===null)&&!(Symbol.toStringTag in A)&&!(Symbol.iterator in A)},Zt=G("Date"),Xt=G("File"),$t=G("Blob"),Ar=G("FileList"),er=A=>uA(A)&&N(A.pipe),tr=A=>{let e;return A&&(typeof FormData=="function"&&A instanceof FormData||N(A.append)&&((e=CA(A))==="formdata"||e==="object"&&N(A.toString)&&A.toString()==="[object FormData]"))},rr=G("URLSearchParams"),ir=A=>A.trim?A.trim():A.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,"");function $(A,e,{allOwnKeys:t=!1}={}){if(A===null||typeof A>"u")return;let r,n;if(typeof A!="object"&&(A=[A]),q(A))for(r=0,n=A.length;r<n;r++)e.call(null,A[r],r,A);else{let i=t?Object.getOwnPropertyNames(A):Object.keys(A),o=i.length,I;for(r=0;r<o;r++)I=i[r],e.call(null,A[I],I,A)}}function ke(A,e){e=e.toLowerCase();let t=Object.keys(A),r=t.length,n;for(;r-- >0;)if(n=t[r],e===n.toLowerCase())return n;return null}var Re=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global,be=A=>!X(A)&&A!==Re;function HA(){let{caseless:A}=be(this)&&this||{},e={},t=(r,n)=>{let i=A&&ke(e,n)||n;BA(e[i])&&BA(r)?e[i]=HA(e[i],r):BA(r)?e[i]=HA({},r):q(r)?e[i]=r.slice():e[i]=r};for(let r=0,n=arguments.length;r<n;r++)arguments[r]&&$(arguments[r],t);return e}var nr=(A,e,t,{allOwnKeys:r}={})=>($(e,(n,i)=>{t&&N(n)?A[i]=Z(n,t):A[i]=n},{allOwnKeys:r}),A),or=A=>(A.charCodeAt(0)===65279&&(A=A.slice(1)),A),ar=(A,e,t,r)=>{A.prototype=Object.create(e.prototype,r),A.prototype.constructor=A,Object.defineProperty(A,"super",{value:e.prototype}),t&&Object.assign(A.prototype,t)},sr=(A,e,t,r)=>{let n,i,o,I={};if(e=e||{},A==null)return e;do{for(n=Object.getOwnPropertyNames(A),i=n.length;i-- >0;)o=n[i],(!r||r(o,A,e))&&!I[o]&&(e[o]=A[o],I[o]=!0);A=t!==!1&&MA(A)}while(A&&(!t||t(A,e))&&A!==Object.prototype);return e},Ir=(A,e,t)=>{A=String(A),(t===void 0||t>A.length)&&(t=A.length),t-=e.length;let r=A.indexOf(e,t);return r!==-1&&r===t},gr=A=>{if(!A)return null;if(q(A))return A;let e=A.length;if(!Fe(e))return null;let t=new Array(e);for(;e-- >0;)t[e]=A[e];return t},lr=(A=>e=>A&&e instanceof A)(typeof Uint8Array<"u"&&MA(Uint8Array)),Br=(A,e)=>{let r=(A&&A[Symbol.iterator]).call(A),n;for(;(n=r.next())&&!n.done;){let i=n.value;e.call(A,i[0],i[1])}},Cr=(A,e)=>{let t,r=[];for(;(t=A.exec(e))!==null;)r.push(t);return r},cr=G("HTMLFormElement"),ur=A=>A.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,function(t,r,n){return r.toUpperCase()+n}),we=(({hasOwnProperty:A})=>(e,t)=>A.call(e,t))(Object.prototype),Er=G("RegExp"),Ue=(A,e)=>{let t=Object.getOwnPropertyDescriptors(A),r={};$(t,(n,i)=>{let o;(o=e(n,i,A))!==!1&&(r[i]=o||n)}),Object.defineProperties(A,r)},fr=A=>{Ue(A,(e,t)=>{if(N(A)&&["arguments","caller","callee"].indexOf(t)!==-1)return!1;let r=A[t];if(N(r)){if(e.enumerable=!1,"writable"in e){e.writable=!1;return}e.set||(e.set=()=>{throw Error("Can not rewrite read-only method '"+t+"'")})}})},Qr=(A,e)=>{let t={},r=n=>{n.forEach(i=>{t[i]=!0})};return q(A)?r(A):r(String(A).split(e)),t},pr=()=>{},dr=(A,e)=>(A=+A,Number.isFinite(A)?A:e),JA="abcdefghijklmnopqrstuvwxyz",De="0123456789",Ne={DIGIT:De,ALPHA:JA,ALPHA_DIGIT:JA+JA.toUpperCase()+De},mr=(A=16,e=Ne.ALPHA_DIGIT)=>{let t="",{length:r}=e;for(;A--;)t+=e[Math.random()*r|0];return t};function hr(A){return!!(A&&N(A.append)&&A[Symbol.toStringTag]==="FormData"&&A[Symbol.iterator])}var yr=A=>{let e=new Array(10),t=(r,n)=>{if(uA(r)){if(e.indexOf(r)>=0)return;if(!("toJSON"in r)){e[n]=r;let i=q(r)?[]:{};return $(r,(o,I)=>{let C=t(o,n+1);!X(C)&&(i[I]=C)}),e[n]=void 0,i}}return r};return t(A,0)},wr=G("AsyncFunction"),Dr=A=>A&&(uA(A)||N(A))&&N(A.then)&&N(A.catch),g={isArray:q,isArrayBuffer:Se,isBuffer:jt,isFormData:tr,isArrayBufferView:_t,isString:zt,isNumber:Fe,isBoolean:Vt,isObject:uA,isPlainObject:BA,isUndefined:X,isDate:Zt,isFile:Xt,isBlob:$t,isRegExp:Er,isFunction:N,isStream:er,isURLSearchParams:rr,isTypedArray:lr,isFileList:Ar,forEach:$,merge:HA,extend:nr,trim:ir,stripBOM:or,inherits:ar,toFlatObject:sr,kindOf:CA,kindOfTest:G,endsWith:Ir,toArray:gr,forEachEntry:Br,matchAll:Cr,isHTMLForm:cr,hasOwnProperty:we,hasOwnProp:we,reduceDescriptors:Ue,freezeMethods:fr,toObjectSet:Qr,toCamelCase:ur,noop:pr,toFiniteNumber:dr,findKey:ke,global:Re,isContextDefined:be,ALPHABET:Ne,generateString:mr,isSpecCompliantForm:hr,toJSONObject:yr,isAsyncFn:wr,isThenable:Dr};function K(A,e,t,r,n){Error.call(this),Error.captureStackTrace?Error.captureStackTrace(this,this.constructor):this.stack=new Error().stack,this.message=A,this.name="AxiosError",e&&(this.code=e),t&&(this.config=t),r&&(this.request=r),n&&(this.response=n)}g.inherits(K,Error,{toJSON:function(){return{message:this.message,name:this.name,description:this.description,number:this.number,fileName:this.fileName,lineNumber:this.lineNumber,columnNumber:this.columnNumber,stack:this.stack,config:g.toJSONObject(this.config),code:this.code,status:this.response&&this.response.status?this.response.status:null}}});var Ge=K.prototype,Te={};["ERR_BAD_OPTION_VALUE","ERR_BAD_OPTION","ECONNABORTED","ETIMEDOUT","ERR_NETWORK","ERR_FR_TOO_MANY_REDIRECTS","ERR_DEPRECATED","ERR_BAD_RESPONSE","ERR_BAD_REQUEST","ERR_CANCELED","ERR_NOT_SUPPORT","ERR_INVALID_URL"].forEach(A=>{Te[A]={value:A}});Object.defineProperties(K,Te);Object.defineProperty(Ge,"isAxiosError",{value:!0});K.from=(A,e,t,r,n,i)=>{let o=Object.create(Ge);return g.toFlatObject(A,o,function(C){return C!==Error.prototype},I=>I!=="isAxiosError"),K.call(o,A.message,e,t,r,n),o.cause=A,o.name=A.name,i&&Object.assign(o,i),o};var p=K;var EA=null;function YA(A){return g.isPlainObject(A)||g.isArray(A)}function xe(A){return g.endsWith(A,"[]")?A.slice(0,-2):A}function Le(A,e,t){return A?A.concat(e).map(function(n,i){return n=xe(n),!t&&i?"["+n+"]":n}).join(t?".":""):e}function Sr(A){return g.isArray(A)&&!A.some(YA)}var Fr=g.toFlatObject(g,{},null,function(e){return/^is[A-Z]/.test(e)});function kr(A,e,t){if(!g.isObject(A))throw new TypeError("target must be an object");e=e||new(EA||FormData),t=g.toFlatObject(t,{metaTokens:!0,dots:!1,indexes:!1},!1,function(c,Q){return!g.isUndefined(Q[c])});let r=t.metaTokens,n=t.visitor||s,i=t.dots,o=t.indexes,C=(t.Blob||typeof Blob<"u"&&Blob)&&g.isSpecCompliantForm(e);if(!g.isFunction(n))throw new TypeError("visitor must be a function");function l(u){if(u===null)return"";if(g.isDate(u))return u.toISOString();if(!C&&g.isBlob(u))throw new p("Blob is not supported. Use a Buffer instead.");return g.isArrayBuffer(u)||g.isTypedArray(u)?C&&typeof Blob=="function"?new Blob([u]):Buffer.from(u):u}function s(u,c,Q){let d=u;if(u&&!Q&&typeof u=="object"){if(g.endsWith(c,"{}"))c=r?c:c.slice(0,-2),u=JSON.stringify(u);else if(g.isArray(u)&&Sr(u)||(g.isFileList(u)||g.endsWith(c,"[]"))&&(d=g.toArray(u)))return c=xe(c),d.forEach(function(k,Dt){!(g.isUndefined(k)||k===null)&&e.append(o===!0?Le([c],Dt,i):o===null?c:c+"[]",l(k))}),!1}return YA(u)?!0:(e.append(Le(Q,c,i),l(u)),!1)}let a=[],E=Object.assign(Fr,{defaultVisitor:s,convertValue:l,isVisitable:YA});function B(u,c){if(!g.isUndefined(u)){if(a.indexOf(u)!==-1)throw Error("Circular reference detected in "+c.join("."));a.push(u),g.forEach(u,function(d,b){(!(g.isUndefined(d)||d===null)&&n.call(e,d,g.isString(b)?b.trim():b,c,E))===!0&&B(d,c?c.concat(b):[b])}),a.pop()}}if(!g.isObject(A))throw new TypeError("data must be an object");return B(A),e}var O=kr;function Oe(A){let e={"!":"%21","'":"%27","(":"%28",")":"%29","~":"%7E","%20":"+","%00":"\0"};return encodeURIComponent(A).replace(/[!'()~]|%20|%00/g,function(r){return e[r]})}function Pe(A,e){this._pairs=[],A&&O(A,this,e)}var Je=Pe.prototype;Je.append=function(e,t){this._pairs.push([e,t])};Je.toString=function(e){let t=e?function(r){return e.call(this,r,Oe)}:Oe;return this._pairs.map(function(n){return t(n[0])+"="+t(n[1])},"").join("&")};var fA=Pe;function Rr(A){return encodeURIComponent(A).replace(/%3A/gi,":").replace(/%24/g,"$").replace(/%2C/gi,",").replace(/%20/g,"+").replace(/%5B/gi,"[").replace(/%5D/gi,"]")}function AA(A,e,t){if(!e)return A;let r=t&&t.encode||Rr,n=t&&t.serialize,i;if(n?i=n(e,t):i=g.isURLSearchParams(e)?e.toString():new fA(e,t).toString(r),i){let o=A.indexOf("#");o!==-1&&(A=A.slice(0,o)),A+=(A.indexOf("?")===-1?"?":"&")+i}return A}var qA=class{constructor(){this.handlers=[]}use(e,t,r){return this.handlers.push({fulfilled:e,rejected:t,synchronous:r?r.synchronous:!1,runWhen:r?r.runWhen:null}),this.handlers.length-1}eject(e){this.handlers[e]&&(this.handlers[e]=null)}clear(){this.handlers&&(this.handlers=[])}forEach(e){g.forEach(this.handlers,function(r){r!==null&&e(r)})}},KA=qA;var QA={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1};var He=typeof URLSearchParams<"u"?URLSearchParams:fA;var Me=typeof FormData<"u"?FormData:null;var Ye=typeof Blob<"u"?Blob:null;var qe={isBrowser:!0,classes:{URLSearchParams:He,FormData:Me,Blob:Ye},protocols:["http","https","file","blob","url","data"]};var WA={};Ft(WA,{hasBrowserEnv:()=>Ke,hasStandardBrowserEnv:()=>br,hasStandardBrowserWebWorkerEnv:()=>Ur});var Ke=typeof window<"u"&&typeof document<"u",br=(A=>Ke&&["ReactNative","NativeScript","NS"].indexOf(A)<0)(typeof navigator<"u"&&navigator.product),Ur=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function";var D={...WA,...qe};function vA(A,e){return O(A,new D.classes.URLSearchParams,Object.assign({visitor:function(t,r,n,i){return D.isNode&&g.isBuffer(t)?(this.append(r,t.toString("base64")),!1):i.defaultVisitor.apply(this,arguments)}},e))}function Nr(A){return g.matchAll(/\w+|\[(\w*)]/g,A).map(e=>e[0]==="[]"?"":e[1]||e[0])}function Gr(A){let e={},t=Object.keys(A),r,n=t.length,i;for(r=0;r<n;r++)i=t[r],e[i]=A[i];return e}function Tr(A){function e(t,r,n,i){let o=t[i++],I=Number.isFinite(+o),C=i>=t.length;return o=!o&&g.isArray(n)?n.length:o,C?(g.hasOwnProp(n,o)?n[o]=[n[o],r]:n[o]=r,!I):((!n[o]||!g.isObject(n[o]))&&(n[o]=[]),e(t,r,n[o],i)&&g.isArray(n[o])&&(n[o]=Gr(n[o])),!I)}if(g.isFormData(A)&&g.isFunction(A.entries)){let t={};return g.forEachEntry(A,(r,n)=>{e(Nr(r),n,t,0)}),t}return null}var pA=Tr;function Lr(A,e,t){if(g.isString(A))try{return(e||JSON.parse)(A),g.trim(A)}catch(r){if(r.name!=="SyntaxError")throw r}return(t||JSON.stringify)(A)}var jA={transitional:QA,adapter:["xhr","http"],transformRequest:[function(e,t){let r=t.getContentType()||"",n=r.indexOf("application/json")>-1,i=g.isObject(e);if(i&&g.isHTMLForm(e)&&(e=new FormData(e)),g.isFormData(e))return n&&n?JSON.stringify(pA(e)):e;if(g.isArrayBuffer(e)||g.isBuffer(e)||g.isStream(e)||g.isFile(e)||g.isBlob(e))return e;if(g.isArrayBufferView(e))return e.buffer;if(g.isURLSearchParams(e))return t.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),e.toString();let I;if(i){if(r.indexOf("application/x-www-form-urlencoded")>-1)return vA(e,this.formSerializer).toString();if((I=g.isFileList(e))||r.indexOf("multipart/form-data")>-1){let C=this.env&&this.env.FormData;return O(I?{"files[]":e}:e,C&&new C,this.formSerializer)}}return i||n?(t.setContentType("application/json",!1),Lr(e)):e}],transformResponse:[function(e){let t=this.transitional||jA.transitional,r=t&&t.forcedJSONParsing,n=this.responseType==="json";if(e&&g.isString(e)&&(r&&!this.responseType||n)){let o=!(t&&t.silentJSONParsing)&&n;try{return JSON.parse(e)}catch(I){if(o)throw I.name==="SyntaxError"?p.from(I,p.ERR_BAD_RESPONSE,this,null,this.response):I}}return e}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:D.classes.FormData,Blob:D.classes.Blob},validateStatus:function(e){return e>=200&&e<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};g.forEach(["delete","get","head","post","put","patch"],A=>{jA.headers[A]={}});var W=jA;var xr=g.toObjectSet(["age","authorization","content-length","content-type","etag","expires","from","host","if-modified-since","if-unmodified-since","last-modified","location","max-forwards","proxy-authorization","referer","retry-after","user-agent"]),We=A=>{let e={},t,r,n;return A&&A.split(`
`).forEach(function(o){n=o.indexOf(":"),t=o.substring(0,n).trim().toLowerCase(),r=o.substring(n+1).trim(),!(!t||e[t]&&xr[t])&&(t==="set-cookie"?e[t]?e[t].push(r):e[t]=[r]:e[t]=e[t]?e[t]+", "+r:r)}),e};var ve=Symbol("internals");function eA(A){return A&&String(A).trim().toLowerCase()}function dA(A){return A===!1||A==null?A:g.isArray(A)?A.map(dA):String(A)}function Or(A){let e=Object.create(null),t=/([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g,r;for(;r=t.exec(A);)e[r[1]]=r[2];return e}var Pr=A=>/^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(A.trim());function _A(A,e,t,r,n){if(g.isFunction(r))return r.call(this,e,t);if(n&&(e=t),!!g.isString(e)){if(g.isString(r))return e.indexOf(r)!==-1;if(g.isRegExp(r))return r.test(e)}}function Jr(A){return A.trim().toLowerCase().replace(/([a-z\d])(\w*)/g,(e,t,r)=>t.toUpperCase()+r)}function Hr(A,e){let t=g.toCamelCase(" "+e);["get","set","has"].forEach(r=>{Object.defineProperty(A,r+t,{value:function(n,i,o){return this[r].call(this,e,n,i,o)},configurable:!0})})}var v=class{constructor(e){e&&this.set(e)}set(e,t,r){let n=this;function i(I,C,l){let s=eA(C);if(!s)throw new Error("header name must be a non-empty string");let a=g.findKey(n,s);(!a||n[a]===void 0||l===!0||l===void 0&&n[a]!==!1)&&(n[a||C]=dA(I))}let o=(I,C)=>g.forEach(I,(l,s)=>i(l,s,C));return g.isPlainObject(e)||e instanceof this.constructor?o(e,t):g.isString(e)&&(e=e.trim())&&!Pr(e)?o(We(e),t):e!=null&&i(t,e,r),this}get(e,t){if(e=eA(e),e){let r=g.findKey(this,e);if(r){let n=this[r];if(!t)return n;if(t===!0)return Or(n);if(g.isFunction(t))return t.call(this,n,r);if(g.isRegExp(t))return t.exec(n);throw new TypeError("parser must be boolean|regexp|function")}}}has(e,t){if(e=eA(e),e){let r=g.findKey(this,e);return!!(r&&this[r]!==void 0&&(!t||_A(this,this[r],r,t)))}return!1}delete(e,t){let r=this,n=!1;function i(o){if(o=eA(o),o){let I=g.findKey(r,o);I&&(!t||_A(r,r[I],I,t))&&(delete r[I],n=!0)}}return g.isArray(e)?e.forEach(i):i(e),n}clear(e){let t=Object.keys(this),r=t.length,n=!1;for(;r--;){let i=t[r];(!e||_A(this,this[i],i,e,!0))&&(delete this[i],n=!0)}return n}normalize(e){let t=this,r={};return g.forEach(this,(n,i)=>{let o=g.findKey(r,i);if(o){t[o]=dA(n),delete t[i];return}let I=e?Jr(i):String(i).trim();I!==i&&delete t[i],t[I]=dA(n),r[I]=!0}),this}concat(...e){return this.constructor.concat(this,...e)}toJSON(e){let t=Object.create(null);return g.forEach(this,(r,n)=>{r!=null&&r!==!1&&(t[n]=e&&g.isArray(r)?r.join(", "):r)}),t}[Symbol.iterator](){return Object.entries(this.toJSON())[Symbol.iterator]()}toString(){return Object.entries(this.toJSON()).map(([e,t])=>e+": "+t).join(`
`)}get[Symbol.toStringTag](){return"AxiosHeaders"}static from(e){return e instanceof this?e:new this(e)}static concat(e,...t){let r=new this(e);return t.forEach(n=>r.set(n)),r}static accessor(e){let r=(this[ve]=this[ve]={accessors:{}}).accessors,n=this.prototype;function i(o){let I=eA(o);r[I]||(Hr(n,o),r[I]=!0)}return g.isArray(e)?e.forEach(i):i(e),this}};v.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);g.reduceDescriptors(v.prototype,({value:A},e)=>{let t=e[0].toUpperCase()+e.slice(1);return{get:()=>A,set(r){this[t]=r}}});g.freezeMethods(v);var S=v;function tA(A,e){let t=this||W,r=e||t,n=S.from(r.headers),i=r.data;return g.forEach(A,function(I){i=I.call(t,i,n.normalize(),e?e.status:void 0)}),n.normalize(),i}function rA(A){return!!(A&&A.__CANCEL__)}function je(A,e,t){p.call(this,A??"canceled",p.ERR_CANCELED,e,t),this.name="CanceledError"}g.inherits(je,p,{__CANCEL__:!0});var P=je;function zA(A,e,t){let r=t.config.validateStatus;!t.status||!r||r(t.status)?A(t):e(new p("Request failed with status code "+t.status,[p.ERR_BAD_REQUEST,p.ERR_BAD_RESPONSE][Math.floor(t.status/100)-4],t.config,t.request,t))}var _e=D.hasStandardBrowserEnv?{write(A,e,t,r,n,i){let o=[A+"="+encodeURIComponent(e)];g.isNumber(t)&&o.push("expires="+new Date(t).toGMTString()),g.isString(r)&&o.push("path="+r),g.isString(n)&&o.push("domain="+n),i===!0&&o.push("secure"),document.cookie=o.join("; ")},read(A){let e=document.cookie.match(new RegExp("(^|;\\s*)("+A+")=([^;]*)"));return e?decodeURIComponent(e[3]):null},remove(A){this.write(A,"",Date.now()-864e5)}}:{write(){},read(){return null},remove(){}};function VA(A){return/^([a-z][a-z\d+\-.]*:)?\/\//i.test(A)}function ZA(A,e){return e?A.replace(/\/+$/,"")+"/"+e.replace(/^\/+/,""):A}function iA(A,e){return A&&!VA(e)?ZA(A,e):e}var ze=D.hasStandardBrowserEnv?function(){let e=/(msie|trident)/i.test(navigator.userAgent),t=document.createElement("a"),r;function n(i){let o=i;return e&&(t.setAttribute("href",o),o=t.href),t.setAttribute("href",o),{href:t.href,protocol:t.protocol?t.protocol.replace(/:$/,""):"",host:t.host,search:t.search?t.search.replace(/^\?/,""):"",hash:t.hash?t.hash.replace(/^#/,""):"",hostname:t.hostname,port:t.port,pathname:t.pathname.charAt(0)==="/"?t.pathname:"/"+t.pathname}}return r=n(window.location.href),function(o){let I=g.isString(o)?n(o):o;return I.protocol===r.protocol&&I.host===r.host}}():function(){return function(){return!0}}();function XA(A){let e=/^([-+\w]{1,25})(:?\/\/|:)/.exec(A);return e&&e[1]||""}function Mr(A,e){A=A||10;let t=new Array(A),r=new Array(A),n=0,i=0,o;return e=e!==void 0?e:1e3,function(C){let l=Date.now(),s=r[i];o||(o=l),t[n]=C,r[n]=l;let a=i,E=0;for(;a!==n;)E+=t[a++],a=a%A;if(n=(n+1)%A,n===i&&(i=(i+1)%A),l-o<e)return;let B=s&&l-s;return B?Math.round(E*1e3/B):void 0}}var Ve=Mr;function Ze(A,e){let t=0,r=Ve(50,250);return n=>{let i=n.loaded,o=n.lengthComputable?n.total:void 0,I=i-t,C=r(I),l=i<=o;t=i;let s={loaded:i,total:o,progress:o?i/o:void 0,bytes:I,rate:C||void 0,estimated:C&&o&&l?(o-i)/C:void 0,event:n};s[e?"download":"upload"]=!0,A(s)}}var Yr=typeof XMLHttpRequest<"u",Xe=Yr&&function(A){return new Promise(function(t,r){let n=A.data,i=S.from(A.headers).normalize(),{responseType:o,withXSRFToken:I}=A,C;function l(){A.cancelToken&&A.cancelToken.unsubscribe(C),A.signal&&A.signal.removeEventListener("abort",C)}let s;if(g.isFormData(n)){if(D.hasStandardBrowserEnv||D.hasStandardBrowserWebWorkerEnv)i.setContentType(!1);else if((s=i.getContentType())!==!1){let[c,...Q]=s?s.split(";").map(d=>d.trim()).filter(Boolean):[];i.setContentType([c||"multipart/form-data",...Q].join("; "))}}let a=new XMLHttpRequest;if(A.auth){let c=A.auth.username||"",Q=A.auth.password?unescape(encodeURIComponent(A.auth.password)):"";i.set("Authorization","Basic "+btoa(c+":"+Q))}let E=iA(A.baseURL,A.url);a.open(A.method.toUpperCase(),AA(E,A.params,A.paramsSerializer),!0),a.timeout=A.timeout;function B(){if(!a)return;let c=S.from("getAllResponseHeaders"in a&&a.getAllResponseHeaders()),d={data:!o||o==="text"||o==="json"?a.responseText:a.response,status:a.status,statusText:a.statusText,headers:c,config:A,request:a};zA(function(k){t(k),l()},function(k){r(k),l()},d),a=null}if("onloadend"in a?a.onloadend=B:a.onreadystatechange=function(){!a||a.readyState!==4||a.status===0&&!(a.responseURL&&a.responseURL.indexOf("file:")===0)||setTimeout(B)},a.onabort=function(){a&&(r(new p("Request aborted",p.ECONNABORTED,A,a)),a=null)},a.onerror=function(){r(new p("Network Error",p.ERR_NETWORK,A,a)),a=null},a.ontimeout=function(){let Q=A.timeout?"timeout of "+A.timeout+"ms exceeded":"timeout exceeded",d=A.transitional||QA;A.timeoutErrorMessage&&(Q=A.timeoutErrorMessage),r(new p(Q,d.clarifyTimeoutError?p.ETIMEDOUT:p.ECONNABORTED,A,a)),a=null},D.hasStandardBrowserEnv&&(I&&g.isFunction(I)&&(I=I(A)),I||I!==!1&&ze(E))){let c=A.xsrfHeaderName&&A.xsrfCookieName&&_e.read(A.xsrfCookieName);c&&i.set(A.xsrfHeaderName,c)}n===void 0&&i.setContentType(null),"setRequestHeader"in a&&g.forEach(i.toJSON(),function(Q,d){a.setRequestHeader(d,Q)}),g.isUndefined(A.withCredentials)||(a.withCredentials=!!A.withCredentials),o&&o!=="json"&&(a.responseType=A.responseType),typeof A.onDownloadProgress=="function"&&a.addEventListener("progress",Ze(A.onDownloadProgress,!0)),typeof A.onUploadProgress=="function"&&a.upload&&a.upload.addEventListener("progress",Ze(A.onUploadProgress)),(A.cancelToken||A.signal)&&(C=c=>{a&&(r(!c||c.type?new P(null,A,a):c),a.abort(),a=null)},A.cancelToken&&A.cancelToken.subscribe(C),A.signal&&(A.signal.aborted?C():A.signal.addEventListener("abort",C)));let u=XA(E);if(u&&D.protocols.indexOf(u)===-1){r(new p("Unsupported protocol "+u+":",p.ERR_BAD_REQUEST,A));return}a.send(n||null)})};var $A={http:EA,xhr:Xe};g.forEach($A,(A,e)=>{if(A){try{Object.defineProperty(A,"name",{value:e})}catch{}Object.defineProperty(A,"adapterName",{value:e})}});var $e=A=>`- ${A}`,qr=A=>g.isFunction(A)||A===null||A===!1,mA={getAdapter:A=>{A=g.isArray(A)?A:[A];let{length:e}=A,t,r,n={};for(let i=0;i<e;i++){t=A[i];let o;if(r=t,!qr(t)&&(r=$A[(o=String(t)).toLowerCase()],r===void 0))throw new p(`Unknown adapter '${o}'`);if(r)break;n[o||"#"+i]=r}if(!r){let i=Object.entries(n).map(([I,C])=>`adapter ${I} `+(C===!1?"is not supported by the environment":"is not available in the build")),o=e?i.length>1?`since :
`+i.map($e).join(`
`):" "+$e(i[0]):"as no adapter specified";throw new p("There is no suitable adapter to dispatch the request "+o,"ERR_NOT_SUPPORT")}return r},adapters:$A};function Ae(A){if(A.cancelToken&&A.cancelToken.throwIfRequested(),A.signal&&A.signal.aborted)throw new P(null,A)}function hA(A){return Ae(A),A.headers=S.from(A.headers),A.data=tA.call(A,A.transformRequest),["post","put","patch"].indexOf(A.method)!==-1&&A.headers.setContentType("application/x-www-form-urlencoded",!1),mA.getAdapter(A.adapter||W.adapter)(A).then(function(r){return Ae(A),r.data=tA.call(A,A.transformResponse,r),r.headers=S.from(r.headers),r},function(r){return rA(r)||(Ae(A),r&&r.response&&(r.response.data=tA.call(A,A.transformResponse,r.response),r.response.headers=S.from(r.response.headers))),Promise.reject(r)})}var At=A=>A instanceof S?A.toJSON():A;function L(A,e){e=e||{};let t={};function r(l,s,a){return g.isPlainObject(l)&&g.isPlainObject(s)?g.merge.call({caseless:a},l,s):g.isPlainObject(s)?g.merge({},s):g.isArray(s)?s.slice():s}function n(l,s,a){if(g.isUndefined(s)){if(!g.isUndefined(l))return r(void 0,l,a)}else return r(l,s,a)}function i(l,s){if(!g.isUndefined(s))return r(void 0,s)}function o(l,s){if(g.isUndefined(s)){if(!g.isUndefined(l))return r(void 0,l)}else return r(void 0,s)}function I(l,s,a){if(a in e)return r(l,s);if(a in A)return r(void 0,l)}let C={url:i,method:i,data:i,baseURL:o,transformRequest:o,transformResponse:o,paramsSerializer:o,timeout:o,timeoutMessage:o,withCredentials:o,withXSRFToken:o,adapter:o,responseType:o,xsrfCookieName:o,xsrfHeaderName:o,onUploadProgress:o,onDownloadProgress:o,decompress:o,maxContentLength:o,maxBodyLength:o,beforeRedirect:o,transport:o,httpAgent:o,httpsAgent:o,cancelToken:o,socketPath:o,responseEncoding:o,validateStatus:I,headers:(l,s)=>n(At(l),At(s),!0)};return g.forEach(Object.keys(Object.assign({},A,e)),function(s){let a=C[s]||n,E=a(A[s],e[s],s);g.isUndefined(E)&&a!==I||(t[s]=E)}),t}var yA="1.6.2";var ee={};["object","boolean","number","function","string","symbol"].forEach((A,e)=>{ee[A]=function(r){return typeof r===A||"a"+(e<1?"n ":" ")+A}});var et={};ee.transitional=function(e,t,r){function n(i,o){return"[Axios v"+yA+"] Transitional option '"+i+"'"+o+(r?". "+r:"")}return(i,o,I)=>{if(e===!1)throw new p(n(o," has been removed"+(t?" in "+t:"")),p.ERR_DEPRECATED);return t&&!et[o]&&(et[o]=!0,console.warn(n(o," has been deprecated since v"+t+" and will be removed in the near future"))),e?e(i,o,I):!0}};function Kr(A,e,t){if(typeof A!="object")throw new p("options must be an object",p.ERR_BAD_OPTION_VALUE);let r=Object.keys(A),n=r.length;for(;n-- >0;){let i=r[n],o=e[i];if(o){let I=A[i],C=I===void 0||o(I,i,A);if(C!==!0)throw new p("option "+i+" must be "+C,p.ERR_BAD_OPTION_VALUE);continue}if(t!==!0)throw new p("Unknown option "+i,p.ERR_BAD_OPTION)}}var wA={assertOptions:Kr,validators:ee};var J=wA.validators,j=class{constructor(e){this.defaults=e,this.interceptors={request:new KA,response:new KA}}request(e,t){typeof e=="string"?(t=t||{},t.url=e):t=e||{},t=L(this.defaults,t);let{transitional:r,paramsSerializer:n,headers:i}=t;r!==void 0&&wA.assertOptions(r,{silentJSONParsing:J.transitional(J.boolean),forcedJSONParsing:J.transitional(J.boolean),clarifyTimeoutError:J.transitional(J.boolean)},!1),n!=null&&(g.isFunction(n)?t.paramsSerializer={serialize:n}:wA.assertOptions(n,{encode:J.function,serialize:J.function},!0)),t.method=(t.method||this.defaults.method||"get").toLowerCase();let o=i&&g.merge(i.common,i[t.method]);i&&g.forEach(["delete","get","head","post","put","patch","common"],u=>{delete i[u]}),t.headers=S.concat(o,i);let I=[],C=!0;this.interceptors.request.forEach(function(c){typeof c.runWhen=="function"&&c.runWhen(t)===!1||(C=C&&c.synchronous,I.unshift(c.fulfilled,c.rejected))});let l=[];this.interceptors.response.forEach(function(c){l.push(c.fulfilled,c.rejected)});let s,a=0,E;if(!C){let u=[hA.bind(this),void 0];for(u.unshift.apply(u,I),u.push.apply(u,l),E=u.length,s=Promise.resolve(t);a<E;)s=s.then(u[a++],u[a++]);return s}E=I.length;let B=t;for(a=0;a<E;){let u=I[a++],c=I[a++];try{B=u(B)}catch(Q){c.call(this,Q);break}}try{s=hA.call(this,B)}catch(u){return Promise.reject(u)}for(a=0,E=l.length;a<E;)s=s.then(l[a++],l[a++]);return s}getUri(e){e=L(this.defaults,e);let t=iA(e.baseURL,e.url);return AA(t,e.params,e.paramsSerializer)}};g.forEach(["delete","get","head","options"],function(e){j.prototype[e]=function(t,r){return this.request(L(r||{},{method:e,url:t,data:(r||{}).data}))}});g.forEach(["post","put","patch"],function(e){function t(r){return function(i,o,I){return this.request(L(I||{},{method:e,headers:r?{"Content-Type":"multipart/form-data"}:{},url:i,data:o}))}}j.prototype[e]=t(),j.prototype[e+"Form"]=t(!0)});var nA=j;var te=class A{constructor(e){if(typeof e!="function")throw new TypeError("executor must be a function.");let t;this.promise=new Promise(function(i){t=i});let r=this;this.promise.then(n=>{if(!r._listeners)return;let i=r._listeners.length;for(;i-- >0;)r._listeners[i](n);r._listeners=null}),this.promise.then=n=>{let i,o=new Promise(I=>{r.subscribe(I),i=I}).then(n);return o.cancel=function(){r.unsubscribe(i)},o},e(function(i,o,I){r.reason||(r.reason=new P(i,o,I),t(r.reason))})}throwIfRequested(){if(this.reason)throw this.reason}subscribe(e){if(this.reason){e(this.reason);return}this._listeners?this._listeners.push(e):this._listeners=[e]}unsubscribe(e){if(!this._listeners)return;let t=this._listeners.indexOf(e);t!==-1&&this._listeners.splice(t,1)}static source(){let e;return{token:new A(function(n){e=n}),cancel:e}}},tt=te;function re(A){return function(t){return A.apply(null,t)}}function ie(A){return g.isObject(A)&&A.isAxiosError===!0}var ne={Continue:100,SwitchingProtocols:101,Processing:102,EarlyHints:103,Ok:200,Created:201,Accepted:202,NonAuthoritativeInformation:203,NoContent:204,ResetContent:205,PartialContent:206,MultiStatus:207,AlreadyReported:208,ImUsed:226,MultipleChoices:300,MovedPermanently:301,Found:302,SeeOther:303,NotModified:304,UseProxy:305,Unused:306,TemporaryRedirect:307,PermanentRedirect:308,BadRequest:400,Unauthorized:401,PaymentRequired:402,Forbidden:403,NotFound:404,MethodNotAllowed:405,NotAcceptable:406,ProxyAuthenticationRequired:407,RequestTimeout:408,Conflict:409,Gone:410,LengthRequired:411,PreconditionFailed:412,PayloadTooLarge:413,UriTooLong:414,UnsupportedMediaType:415,RangeNotSatisfiable:416,ExpectationFailed:417,ImATeapot:418,MisdirectedRequest:421,UnprocessableEntity:422,Locked:423,FailedDependency:424,TooEarly:425,UpgradeRequired:426,PreconditionRequired:428,TooManyRequests:429,RequestHeaderFieldsTooLarge:431,UnavailableForLegalReasons:451,InternalServerError:500,NotImplemented:501,BadGateway:502,ServiceUnavailable:503,GatewayTimeout:504,HttpVersionNotSupported:505,VariantAlsoNegotiates:506,InsufficientStorage:507,LoopDetected:508,NotExtended:510,NetworkAuthenticationRequired:511};Object.entries(ne).forEach(([A,e])=>{ne[e]=A});var rt=ne;function it(A){let e=new nA(A),t=Z(nA.prototype.request,e);return g.extend(t,nA.prototype,e,{allOwnKeys:!0}),g.extend(t,e,null,{allOwnKeys:!0}),t.create=function(n){return it(L(A,n))},t}var m=it(W);m.Axios=nA;m.CanceledError=P;m.CancelToken=tt;m.isCancel=rA;m.VERSION=yA;m.toFormData=O;m.AxiosError=p;m.Cancel=m.CanceledError;m.all=function(e){return Promise.all(e)};m.spread=re;m.isAxiosError=ie;m.mergeConfig=L;m.AxiosHeaders=S;m.formToJSON=A=>pA(g.isHTMLForm(A)?new FormData(A):A);m.getAdapter=mA.getAdapter;m.HttpStatusCode=rt;m.default=m;var _=m;var{Axios:La,AxiosError:xa,CanceledError:Oa,isCancel:Pa,CancelToken:Ja,VERSION:Ha,all:Ma,Cancel:Ya,isAxiosError:qa,spread:Ka,toFormData:Wa,AxiosHeaders:va,HttpStatusCode:ja,formToJSON:_a,getAdapter:za,mergeConfig:Va}=_;async function Wr(A,e){let t=A,r=null;if(t===null)r=new Worker(new URL("./web-workers/itk-wasm-pipeline.worker.js",import.meta.url),{type:"module"});else if(t.startsWith("http")){let n=await _.get(t,{responseType:"blob",params:e}),i=URL.createObjectURL(n.data);r=new Worker(i,{type:"module"})}else r=new Worker(t,{type:"module"});return r}var oA=Wr;function nt(A){let e=OA(A),t=A;return t.terminated=!1,t.workerProxy=e,t.originalTerminate=t.terminate,t.terminate=()=>{t.terminated=!0,t.workerProxy[xA](),t.originalTerminate()},{workerProxy:e,worker:t}}async function vr(A,e,t){let r;if(A!=null){let i=A;return i.workerProxy!==void 0?(r=i.workerProxy,{workerProxy:r,worker:i}):nt(A)}let n=await oA(e,t);return nt(n)}var ot=vr;async function jr(A,e,t){let r="unknown";typeof A!="string"?r=A.href:A.startsWith("http")?r=A:r=typeof e<"u"?`${e}/${A}`:A,r.endsWith(".js")&&(r=r.substring(0,r.length-3)),r.endsWith(".wasm")&&(r=r.substring(0,r.length-5));let n=`${r}.wasm`,o=(await _.get(n,{responseType:"arraybuffer",params:t})).data;return(await import(`${r}.js`)).default({wasmBinary:o})}var at=jr;var st=async()=>WebAssembly.validate(new Uint8Array([0,97,115,109,1,0,0,0,1,5,1,96,0,1,123,3,2,1,0,10,10,1,8,0,65,0,253,15,253,98,11]));var lt=typeof globalThis.SharedArrayBuffer=="function",It=new TextEncoder,gt=new TextDecoder("utf-8");function _r(A,e){let t={flags:"r",encoding:"binary"},r=A.fs_open(e,t.flags),i=A.fs_stat(e).size,o=null;lt?o=new SharedArrayBuffer(i):o=new ArrayBuffer(i);let I=new Uint8Array(o);return A.fs_read(r,I,0,i,0),A.fs_close(r),I}function Bt(A,e,t){let r=null;lt?r=new SharedArrayBuffer(t):r=new ArrayBuffer(t);let n=new Uint8Array(r),i=new Uint8Array(A.HEAPU8.buffer,e,t);return n.set(i),n}function y(A,e,t,r){let n=0;return e!==null&&(n=A.ccall("itk_wasm_input_array_alloc","number",["number","number","number","number"],[0,t,r,e.buffer.byteLength]),A.HEAPU8.set(new Uint8Array(e.buffer),n)),n}function z(A,e,t){let r=JSON.stringify(e),n=A.ccall("itk_wasm_input_json_alloc","number",["number","number","number"],[0,t,r.length]);A.writeAsciiToMemory(r,n,!1)}function U(A,e,t,r){let n=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,e,t]),i=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,e,t]),o=Bt(A,n,i);return x(r,o.buffer)}function oe(A,e){let t=A.ccall("itk_wasm_output_json_address","number",["number","number"],[0,e]),r=A.AsciiToString(t);return JSON.parse(r)}function zr(A,e,t,r){r!=null&&r.length>0&&r.forEach(function(l,s){switch(l.type){case f.TextStream:{let a=It.encode(l.data.data),E=y(A,a,s,0),B={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${E}`};z(A,B,s);break}case f.JsonCompatible:{let a=It.encode(JSON.stringify(l.data)),E=y(A,a,s,0),B={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${E}`};z(A,B,s);break}case f.BinaryStream:{let a=l.data.data,E=y(A,a,s,0),B={size:a.buffer.byteLength,data:`data:application/vnd.itk.address,0:${E}`};z(A,B,s);break}case f.TextFile:{A.fs_writeFile(l.data.path,l.data.data);break}case f.BinaryFile:{A.fs_writeFile(l.data.path,l.data.data);break}case f.Image:{let a=l.data,E=y(A,a.data,s,0),B=y(A,a.direction,s,1),u=typeof a.metadata?.entries<"u"?JSON.stringify(Array.from(a.metadata.entries())):"[]",c={imageType:a.imageType,name:a.name,origin:a.origin,spacing:a.spacing,direction:`data:application/vnd.itk.address,0:${B}`,size:a.size,data:`data:application/vnd.itk.address,0:${E}`,metadata:u};z(A,c,s);break}case f.Mesh:{let a=l.data,E=y(A,a.points,s,0),B=y(A,a.cells,s,1),u=y(A,a.pointData,s,2),c=y(A,a.cellData,s,3),Q={meshType:a.meshType,name:a.name,numberOfPoints:a.numberOfPoints,points:`data:application/vnd.itk.address,0:${E}`,numberOfCells:a.numberOfCells,cells:`data:application/vnd.itk.address,0:${B}`,cellBufferSize:a.cellBufferSize,numberOfPointPixels:a.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${u}`,numberOfCellPixels:a.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${c}`};z(A,Q,s);break}case f.PolyData:{let a=l.data,E=y(A,a.points,s,0),B=y(A,a.vertices,s,1),u=y(A,a.lines,s,2),c=y(A,a.polygons,s,3),Q=y(A,a.triangleStrips,s,4),d=y(A,a.pointData,s,5),b=y(A,a.pointData,s,6),k={polyDataType:a.polyDataType,name:a.name,numberOfPoints:a.numberOfPoints,points:`data:application/vnd.itk.address,0:${E}`,verticesBufferSize:a.verticesBufferSize,vertices:`data:application/vnd.itk.address,0:${B}`,linesBufferSize:a.linesBufferSize,lines:`data:application/vnd.itk.address,0:${u}`,polygonsBufferSize:a.polygonsBufferSize,polygons:`data:application/vnd.itk.address,0:${c}`,triangleStripsBufferSize:a.triangleStripsBufferSize,triangleStrips:`data:application/vnd.itk.address,0:${Q}`,numberOfPointPixels:a.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${d}`,numberOfCellPixels:a.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${b}`};z(A,k,s);break}default:throw Error("Unsupported input InterfaceType")}}),A.resetModuleStdout(),A.resetModuleStderr();let n=A.stackSave(),i=0;try{i=A.callMain(e.slice())}catch(l){throw typeof l=="number"&&(console.log("Exception while running pipeline:"),console.log("stdout:",A.getModuleStdout()),console.error("stderr:",A.getModuleStderr()),typeof A.getExceptionMessage<"u"?console.error("exception:",A.getExceptionMessage(l)):console.error("Build module in Debug mode for exception message information.")),l}finally{A.stackRestore(n)}let o=A.getModuleStdout(),I=A.getModuleStderr(),C=[];return t!=null&&t.length>0&&i===0&&t.forEach(function(l,s){let a=null;switch(l.type){case f.TextStream:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,s,0]),u=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,s,0]),c=new Uint8Array(A.HEAPU8.buffer,B,u);a={data:gt.decode(c)};break}case f.JsonCompatible:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,s,0]),u=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,s,0]),c=new Uint8Array(A.HEAPU8.buffer,B,u);a=JSON.parse(gt.decode(c));break}case f.BinaryStream:{let B=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,s,0]),u=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,s,0]);a={data:Bt(A,B,u)};break}case f.TextFile:{a={path:l.data.path,data:A.fs_readFile(l.data.path,{encoding:"utf8"})};break}case f.BinaryFile:{a={path:l.data.path,data:_r(A,l.data.path)};break}case f.Image:{let B=oe(A,s);B.data=U(A,s,0,B.imageType.componentType),B.direction=U(A,s,1,M.Float64),B.metadata=new Map(B.metadata),a=B;break}case f.Mesh:{let B=oe(A,s);B.numberOfPoints>0?B.points=U(A,s,0,B.meshType.pointComponentType):B.points=x(B.meshType.pointComponentType,new ArrayBuffer(0)),B.numberOfCells>0?B.cells=U(A,s,1,B.meshType.cellComponentType):B.cells=x(B.meshType.cellComponentType,new ArrayBuffer(0)),B.numberOfPointPixels>0?B.pointData=U(A,s,2,B.meshType.pointPixelComponentType):B.pointData=x(B.meshType.pointPixelComponentType,new ArrayBuffer(0)),B.numberOfCellPixels>0?B.cellData=U(A,s,3,B.meshType.cellPixelComponentType):B.cellData=x(B.meshType.cellPixelComponentType,new ArrayBuffer(0)),a=B;break}case f.PolyData:{let B=oe(A,s);B.numberOfPoints>0?B.points=U(A,s,0,M.Float32):B.points=new Float32Array,B.verticesBufferSize>0?B.vertices=U(A,s,1,h.UInt32):B.vertices=new Uint32Array,B.linesBufferSize>0?B.lines=U(A,s,2,h.UInt32):B.lines=new Uint32Array,B.polygonsBufferSize>0?B.polygons=U(A,s,3,h.UInt32):B.polygons=new Uint32Array,B.triangleStripsBufferSize>0?B.triangleStrips=U(A,s,4,h.UInt32):B.triangleStrips=new Uint32Array,B.numberOfPointPixels>0?B.pointData=U(A,s,5,B.polyDataType.pointPixelComponentType):B.pointData=x(B.polyDataType.pointPixelComponentType,new ArrayBuffer(0)),B.numberOfCellPixels>0?B.cellData=U(A,s,6,B.polyDataType.cellPixelComponentType):B.cellData=x(B.polyDataType.cellPixelComponentType,new ArrayBuffer(0)),a=B;break}default:throw Error("Unsupported output InterfaceType")}let E={type:l.type,data:a};C.push(E)}),{returnValue:i,stdout:o,stderr:I,outputs:C}}var Ct=zr;var Vr=typeof globalThis.SharedArrayBuffer<"u";function Zr(A,e){if(A==null)return[];let t=[];for(let r=0;r<A.length;r++){let n=Xr(A[r],e);n!==null&&t.push(n)}return t}function Xr(A,e){if(A==null)return null;let t=null;return A.buffer!==void 0?t=A.buffer:A.byteLength!==void 0&&(t=A),Vr&&t instanceof SharedArrayBuffer?null:e?t:t.slice(0)}var ct=Zr;function $r(A){return[A.data,A.direction]}var ut=$r;function Ai(A){return[A.points,A.pointData,A.cells,A.cellData]}var Et=Ai;function ei(A){return[A.points,A.vertices,A.lines,A.polygons,A.triangleStrips,A.pointData,A.cellData]}var ft=ei;var ti;function DA(){return ti}var ri;function Qt(){return ri}var ii;function SA(){return ii}var ae=new Map;function ni(){let A=SA();return typeof A>"u"&&(A=null),A}function pt(){let A=DA();return typeof A>"u"&&(A=new URL("/pipelines",document.location.origin).href),A}function FA(){let A=Qt();return typeof A>"u"&&(A={}),A}async function oi(A,e,t){let r=A,n=A;if(typeof A!="string"&&(r=new URL(A.href),n=r.href),ae.has(n))return ae.get(n);{let i=await at(A,e?.toString()??pt(),t??FA());return ae.set(n,i),i}}async function ai(A,e,t,r,n){if(!await st()){let Q="WebAssembly SIMD support is required -- please update your browser.";throw alert(Q),new Error(Q)}let i=n?.webWorker??null;if(i===!1){let Q=await oi(A.toString(),n?.pipelineBaseUrl,n?.pipelineQueryParams??FA());return Ct(Q,e,t,r)}let o=i,I=n?.pipelineWorkerUrl??ni(),C=typeof I!="string"&&typeof I?.href<"u"?I.href:I,{workerProxy:l,worker:s}=await ot(o,C,n?.pipelineQueryParams??FA());o=s;let a=[];r!=null&&r.length>0&&r.forEach(function(Q){if(Q.type===f.BinaryStream){let d=Q.data.data;a.push(d)}else if(Q.type===f.BinaryFile){let d=Q.data.data;a.push(d)}else if(Q.type===f.Image){let d=Q.data;d.data!==null&&a.push(...ut(d))}else if(Q.type===f.Mesh){let d=Q.data;a.push(...Et(d))}else if(Q.type===f.PolyData){let d=Q.data;a.push(...ft(d))}});let E=n?.pipelineBaseUrl??pt(),B=typeof E!="string"&&typeof E?.href<"u"?E.href:E,u=r!=null?PA(r,ct(a,n?.noCopy)):null,c=await l.runPipeline(A.toString(),B,e,t,u,n?.pipelineQueryParams??FA());return{returnValue:c.returnValue,stdout:c.stdout,stderr:c.stderr,outputs:c.outputs,webWorker:o}}var F=ai;var si=null;function dt(){return si}var se,Ii=`https://cdn.jsdelivr.net/npm/@itk-wasm/dicom@${kA}/dist/pipelines`;function Hs(A){se=A}function R(){if(typeof se<"u")return se;let A=DA();return typeof A<"u"?A:Ii}var Ie,gi=null;function mt(A){Ie=A}function w(){if(typeof Ie<"u")return Ie;let A=SA();return typeof A<"u"?A:gi}var V=null;async function ht(){let A=w(),e=typeof A!="string"&&typeof A?.href<"u"?A.href:A;V=await oA(e)}function js(A){V=A}async function T(){if(V!==null)return V.terminated&&await ht(),V;let A=dt();return A!==null?A:(await ht(),V)}async function li(A,e,t={}){let r=[{type:f.JsonCompatible},{type:f.Image}],n=A;if(A instanceof File){let k=await A.arrayBuffer();n={path:A.name,data:new Uint8Array(k)}}let i=e;if(e instanceof File){let k=await e.arrayBuffer();i={path:e.name,data:new Uint8Array(k)}}let o=[{type:f.BinaryFile,data:n},{type:f.BinaryFile,data:i}],I=[],C=n.path;I.push(C);let l=i.path;I.push(l);let s="0";I.push(s);let a="1";I.push(a),I.push("--memory-io"),t.colorOutput&&t.colorOutput&&I.push("--color-output"),t.configFile&&I.push("--config-file",t.configFile.toString()),t.frame&&I.push("--frame",t.frame.toString()),t.noPresentationStateOutput&&t.noPresentationStateOutput&&I.push("--no-presentation-state-output"),t.noBitmapOutput&&t.noBitmapOutput&&I.push("--no-bitmap-output");let E="apply-presentation-state-to-image",B=t?.webWorker;B===void 0&&(B=await T());let{webWorker:u,returnValue:c,stderr:Q,outputs:d}=await F(E,I,r,o,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:B,noCopy:t?.noCopy});if(c!==0&&Q!=="")throw new Error(Q);return{webWorker:u,presentationStateOutStream:d[0]?.data,outputImage:d[1]?.data}}var Bi=li;async function Ci(A,e={}){let t=[{type:f.BinaryStream}],r=A;if(A instanceof File){let c=await A.arrayBuffer();r={path:A.name,data:new Uint8Array(c)}}let n=[{type:f.BinaryFile,data:r}],i=[],o=r.path;i.push(o);let I="0";i.push(I),i.push("--memory-io"),e.readFileOnly&&e.readFileOnly&&i.push("--read-file-only"),e.readDataset&&e.readDataset&&i.push("--read-dataset"),e.readXferAuto&&e.readXferAuto&&i.push("--read-xfer-auto"),e.readXferDetect&&e.readXferDetect&&i.push("--read-xfer-detect"),e.readXferLittle&&e.readXferLittle&&i.push("--read-xfer-little"),e.readXferBig&&e.readXferBig&&i.push("--read-xfer-big"),e.readXferImplicit&&e.readXferImplicit&&i.push("--read-xfer-implicit"),e.acceptOddLength&&e.acceptOddLength&&i.push("--accept-odd-length"),e.assumeEvenLength&&e.assumeEvenLength&&i.push("--assume-even-length"),e.enableCp246&&e.enableCp246&&i.push("--enable-cp246"),e.disableCp246&&e.disableCp246&&i.push("--disable-cp246"),e.retainUn&&e.retainUn&&i.push("--retain-un"),e.convertUn&&e.convertUn&&i.push("--convert-un"),e.enableCorrection&&e.enableCorrection&&i.push("--enable-correction"),e.disableCorrection&&e.disableCorrection&&i.push("--disable-correction");let C="read-dicom-encapsulated-pdf",l=e?.webWorker;l===void 0&&(l=await T());let{webWorker:s,returnValue:a,stderr:E,outputs:B}=await F(C,i,t,n,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:l,noCopy:e?.noCopy});if(a!==0&&E!=="")throw new Error(E);return{webWorker:s,pdfBinaryOutput:(B[0]?.data).data}}var ci=Ci;async function ui(A,e={}){let t=[{type:f.TextStream}],r=A;if(A instanceof File){let c=await A.arrayBuffer();r={path:A.name,data:new Uint8Array(c)}}let n=[{type:f.BinaryFile,data:r}],i=[],o=r.path;i.push(o);let I="0";if(i.push(I),i.push("--memory-io"),e.readFileOnly&&e.readFileOnly&&i.push("--read-file-only"),e.readDataset&&e.readDataset&&i.push("--read-dataset"),e.readXferAuto&&e.readXferAuto&&i.push("--read-xfer-auto"),e.readXferDetect&&e.readXferDetect&&i.push("--read-xfer-detect"),e.readXferLittle&&e.readXferLittle&&i.push("--read-xfer-little"),e.readXferBig&&e.readXferBig&&i.push("--read-xfer-big"),e.readXferImplicit&&e.readXferImplicit&&i.push("--read-xfer-implicit"),e.processingDetails&&e.processingDetails&&i.push("--processing-details"),e.unknownRelationship&&e.unknownRelationship&&i.push("--unknown-relationship"),e.invalidItemValue&&e.invalidItemValue&&i.push("--invalid-item-value"),e.ignoreConstraints&&e.ignoreConstraints&&i.push("--ignore-constraints"),e.ignoreItemErrors&&e.ignoreItemErrors&&i.push("--ignore-item-errors"),e.skipInvalidItems&&e.skipInvalidItems&&i.push("--skip-invalid-items"),e.disableVrChecker&&e.disableVrChecker&&i.push("--disable-vr-checker"),e.charsetRequire&&e.charsetRequire&&i.push("--charset-require"),e.charsetAssume&&i.push("--charset-assume",e.charsetAssume.toString()),e.charsetCheckAll&&e.charsetCheckAll&&i.push("--charset-check-all"),e.convertToUtf8&&e.convertToUtf8&&i.push("--convert-to-utf8"),e.urlPrefix&&i.push("--url-prefix",e.urlPrefix.toString()),e.html32&&e.html32&&i.push("--html-32"),e.html40&&e.html40&&i.push("--html-40"),e.xhtml11&&e.xhtml11&&i.push("--xhtml-11"),e.addDocumentType&&e.addDocumentType&&i.push("--add-document-type"),e.cssReference){let c=n.length.toString();n.push({type:f.TextStream,data:{data:e.cssReference}}),i.push("--css-reference",c)}if(e.cssFile){let c=e.cssFile,Q=c;if(c instanceof File){let b=await c.arrayBuffer();Q={path:c.name,data:new TextDecoder().decode(b)}}i.push("--css-file"),n.push({type:f.TextFile,data:Q});let d=c instanceof File?c.name:c.path;i.push(d)}e.expandInline&&e.expandInline&&i.push("--expand-inline"),e.neverExpandInline&&e.neverExpandInline&&i.push("--never-expand-inline"),e.alwaysExpandInline&&e.alwaysExpandInline&&i.push("--always-expand-inline"),e.renderFullData&&e.renderFullData&&i.push("--render-full-data"),e.sectionTitleInline&&e.sectionTitleInline&&i.push("--section-title-inline"),e.documentTypeTitle&&e.documentTypeTitle&&i.push("--document-type-title"),e.patientInfoTitle&&e.patientInfoTitle&&i.push("--patient-info-title"),e.noDocumentHeader&&e.noDocumentHeader&&i.push("--no-document-header"),e.renderInlineCodes&&e.renderInlineCodes&&i.push("--render-inline-codes"),e.conceptNameCodes&&e.conceptNameCodes&&i.push("--concept-name-codes"),e.numericUnitCodes&&e.numericUnitCodes&&i.push("--numeric-unit-codes"),e.codeValueUnit&&e.codeValueUnit&&i.push("--code-value-unit"),e.codeMeaningUnit&&e.codeMeaningUnit&&i.push("--code-meaning-unit"),e.renderAllCodes&&e.renderAllCodes&&i.push("--render-all-codes"),e.codeDetailsTooltip&&e.codeDetailsTooltip&&i.push("--code-details-tooltip");let C="structured-report-to-html",l=e?.webWorker;l===void 0&&(l=await T());let{webWorker:s,returnValue:a,stderr:E,outputs:B}=await F(C,i,t,n,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:l,noCopy:e?.noCopy});if(a!==0&&E!=="")throw new Error(E);return{webWorker:s,outputText:(B[0]?.data).data}}var Ei=ui;async function fi(A,e={}){let t=[{type:f.TextStream}],r=A;if(A instanceof File){let c=await A.arrayBuffer();r={path:A.name,data:new Uint8Array(c)}}let n=[{type:f.BinaryFile,data:r}],i=[],o=r.path;i.push(o);let I="0";i.push(I),i.push("--memory-io"),e.unknownRelationship&&e.unknownRelationship&&i.push("--unknown-relationship"),e.invalidItemValue&&e.invalidItemValue&&i.push("--invalid-item-value"),e.ignoreConstraints&&e.ignoreConstraints&&i.push("--ignore-constraints"),e.ignoreItemErrors&&e.ignoreItemErrors&&i.push("--ignore-item-errors"),e.skipInvalidItems&&e.skipInvalidItems&&i.push("--skip-invalid-items"),e.noDocumentHeader&&e.noDocumentHeader&&i.push("--no-document-header"),e.numberNestedItems&&e.numberNestedItems&&i.push("--number-nested-items"),e.shortenLongValues&&e.shortenLongValues&&i.push("--shorten-long-values"),e.printInstanceUid&&e.printInstanceUid&&i.push("--print-instance-uid"),e.printSopclassShort&&e.printSopclassShort&&i.push("--print-sopclass-short"),e.printSopclassLong&&e.printSopclassLong&&i.push("--print-sopclass-long"),e.printSopclassUid&&e.printSopclassUid&&i.push("--print-sopclass-uid"),e.printAllCodes&&e.printAllCodes&&i.push("--print-all-codes"),e.printInvalidCodes&&e.printInvalidCodes&&i.push("--print-invalid-codes"),e.printTemplateId&&e.printTemplateId&&i.push("--print-template-id"),e.indicateEnhanced&&e.indicateEnhanced&&i.push("--indicate-enhanced"),e.printColor&&e.printColor&&i.push("--print-color");let C="structured-report-to-text",l=e?.webWorker;l===void 0&&(l=await T());let{webWorker:s,returnValue:a,stderr:E,outputs:B}=await F(C,i,t,n,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:l,noCopy:e?.noCopy});if(a!==0&&E!=="")throw new Error(E);return{webWorker:s,outputText:(B[0]?.data).data}}var Qi=fi;async function pi(A,e={}){let t=[{type:f.JsonCompatible}],r=A;if(A instanceof File){let u=await A.arrayBuffer();r={path:A.name,data:new Uint8Array(u)}}let n=[{type:f.BinaryFile,data:r}],i=[],o=r.path;i.push(o);let I="0";if(i.push(I),i.push("--memory-io"),typeof e.tagsToRead<"u"){let u=n.length.toString();n.push({type:f.JsonCompatible,data:e.tagsToRead}),i.push("--tags-to-read",u)}let C="read-dicom-tags",{webWorker:l,returnValue:s,stderr:a,outputs:E}=await F(C,i,t,n,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:e?.webWorker??null});if(s!==0)throw new Error(a);return{webWorker:l,tags:E[0].data}}var di=pi;async function mi(A,e=!1,t={}){let r=[{type:f.Image},{type:f.JsonCompatible}],n=[],i=[],o="0";i.push(o);let I="1";i.push(I),i.push("--memory-io"),i.push("--input-images"),A.forEach(u=>{n.push({type:f.BinaryFile,data:u}),i.push(u.path)}),typeof e<"u"&&e&&i.push("--single-sorted-series");let C="read-image-dicom-file-series",{webWorker:l,returnValue:s,stderr:a,outputs:E}=await F(C,i,r,n,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:t?.webWorker??null});if(s!==0)throw new Error(a);return{webWorker:l,outputImage:E[0].data,sortedFilenames:E[1].data}}var ge=mi;var hi=typeof globalThis.navigator?.hardwareConcurrency=="number"?globalThis.navigator.hardwareConcurrency:4,yt=8;async function yi(A={inputImages:[]}){let e=A.webWorkerPool??null;e===null&&(e=new GA(hi,ge));let t=[];if(A.inputImages.length<1)throw new Error('"input-images" option must have a length > 1');if(await Promise.all(A.inputImages.map(async r=>{let n=r;if(r instanceof File){let i=await r.arrayBuffer();n={path:r.name,data:new Uint8Array(i)}}t.push(n)})),A.singleSortedSeries){let r=[];for(let C=0;C<t.length;C+=yt){let l=t.slice(C,C+yt);r.push([l,A.singleSortedSeries,{}])}let n=await e.runTasks(r).promise,i=n.map(C=>C.outputImage),o=n.reduce((C,l)=>C.concat(l.sortedFilenames),[]);return{outputImage:UA(i),webWorkerPool:e,sortedFilenames:o}}else{let r=[[t,A.singleSortedSeries,{}]],n=await e.runTasks(r).promise;return{outputImage:n[0].outputImage,webWorkerPool:e,sortedFilenames:n[0].sortedFilenames}}}var wi=yi;async function Di(A={files:[]}){let e=[{type:f.JsonCompatible}],t=[],r=[],n="0";if(r.push(n),r.push("--memory-io"),A.files){if(A.files.length<1)throw new Error('"files" option must have a length > 1');r.push("--files"),await Promise.all(A.files.map(async E=>{let B=E;if(E instanceof File){let c=await E.arrayBuffer();B={path:E.name,data:new Uint8Array(c)}}t.push({type:f.BinaryFile,data:B});let u=E instanceof File?E.name:B.path;r.push(u)}))}let i="image-sets-normalization",o=A?.webWorker;o===void 0&&(o=await T());let{webWorker:I,returnValue:C,stderr:l,outputs:s}=await F(i,r,e,t,{pipelineBaseUrl:R(),pipelineWorkerUrl:w(),webWorker:o,noCopy:A?.noCopy});if(C!==0&&l!=="")throw new Error(l);return{webWorker:I,imageSets:s[0]?.data}}var Si=Di;var wt='data:text/javascript;charset=utf-8,var tt=Object.defineProperty;var et=(A,I)=>{for(var t in I)tt(A,t,{get:I[t],enumerable:!0})};var vA=Symbol("Comlink.proxy"),gt=Symbol("Comlink.endpoint"),rt=Symbol("Comlink.releaseProxy"),mA=Symbol("Comlink.finalizer"),eA=Symbol("Comlink.thrown"),$A=A=>typeof A=="object"&&A!==null||typeof A=="function",it={canHandle:A=>$A(A)&&A[vA],serialize(A){let{port1:I,port2:t}=new MessageChannel;return oA(A,I),[t,[t]]},deserialize(A){return A.start(),st(A)}},ot={canHandle:A=>$A(A)&&eA in A,serialize({value:A}){let I;return A instanceof Error?I={isError:!0,value:{message:A.message,name:A.name,stack:A.stack}}:I={isError:!1,value:A},[I,[]]},deserialize(A){throw A.isError?Object.assign(new Error(A.value.message),A.value):A.value}},AI=new Map([["proxy",it],["throw",ot]]);function Bt(A,I){for(let t of A)if(I===t||t==="*"||t instanceof RegExp&&t.test(I))return!0;return!1}function oA(A,I=globalThis,t=["*"]){I.addEventListener("message",function e(g){if(!g||!g.data)return;if(!Bt(t,g.origin)){console.warn(`Invalid origin \'${g.origin}\' for comlink proxy`);return}let{id:r,type:i,path:s}=Object.assign({path:[]},g.data),a=(g.data.argumentList||[]).map(b),n;try{let C=s.slice(0,-1).reduce((f,Q)=>f[Q],A),o=s.reduce((f,Q)=>f[Q],A);switch(i){case"GET":n=o;break;case"SET":C[s.slice(-1)[0]]=b(g.data.value),n=!0;break;case"APPLY":n=o.apply(C,a);break;case"CONSTRUCT":{let f=new o(...a);n=at(f)}break;case"ENDPOINT":{let{port1:f,port2:Q}=new MessageChannel;oA(A,Q),n=SA(f,[f])}break;case"RELEASE":n=void 0;break;default:return}}catch(C){n={value:C,[eA]:0}}Promise.resolve(n).catch(C=>({value:C,[eA]:0})).then(C=>{let[o,f]=iA(C);I.postMessage(Object.assign(Object.assign({},o),{id:r}),f),i==="RELEASE"&&(I.removeEventListener("message",e),II(I),mA in A&&typeof A[mA]=="function"&&A[mA]())}).catch(C=>{let[o,f]=iA({value:new TypeError("Unserializable return value"),[eA]:0});I.postMessage(Object.assign(Object.assign({},o),{id:r}),f)})}),I.start&&I.start()}function Ct(A){return A.constructor.name==="MessagePort"}function II(A){Ct(A)&&A.close()}function st(A,I){return pA(A,[],I)}function tA(A){if(A)throw new Error("Proxy has been released and is not useable")}function tI(A){return M(A,{type:"RELEASE"}).then(()=>{II(A)})}var gA=new WeakMap,rA="FinalizationRegistry"in globalThis&&new FinalizationRegistry(A=>{let I=(gA.get(A)||0)-1;gA.set(A,I),I===0&&tI(A)});function Qt(A,I){let t=(gA.get(I)||0)+1;gA.set(I,t),rA&&rA.register(A,I,A)}function nt(A){rA&&rA.unregister(A)}function pA(A,I=[],t=function(){}){let e=!1,g=new Proxy(t,{get(r,i){if(tA(e),i===rt)return()=>{nt(g),tI(A),e=!0};if(i==="then"){if(I.length===0)return{then:()=>g};let s=M(A,{type:"GET",path:I.map(a=>a.toString())}).then(b);return s.then.bind(s)}return pA(A,[...I,i])},set(r,i,s){tA(e);let[a,n]=iA(s);return M(A,{type:"SET",path:[...I,i].map(C=>C.toString()),value:a},n).then(b)},apply(r,i,s){tA(e);let a=I[I.length-1];if(a===gt)return M(A,{type:"ENDPOINT"}).then(b);if(a==="bind")return pA(A,I.slice(0,-1));let[n,C]=_A(s);return M(A,{type:"APPLY",path:I.map(o=>o.toString()),argumentList:n},C).then(b)},construct(r,i){tA(e);let[s,a]=_A(i);return M(A,{type:"CONSTRUCT",path:I.map(n=>n.toString()),argumentList:s},a).then(b)}});return Qt(g,A),g}function Et(A){return Array.prototype.concat.apply([],A)}function _A(A){let I=A.map(iA);return[I.map(t=>t[0]),Et(I.map(t=>t[1]))]}var eI=new WeakMap;function SA(A,I){return eI.set(A,I),A}function at(A){return Object.assign(A,{[vA]:!0})}function iA(A){for(let[I,t]of AI)if(t.canHandle(A)){let[e,g]=t.serialize(A);return[{type:"HANDLER",name:I,value:e},g]}return[{type:"RAW",value:A},eI.get(A)||[]]}function b(A){switch(A.type){case"HANDLER":return AI.get(A.name).deserialize(A.value);case"RAW":return A.value}}function M(A,I,t){return new Promise(e=>{let g=ct();A.addEventListener("message",function r(i){!i.data||!i.data.id||i.data.id!==g||(A.removeEventListener("message",r),e(i.data))}),A.start&&A.start(),A.postMessage(Object.assign({id:g},I),t)})}function ct(){return new Array(4).fill(0).map(()=>Math.floor(Math.random()*Number.MAX_SAFE_INTEGER).toString(16)).join("-")}function W(A,I){return function(){return A.apply(I,arguments)}}var{toString:ft}=Object.prototype,{getPrototypeOf:NA}=Object,CA=(A=>I=>{let t=ft.call(I);return A[t]||(A[t]=t.slice(8,-1).toLowerCase())})(Object.create(null)),U=A=>(A=A.toLowerCase(),I=>CA(I)===A),sA=A=>I=>typeof I===A,{isArray:q}=Array,Z=sA("undefined");function lt(A){return A!==null&&!Z(A)&&A.constructor!==null&&!Z(A.constructor)&&F(A.constructor.isBuffer)&&A.constructor.isBuffer(A)}var oI=U("ArrayBuffer");function Dt(A){let I;return typeof ArrayBuffer<"u"&&ArrayBuffer.isView?I=ArrayBuffer.isView(A):I=A&&A.buffer&&oI(A.buffer),I}var ut=sA("string"),F=sA("function"),BI=sA("number"),QA=A=>A!==null&&typeof A=="object",ht=A=>A===!0||A===!1,BA=A=>{if(CA(A)!=="object")return!1;let I=NA(A);return(I===null||I===Object.prototype||Object.getPrototypeOf(I)===null)&&!(Symbol.toStringTag in A)&&!(Symbol.iterator in A)},dt=U("Date"),yt=U("File"),wt=U("Blob"),mt=U("FileList"),pt=A=>QA(A)&&F(A.pipe),St=A=>{let I;return A&&(typeof FormData=="function"&&A instanceof FormData||F(A.append)&&((I=CA(A))==="formdata"||I==="object"&&F(A.toString)&&A.toString()==="[object FormData]"))},Ft=U("URLSearchParams"),Rt=A=>A.trim?A.trim():A.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,"");function V(A,I,{allOwnKeys:t=!1}={}){if(A===null||typeof A>"u")return;let e,g;if(typeof A!="object"&&(A=[A]),q(A))for(e=0,g=A.length;e<g;e++)I.call(null,A[e],e,A);else{let r=t?Object.getOwnPropertyNames(A):Object.keys(A),i=r.length,s;for(e=0;e<i;e++)s=r[e],I.call(null,A[s],s,A)}}function CI(A,I){I=I.toLowerCase();let t=Object.keys(A),e=t.length,g;for(;e-- >0;)if(g=t[e],I===g.toLowerCase())return g;return null}var sI=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:global,QI=A=>!Z(A)&&A!==sI;function RA(){let{caseless:A}=QI(this)&&this||{},I={},t=(e,g)=>{let r=A&&CI(I,g)||g;BA(I[r])&&BA(e)?I[r]=RA(I[r],e):BA(e)?I[r]=RA({},e):q(e)?I[r]=e.slice():I[r]=e};for(let e=0,g=arguments.length;e<g;e++)arguments[e]&&V(arguments[e],t);return I}var Nt=(A,I,t,{allOwnKeys:e}={})=>(V(I,(g,r)=>{t&&F(g)?A[r]=W(g,t):A[r]=g},{allOwnKeys:e}),A),Ut=A=>(A.charCodeAt(0)===65279&&(A=A.slice(1)),A),Gt=(A,I,t,e)=>{A.prototype=Object.create(I.prototype,e),A.prototype.constructor=A,Object.defineProperty(A,"super",{value:I.prototype}),t&&Object.assign(A.prototype,t)},kt=(A,I,t,e)=>{let g,r,i,s={};if(I=I||{},A==null)return I;do{for(g=Object.getOwnPropertyNames(A),r=g.length;r-- >0;)i=g[r],(!e||e(i,A,I))&&!s[i]&&(I[i]=A[i],s[i]=!0);A=t!==!1&&NA(A)}while(A&&(!t||t(A,I))&&A!==Object.prototype);return I},Lt=(A,I,t)=>{A=String(A),(t===void 0||t>A.length)&&(t=A.length),t-=I.length;let e=A.indexOf(I,t);return e!==-1&&e===t},Jt=A=>{if(!A)return null;if(q(A))return A;let I=A.length;if(!BI(I))return null;let t=new Array(I);for(;I-- >0;)t[I]=A[I];return t},Ht=(A=>I=>A&&I instanceof A)(typeof Uint8Array<"u"&&NA(Uint8Array)),Yt=(A,I)=>{let e=(A&&A[Symbol.iterator]).call(A),g;for(;(g=e.next())&&!g.done;){let r=g.value;I.call(A,r[0],r[1])}},bt=(A,I)=>{let t,e=[];for(;(t=A.exec(I))!==null;)e.push(t);return e},Mt=U("HTMLFormElement"),qt=A=>A.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,function(t,e,g){return e.toUpperCase()+g}),rI=(({hasOwnProperty:A})=>(I,t)=>A.call(I,t))(Object.prototype),Kt=U("RegExp"),nI=(A,I)=>{let t=Object.getOwnPropertyDescriptors(A),e={};V(t,(g,r)=>{let i;(i=I(g,r,A))!==!1&&(e[r]=i||g)}),Object.defineProperties(A,e)},Ot=A=>{nI(A,(I,t)=>{if(F(A)&&["arguments","caller","callee"].indexOf(t)!==-1)return!1;let e=A[t];if(F(e)){if(I.enumerable=!1,"writable"in I){I.writable=!1;return}I.set||(I.set=()=>{throw Error("Can not rewrite read-only method \'"+t+"\'")})}})},Tt=(A,I)=>{let t={},e=g=>{g.forEach(r=>{t[r]=!0})};return q(A)?e(A):e(String(A).split(I)),t},xt=()=>{},Pt=(A,I)=>(A=+A,Number.isFinite(A)?A:I),FA="abcdefghijklmnopqrstuvwxyz",iI="0123456789",EI={DIGIT:iI,ALPHA:FA,ALPHA_DIGIT:FA+FA.toUpperCase()+iI},jt=(A=16,I=EI.ALPHA_DIGIT)=>{let t="",{length:e}=I;for(;A--;)t+=I[Math.random()*e|0];return t};function Wt(A){return!!(A&&F(A.append)&&A[Symbol.toStringTag]==="FormData"&&A[Symbol.iterator])}var Zt=A=>{let I=new Array(10),t=(e,g)=>{if(QA(e)){if(I.indexOf(e)>=0)return;if(!("toJSON"in e)){I[g]=e;let r=q(e)?[]:{};return V(e,(i,s)=>{let a=t(i,g+1);!Z(a)&&(r[s]=a)}),I[g]=void 0,r}}return e};return t(A,0)},Vt=U("AsyncFunction"),Xt=A=>A&&(QA(A)||F(A))&&F(A.then)&&F(A.catch),B={isArray:q,isArrayBuffer:oI,isBuffer:lt,isFormData:St,isArrayBufferView:Dt,isString:ut,isNumber:BI,isBoolean:ht,isObject:QA,isPlainObject:BA,isUndefined:Z,isDate:dt,isFile:yt,isBlob:wt,isRegExp:Kt,isFunction:F,isStream:pt,isURLSearchParams:Ft,isTypedArray:Ht,isFileList:mt,forEach:V,merge:RA,extend:Nt,trim:Rt,stripBOM:Ut,inherits:Gt,toFlatObject:kt,kindOf:CA,kindOfTest:U,endsWith:Lt,toArray:Jt,forEachEntry:Yt,matchAll:bt,isHTMLForm:Mt,hasOwnProperty:rI,hasOwnProp:rI,reduceDescriptors:nI,freezeMethods:Ot,toObjectSet:Tt,toCamelCase:qt,noop:xt,toFiniteNumber:Pt,findKey:CI,global:sI,isContextDefined:QI,ALPHABET:EI,generateString:jt,isSpecCompliantForm:Wt,toJSONObject:Zt,isAsyncFn:Vt,isThenable:Xt};function K(A,I,t,e,g){Error.call(this),Error.captureStackTrace?Error.captureStackTrace(this,this.constructor):this.stack=new Error().stack,this.message=A,this.name="AxiosError",I&&(this.code=I),t&&(this.config=t),e&&(this.request=e),g&&(this.response=g)}B.inherits(K,Error,{toJSON:function(){return{message:this.message,name:this.name,description:this.description,number:this.number,fileName:this.fileName,lineNumber:this.lineNumber,columnNumber:this.columnNumber,stack:this.stack,config:B.toJSONObject(this.config),code:this.code,status:this.response&&this.response.status?this.response.status:null}}});var aI=K.prototype,cI={};["ERR_BAD_OPTION_VALUE","ERR_BAD_OPTION","ECONNABORTED","ETIMEDOUT","ERR_NETWORK","ERR_FR_TOO_MANY_REDIRECTS","ERR_DEPRECATED","ERR_BAD_RESPONSE","ERR_BAD_REQUEST","ERR_CANCELED","ERR_NOT_SUPPORT","ERR_INVALID_URL"].forEach(A=>{cI[A]={value:A}});Object.defineProperties(K,cI);Object.defineProperty(aI,"isAxiosError",{value:!0});K.from=(A,I,t,e,g,r)=>{let i=Object.create(aI);return B.toFlatObject(A,i,function(a){return a!==Error.prototype},s=>s!=="isAxiosError"),K.call(i,A.message,I,t,e,g),i.cause=A,i.name=A.name,r&&Object.assign(i,r),i};var l=K;var nA=null;function UA(A){return B.isPlainObject(A)||B.isArray(A)}function lI(A){return B.endsWith(A,"[]")?A.slice(0,-2):A}function fI(A,I,t){return A?A.concat(I).map(function(g,r){return g=lI(g),!t&&r?"["+g+"]":g}).join(t?".":""):I}function zt(A){return B.isArray(A)&&!A.some(UA)}var _t=B.toFlatObject(B,{},null,function(I){return/^is[A-Z]/.test(I)});function vt(A,I,t){if(!B.isObject(A))throw new TypeError("target must be an object");I=I||new(nA||FormData),t=B.toFlatObject(t,{metaTokens:!0,dots:!1,indexes:!1},!1,function(c,u){return!B.isUndefined(u[c])});let e=t.metaTokens,g=t.visitor||C,r=t.dots,i=t.indexes,a=(t.Blob||typeof Blob<"u"&&Blob)&&B.isSpecCompliantForm(I);if(!B.isFunction(g))throw new TypeError("visitor must be a function");function n(E){if(E===null)return"";if(B.isDate(E))return E.toISOString();if(!a&&B.isBlob(E))throw new l("Blob is not supported. Use a Buffer instead.");return B.isArrayBuffer(E)||B.isTypedArray(E)?a&&typeof Blob=="function"?new Blob([E]):Buffer.from(E):E}function C(E,c,u){let d=E;if(E&&!u&&typeof E=="object"){if(B.endsWith(c,"{}"))c=e?c:c.slice(0,-2),E=JSON.stringify(E);else if(B.isArray(E)&&zt(E)||(B.isFileList(E)||B.endsWith(c,"[]"))&&(d=B.toArray(E)))return c=lI(c),d.forEach(function(N,It){!(B.isUndefined(N)||N===null)&&I.append(i===!0?fI([c],It,r):i===null?c:c+"[]",n(N))}),!1}return UA(E)?!0:(I.append(fI(u,c,r),n(E)),!1)}let o=[],f=Object.assign(_t,{defaultVisitor:C,convertValue:n,isVisitable:UA});function Q(E,c){if(!B.isUndefined(E)){if(o.indexOf(E)!==-1)throw Error("Circular reference detected in "+c.join("."));o.push(E),B.forEach(E,function(d,R){(!(B.isUndefined(d)||d===null)&&g.call(I,d,B.isString(R)?R.trim():R,c,f))===!0&&Q(d,c?c.concat(R):[R])}),o.pop()}}if(!B.isObject(A))throw new TypeError("data must be an object");return Q(A),I}var L=vt;function DI(A){let I={"!":"%2521","\'":"%2527","(":"%2528",")":"%2529","~":"%257E","%2520":"+","%2500":"\\0"};return encodeURIComponent(A).replace(/[!\'()~]|%2520|%2500/g,function(e){return I[e]})}function uI(A,I){this._pairs=[],A&&L(A,this,I)}var hI=uI.prototype;hI.append=function(I,t){this._pairs.push([I,t])};hI.toString=function(I){let t=I?function(e){return I.call(this,e,DI)}:DI;return this._pairs.map(function(g){return t(g[0])+"="+t(g[1])},"").join("&")};var EA=uI;function $t(A){return encodeURIComponent(A).replace(/%253A/gi,":").replace(/%2524/g,"$").replace(/%252C/gi,",").replace(/%2520/g,"+").replace(/%255B/gi,"[").replace(/%255D/gi,"]")}function X(A,I,t){if(!I)return A;let e=t&&t.encode||$t,g=t&&t.serialize,r;if(g?r=g(I,t):r=B.isURLSearchParams(I)?I.toString():new EA(I,t).toString(e),r){let i=A.indexOf("%23");i!==-1&&(A=A.slice(0,i)),A+=(A.indexOf("?")===-1?"?":"&")+r}return A}var GA=class{constructor(){this.handlers=[]}use(I,t,e){return this.handlers.push({fulfilled:I,rejected:t,synchronous:e?e.synchronous:!1,runWhen:e?e.runWhen:null}),this.handlers.length-1}eject(I){this.handlers[I]&&(this.handlers[I]=null)}clear(){this.handlers&&(this.handlers=[])}forEach(I){B.forEach(this.handlers,function(e){e!==null&&I(e)})}},kA=GA;var aA={silentJSONParsing:!0,forcedJSONParsing:!0,clarifyTimeoutError:!1};var dI=typeof URLSearchParams<"u"?URLSearchParams:EA;var yI=typeof FormData<"u"?FormData:null;var wI=typeof Blob<"u"?Blob:null;var mI={isBrowser:!0,classes:{URLSearchParams:dI,FormData:yI,Blob:wI},protocols:["http","https","file","blob","url","data"]};var LA={};et(LA,{hasBrowserEnv:()=>pI,hasStandardBrowserEnv:()=>Ae,hasStandardBrowserWebWorkerEnv:()=>Ie});var pI=typeof window<"u"&&typeof document<"u",Ae=(A=>pI&&["ReactNative","NativeScript","NS"].indexOf(A)<0)(typeof navigator<"u"&&navigator.product),Ie=typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope&&typeof self.importScripts=="function";var w={...LA,...mI};function JA(A,I){return L(A,new w.classes.URLSearchParams,Object.assign({visitor:function(t,e,g,r){return w.isNode&&B.isBuffer(t)?(this.append(e,t.toString("base64")),!1):r.defaultVisitor.apply(this,arguments)}},I))}function te(A){return B.matchAll(/\\w+|\\[(\\w*)]/g,A).map(I=>I[0]==="[]"?"":I[1]||I[0])}function ee(A){let I={},t=Object.keys(A),e,g=t.length,r;for(e=0;e<g;e++)r=t[e],I[r]=A[r];return I}function ge(A){function I(t,e,g,r){let i=t[r++],s=Number.isFinite(+i),a=r>=t.length;return i=!i&&B.isArray(g)?g.length:i,a?(B.hasOwnProp(g,i)?g[i]=[g[i],e]:g[i]=e,!s):((!g[i]||!B.isObject(g[i]))&&(g[i]=[]),I(t,e,g[i],r)&&B.isArray(g[i])&&(g[i]=ee(g[i])),!s)}if(B.isFormData(A)&&B.isFunction(A.entries)){let t={};return B.forEachEntry(A,(e,g)=>{I(te(e),g,t,0)}),t}return null}var cA=ge;function re(A,I,t){if(B.isString(A))try{return(I||JSON.parse)(A),B.trim(A)}catch(e){if(e.name!=="SyntaxError")throw e}return(t||JSON.stringify)(A)}var HA={transitional:aA,adapter:["xhr","http"],transformRequest:[function(I,t){let e=t.getContentType()||"",g=e.indexOf("application/json")>-1,r=B.isObject(I);if(r&&B.isHTMLForm(I)&&(I=new FormData(I)),B.isFormData(I))return g&&g?JSON.stringify(cA(I)):I;if(B.isArrayBuffer(I)||B.isBuffer(I)||B.isStream(I)||B.isFile(I)||B.isBlob(I))return I;if(B.isArrayBufferView(I))return I.buffer;if(B.isURLSearchParams(I))return t.setContentType("application/x-www-form-urlencoded;charset=utf-8",!1),I.toString();let s;if(r){if(e.indexOf("application/x-www-form-urlencoded")>-1)return JA(I,this.formSerializer).toString();if((s=B.isFileList(I))||e.indexOf("multipart/form-data")>-1){let a=this.env&&this.env.FormData;return L(s?{"files[]":I}:I,a&&new a,this.formSerializer)}}return r||g?(t.setContentType("application/json",!1),re(I)):I}],transformResponse:[function(I){let t=this.transitional||HA.transitional,e=t&&t.forcedJSONParsing,g=this.responseType==="json";if(I&&B.isString(I)&&(e&&!this.responseType||g)){let i=!(t&&t.silentJSONParsing)&&g;try{return JSON.parse(I)}catch(s){if(i)throw s.name==="SyntaxError"?l.from(s,l.ERR_BAD_RESPONSE,this,null,this.response):s}}return I}],timeout:0,xsrfCookieName:"XSRF-TOKEN",xsrfHeaderName:"X-XSRF-TOKEN",maxContentLength:-1,maxBodyLength:-1,env:{FormData:w.classes.FormData,Blob:w.classes.Blob},validateStatus:function(I){return I>=200&&I<300},headers:{common:{Accept:"application/json, text/plain, */*","Content-Type":void 0}}};B.forEach(["delete","get","head","post","put","patch"],A=>{HA.headers[A]={}});var O=HA;var ie=B.toObjectSet(["age","authorization","content-length","content-type","etag","expires","from","host","if-modified-since","if-unmodified-since","last-modified","location","max-forwards","proxy-authorization","referer","retry-after","user-agent"]),SI=A=>{let I={},t,e,g;return A&&A.split(`%0A`).forEach(function(i){g=i.indexOf(":"),t=i.substring(0,g).trim().toLowerCase(),e=i.substring(g+1).trim(),!(!t||I[t]&&ie[t])&&(t==="set-cookie"?I[t]?I[t].push(e):I[t]=[e]:I[t]=I[t]?I[t]+", "+e:e)}),I};var FI=Symbol("internals");function z(A){return A&&String(A).trim().toLowerCase()}function fA(A){return A===!1||A==null?A:B.isArray(A)?A.map(fA):String(A)}function oe(A){let I=Object.create(null),t=/([^\\s,;=]+)\\s*(?:=\\s*([^,;]+))?/g,e;for(;e=t.exec(A);)I[e[1]]=e[2];return I}var Be=A=>/^[-_a-zA-Z0-9^`|~,!%23$%&\'*+.]+$/.test(A.trim());function YA(A,I,t,e,g){if(B.isFunction(e))return e.call(this,I,t);if(g&&(I=t),!!B.isString(I)){if(B.isString(e))return I.indexOf(e)!==-1;if(B.isRegExp(e))return e.test(I)}}function Ce(A){return A.trim().toLowerCase().replace(/([a-z\\d])(\\w*)/g,(I,t,e)=>t.toUpperCase()+e)}function se(A,I){let t=B.toCamelCase(" "+I);["get","set","has"].forEach(e=>{Object.defineProperty(A,e+t,{value:function(g,r,i){return this[e].call(this,I,g,r,i)},configurable:!0})})}var T=class{constructor(I){I&&this.set(I)}set(I,t,e){let g=this;function r(s,a,n){let C=z(a);if(!C)throw new Error("header name must be a non-empty string");let o=B.findKey(g,C);(!o||g[o]===void 0||n===!0||n===void 0&&g[o]!==!1)&&(g[o||a]=fA(s))}let i=(s,a)=>B.forEach(s,(n,C)=>r(n,C,a));return B.isPlainObject(I)||I instanceof this.constructor?i(I,t):B.isString(I)&&(I=I.trim())&&!Be(I)?i(SI(I),t):I!=null&&r(t,I,e),this}get(I,t){if(I=z(I),I){let e=B.findKey(this,I);if(e){let g=this[e];if(!t)return g;if(t===!0)return oe(g);if(B.isFunction(t))return t.call(this,g,e);if(B.isRegExp(t))return t.exec(g);throw new TypeError("parser must be boolean|regexp|function")}}}has(I,t){if(I=z(I),I){let e=B.findKey(this,I);return!!(e&&this[e]!==void 0&&(!t||YA(this,this[e],e,t)))}return!1}delete(I,t){let e=this,g=!1;function r(i){if(i=z(i),i){let s=B.findKey(e,i);s&&(!t||YA(e,e[s],s,t))&&(delete e[s],g=!0)}}return B.isArray(I)?I.forEach(r):r(I),g}clear(I){let t=Object.keys(this),e=t.length,g=!1;for(;e--;){let r=t[e];(!I||YA(this,this[r],r,I,!0))&&(delete this[r],g=!0)}return g}normalize(I){let t=this,e={};return B.forEach(this,(g,r)=>{let i=B.findKey(e,r);if(i){t[i]=fA(g),delete t[r];return}let s=I?Ce(r):String(r).trim();s!==r&&delete t[r],t[s]=fA(g),e[s]=!0}),this}concat(...I){return this.constructor.concat(this,...I)}toJSON(I){let t=Object.create(null);return B.forEach(this,(e,g)=>{e!=null&&e!==!1&&(t[g]=I&&B.isArray(e)?e.join(", "):e)}),t}[Symbol.iterator](){return Object.entries(this.toJSON())[Symbol.iterator]()}toString(){return Object.entries(this.toJSON()).map(([I,t])=>I+": "+t).join(`%0A`)}get[Symbol.toStringTag](){return"AxiosHeaders"}static from(I){return I instanceof this?I:new this(I)}static concat(I,...t){let e=new this(I);return t.forEach(g=>e.set(g)),e}static accessor(I){let e=(this[FI]=this[FI]={accessors:{}}).accessors,g=this.prototype;function r(i){let s=z(i);e[s]||(se(g,i),e[s]=!0)}return B.isArray(I)?I.forEach(r):r(I),this}};T.accessor(["Content-Type","Content-Length","Accept","Accept-Encoding","User-Agent","Authorization"]);B.reduceDescriptors(T.prototype,({value:A},I)=>{let t=I[0].toUpperCase()+I.slice(1);return{get:()=>A,set(e){this[t]=e}}});B.freezeMethods(T);var m=T;function _(A,I){let t=this||O,e=I||t,g=m.from(e.headers),r=e.data;return B.forEach(A,function(s){r=s.call(t,r,g.normalize(),I?I.status:void 0)}),g.normalize(),r}function v(A){return!!(A&&A.__CANCEL__)}function RI(A,I,t){l.call(this,A??"canceled",l.ERR_CANCELED,I,t),this.name="CanceledError"}B.inherits(RI,l,{__CANCEL__:!0});var J=RI;function bA(A,I,t){let e=t.config.validateStatus;!t.status||!e||e(t.status)?A(t):I(new l("Request failed with status code "+t.status,[l.ERR_BAD_REQUEST,l.ERR_BAD_RESPONSE][Math.floor(t.status/100)-4],t.config,t.request,t))}var NI=w.hasStandardBrowserEnv?{write(A,I,t,e,g,r){let i=[A+"="+encodeURIComponent(I)];B.isNumber(t)&&i.push("expires="+new Date(t).toGMTString()),B.isString(e)&&i.push("path="+e),B.isString(g)&&i.push("domain="+g),r===!0&&i.push("secure"),document.cookie=i.join("; ")},read(A){let I=document.cookie.match(new RegExp("(^|;\\\\s*)("+A+")=([^;]*)"));return I?decodeURIComponent(I[3]):null},remove(A){this.write(A,"",Date.now()-864e5)}}:{write(){},read(){return null},remove(){}};function MA(A){return/^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.test(A)}function qA(A,I){return I?A.replace(/\\/+$/,"")+"/"+I.replace(/^\\/+/,""):A}function $(A,I){return A&&!MA(I)?qA(A,I):I}var UI=w.hasStandardBrowserEnv?function(){let I=/(msie|trident)/i.test(navigator.userAgent),t=document.createElement("a"),e;function g(r){let i=r;return I&&(t.setAttribute("href",i),i=t.href),t.setAttribute("href",i),{href:t.href,protocol:t.protocol?t.protocol.replace(/:$/,""):"",host:t.host,search:t.search?t.search.replace(/^\\?/,""):"",hash:t.hash?t.hash.replace(/^%23/,""):"",hostname:t.hostname,port:t.port,pathname:t.pathname.charAt(0)==="/"?t.pathname:"/"+t.pathname}}return e=g(window.location.href),function(i){let s=B.isString(i)?g(i):i;return s.protocol===e.protocol&&s.host===e.host}}():function(){return function(){return!0}}();function KA(A){let I=/^([-+\\w]{1,25})(:?\\/\\/|:)/.exec(A);return I&&I[1]||""}function Qe(A,I){A=A||10;let t=new Array(A),e=new Array(A),g=0,r=0,i;return I=I!==void 0?I:1e3,function(a){let n=Date.now(),C=e[r];i||(i=n),t[g]=a,e[g]=n;let o=r,f=0;for(;o!==g;)f+=t[o++],o=o%A;if(g=(g+1)%A,g===r&&(r=(r+1)%A),n-i<I)return;let Q=C&&n-C;return Q?Math.round(f*1e3/Q):void 0}}var GI=Qe;function kI(A,I){let t=0,e=GI(50,250);return g=>{let r=g.loaded,i=g.lengthComputable?g.total:void 0,s=r-t,a=e(s),n=r<=i;t=r;let C={loaded:r,total:i,progress:i?r/i:void 0,bytes:s,rate:a||void 0,estimated:a&&i&&n?(i-r)/a:void 0,event:g};C[I?"download":"upload"]=!0,A(C)}}var ne=typeof XMLHttpRequest<"u",LI=ne&&function(A){return new Promise(function(t,e){let g=A.data,r=m.from(A.headers).normalize(),{responseType:i,withXSRFToken:s}=A,a;function n(){A.cancelToken&&A.cancelToken.unsubscribe(a),A.signal&&A.signal.removeEventListener("abort",a)}let C;if(B.isFormData(g)){if(w.hasStandardBrowserEnv||w.hasStandardBrowserWebWorkerEnv)r.setContentType(!1);else if((C=r.getContentType())!==!1){let[c,...u]=C?C.split(";").map(d=>d.trim()).filter(Boolean):[];r.setContentType([c||"multipart/form-data",...u].join("; "))}}let o=new XMLHttpRequest;if(A.auth){let c=A.auth.username||"",u=A.auth.password?unescape(encodeURIComponent(A.auth.password)):"";r.set("Authorization","Basic "+btoa(c+":"+u))}let f=$(A.baseURL,A.url);o.open(A.method.toUpperCase(),X(f,A.params,A.paramsSerializer),!0),o.timeout=A.timeout;function Q(){if(!o)return;let c=m.from("getAllResponseHeaders"in o&&o.getAllResponseHeaders()),d={data:!i||i==="text"||i==="json"?o.responseText:o.response,status:o.status,statusText:o.statusText,headers:c,config:A,request:o};bA(function(N){t(N),n()},function(N){e(N),n()},d),o=null}if("onloadend"in o?o.onloadend=Q:o.onreadystatechange=function(){!o||o.readyState!==4||o.status===0&&!(o.responseURL&&o.responseURL.indexOf("file:")===0)||setTimeout(Q)},o.onabort=function(){o&&(e(new l("Request aborted",l.ECONNABORTED,A,o)),o=null)},o.onerror=function(){e(new l("Network Error",l.ERR_NETWORK,A,o)),o=null},o.ontimeout=function(){let u=A.timeout?"timeout of "+A.timeout+"ms exceeded":"timeout exceeded",d=A.transitional||aA;A.timeoutErrorMessage&&(u=A.timeoutErrorMessage),e(new l(u,d.clarifyTimeoutError?l.ETIMEDOUT:l.ECONNABORTED,A,o)),o=null},w.hasStandardBrowserEnv&&(s&&B.isFunction(s)&&(s=s(A)),s||s!==!1&&UI(f))){let c=A.xsrfHeaderName&&A.xsrfCookieName&&NI.read(A.xsrfCookieName);c&&r.set(A.xsrfHeaderName,c)}g===void 0&&r.setContentType(null),"setRequestHeader"in o&&B.forEach(r.toJSON(),function(u,d){o.setRequestHeader(d,u)}),B.isUndefined(A.withCredentials)||(o.withCredentials=!!A.withCredentials),i&&i!=="json"&&(o.responseType=A.responseType),typeof A.onDownloadProgress=="function"&&o.addEventListener("progress",kI(A.onDownloadProgress,!0)),typeof A.onUploadProgress=="function"&&o.upload&&o.upload.addEventListener("progress",kI(A.onUploadProgress)),(A.cancelToken||A.signal)&&(a=c=>{o&&(e(!c||c.type?new J(null,A,o):c),o.abort(),o=null)},A.cancelToken&&A.cancelToken.subscribe(a),A.signal&&(A.signal.aborted?a():A.signal.addEventListener("abort",a)));let E=KA(f);if(E&&w.protocols.indexOf(E)===-1){e(new l("Unsupported protocol "+E+":",l.ERR_BAD_REQUEST,A));return}o.send(g||null)})};var OA={http:nA,xhr:LI};B.forEach(OA,(A,I)=>{if(A){try{Object.defineProperty(A,"name",{value:I})}catch{}Object.defineProperty(A,"adapterName",{value:I})}});var JI=A=>`- ${A}`,Ee=A=>B.isFunction(A)||A===null||A===!1,lA={getAdapter:A=>{A=B.isArray(A)?A:[A];let{length:I}=A,t,e,g={};for(let r=0;r<I;r++){t=A[r];let i;if(e=t,!Ee(t)&&(e=OA[(i=String(t)).toLowerCase()],e===void 0))throw new l(`Unknown adapter \'${i}\'`);if(e)break;g[i||"%23"+r]=e}if(!e){let r=Object.entries(g).map(([s,a])=>`adapter ${s} `+(a===!1?"is not supported by the environment":"is not available in the build")),i=I?r.length>1?`since :%0A`+r.map(JI).join(`%0A`):" "+JI(r[0]):"as no adapter specified";throw new l("There is no suitable adapter to dispatch the request "+i,"ERR_NOT_SUPPORT")}return e},adapters:OA};function TA(A){if(A.cancelToken&&A.cancelToken.throwIfRequested(),A.signal&&A.signal.aborted)throw new J(null,A)}function DA(A){return TA(A),A.headers=m.from(A.headers),A.data=_.call(A,A.transformRequest),["post","put","patch"].indexOf(A.method)!==-1&&A.headers.setContentType("application/x-www-form-urlencoded",!1),lA.getAdapter(A.adapter||O.adapter)(A).then(function(e){return TA(A),e.data=_.call(A,A.transformResponse,e),e.headers=m.from(e.headers),e},function(e){return v(e)||(TA(A),e&&e.response&&(e.response.data=_.call(A,A.transformResponse,e.response),e.response.headers=m.from(e.response.headers))),Promise.reject(e)})}var HI=A=>A instanceof m?A.toJSON():A;function G(A,I){I=I||{};let t={};function e(n,C,o){return B.isPlainObject(n)&&B.isPlainObject(C)?B.merge.call({caseless:o},n,C):B.isPlainObject(C)?B.merge({},C):B.isArray(C)?C.slice():C}function g(n,C,o){if(B.isUndefined(C)){if(!B.isUndefined(n))return e(void 0,n,o)}else return e(n,C,o)}function r(n,C){if(!B.isUndefined(C))return e(void 0,C)}function i(n,C){if(B.isUndefined(C)){if(!B.isUndefined(n))return e(void 0,n)}else return e(void 0,C)}function s(n,C,o){if(o in I)return e(n,C);if(o in A)return e(void 0,n)}let a={url:r,method:r,data:r,baseURL:i,transformRequest:i,transformResponse:i,paramsSerializer:i,timeout:i,timeoutMessage:i,withCredentials:i,withXSRFToken:i,adapter:i,responseType:i,xsrfCookieName:i,xsrfHeaderName:i,onUploadProgress:i,onDownloadProgress:i,decompress:i,maxContentLength:i,maxBodyLength:i,beforeRedirect:i,transport:i,httpAgent:i,httpsAgent:i,cancelToken:i,socketPath:i,responseEncoding:i,validateStatus:s,headers:(n,C)=>g(HI(n),HI(C),!0)};return B.forEach(Object.keys(Object.assign({},A,I)),function(C){let o=a[C]||g,f=o(A[C],I[C],C);B.isUndefined(f)&&o!==s||(t[C]=f)}),t}var uA="1.6.2";var xA={};["object","boolean","number","function","string","symbol"].forEach((A,I)=>{xA[A]=function(e){return typeof e===A||"a"+(I<1?"n ":" ")+A}});var YI={};xA.transitional=function(I,t,e){function g(r,i){return"[Axios v"+uA+"] Transitional option \'"+r+"\'"+i+(e?". "+e:"")}return(r,i,s)=>{if(I===!1)throw new l(g(i," has been removed"+(t?" in "+t:"")),l.ERR_DEPRECATED);return t&&!YI[i]&&(YI[i]=!0,console.warn(g(i," has been deprecated since v"+t+" and will be removed in the near future"))),I?I(r,i,s):!0}};function ae(A,I,t){if(typeof A!="object")throw new l("options must be an object",l.ERR_BAD_OPTION_VALUE);let e=Object.keys(A),g=e.length;for(;g-- >0;){let r=e[g],i=I[r];if(i){let s=A[r],a=s===void 0||i(s,r,A);if(a!==!0)throw new l("option "+r+" must be "+a,l.ERR_BAD_OPTION_VALUE);continue}if(t!==!0)throw new l("Unknown option "+r,l.ERR_BAD_OPTION)}}var hA={assertOptions:ae,validators:xA};var H=hA.validators,x=class{constructor(I){this.defaults=I,this.interceptors={request:new kA,response:new kA}}request(I,t){typeof I=="string"?(t=t||{},t.url=I):t=I||{},t=G(this.defaults,t);let{transitional:e,paramsSerializer:g,headers:r}=t;e!==void 0&&hA.assertOptions(e,{silentJSONParsing:H.transitional(H.boolean),forcedJSONParsing:H.transitional(H.boolean),clarifyTimeoutError:H.transitional(H.boolean)},!1),g!=null&&(B.isFunction(g)?t.paramsSerializer={serialize:g}:hA.assertOptions(g,{encode:H.function,serialize:H.function},!0)),t.method=(t.method||this.defaults.method||"get").toLowerCase();let i=r&&B.merge(r.common,r[t.method]);r&&B.forEach(["delete","get","head","post","put","patch","common"],E=>{delete r[E]}),t.headers=m.concat(i,r);let s=[],a=!0;this.interceptors.request.forEach(function(c){typeof c.runWhen=="function"&&c.runWhen(t)===!1||(a=a&&c.synchronous,s.unshift(c.fulfilled,c.rejected))});let n=[];this.interceptors.response.forEach(function(c){n.push(c.fulfilled,c.rejected)});let C,o=0,f;if(!a){let E=[DA.bind(this),void 0];for(E.unshift.apply(E,s),E.push.apply(E,n),f=E.length,C=Promise.resolve(t);o<f;)C=C.then(E[o++],E[o++]);return C}f=s.length;let Q=t;for(o=0;o<f;){let E=s[o++],c=s[o++];try{Q=E(Q)}catch(u){c.call(this,u);break}}try{C=DA.call(this,Q)}catch(E){return Promise.reject(E)}for(o=0,f=n.length;o<f;)C=C.then(n[o++],n[o++]);return C}getUri(I){I=G(this.defaults,I);let t=$(I.baseURL,I.url);return X(t,I.params,I.paramsSerializer)}};B.forEach(["delete","get","head","options"],function(I){x.prototype[I]=function(t,e){return this.request(G(e||{},{method:I,url:t,data:(e||{}).data}))}});B.forEach(["post","put","patch"],function(I){function t(e){return function(r,i,s){return this.request(G(s||{},{method:I,headers:e?{"Content-Type":"multipart/form-data"}:{},url:r,data:i}))}}x.prototype[I]=t(),x.prototype[I+"Form"]=t(!0)});var AA=x;var PA=class A{constructor(I){if(typeof I!="function")throw new TypeError("executor must be a function.");let t;this.promise=new Promise(function(r){t=r});let e=this;this.promise.then(g=>{if(!e._listeners)return;let r=e._listeners.length;for(;r-- >0;)e._listeners[r](g);e._listeners=null}),this.promise.then=g=>{let r,i=new Promise(s=>{e.subscribe(s),r=s}).then(g);return i.cancel=function(){e.unsubscribe(r)},i},I(function(r,i,s){e.reason||(e.reason=new J(r,i,s),t(e.reason))})}throwIfRequested(){if(this.reason)throw this.reason}subscribe(I){if(this.reason){I(this.reason);return}this._listeners?this._listeners.push(I):this._listeners=[I]}unsubscribe(I){if(!this._listeners)return;let t=this._listeners.indexOf(I);t!==-1&&this._listeners.splice(t,1)}static source(){let I;return{token:new A(function(g){I=g}),cancel:I}}},bI=PA;function jA(A){return function(t){return A.apply(null,t)}}function WA(A){return B.isObject(A)&&A.isAxiosError===!0}var ZA={Continue:100,SwitchingProtocols:101,Processing:102,EarlyHints:103,Ok:200,Created:201,Accepted:202,NonAuthoritativeInformation:203,NoContent:204,ResetContent:205,PartialContent:206,MultiStatus:207,AlreadyReported:208,ImUsed:226,MultipleChoices:300,MovedPermanently:301,Found:302,SeeOther:303,NotModified:304,UseProxy:305,Unused:306,TemporaryRedirect:307,PermanentRedirect:308,BadRequest:400,Unauthorized:401,PaymentRequired:402,Forbidden:403,NotFound:404,MethodNotAllowed:405,NotAcceptable:406,ProxyAuthenticationRequired:407,RequestTimeout:408,Conflict:409,Gone:410,LengthRequired:411,PreconditionFailed:412,PayloadTooLarge:413,UriTooLong:414,UnsupportedMediaType:415,RangeNotSatisfiable:416,ExpectationFailed:417,ImATeapot:418,MisdirectedRequest:421,UnprocessableEntity:422,Locked:423,FailedDependency:424,TooEarly:425,UpgradeRequired:426,PreconditionRequired:428,TooManyRequests:429,RequestHeaderFieldsTooLarge:431,UnavailableForLegalReasons:451,InternalServerError:500,NotImplemented:501,BadGateway:502,ServiceUnavailable:503,GatewayTimeout:504,HttpVersionNotSupported:505,VariantAlsoNegotiates:506,InsufficientStorage:507,LoopDetected:508,NotExtended:510,NetworkAuthenticationRequired:511};Object.entries(ZA).forEach(([A,I])=>{ZA[I]=A});var MI=ZA;function qI(A){let I=new AA(A),t=W(AA.prototype.request,I);return B.extend(t,AA.prototype,I,{allOwnKeys:!0}),B.extend(t,I,null,{allOwnKeys:!0}),t.create=function(g){return qI(G(A,g))},t}var h=qI(O);h.Axios=AA;h.CanceledError=J;h.CancelToken=bI;h.isCancel=v;h.VERSION=uA;h.toFormData=L;h.AxiosError=l;h.Cancel=h.CanceledError;h.all=function(I){return Promise.all(I)};h.spread=jA;h.isAxiosError=WA;h.mergeConfig=G;h.AxiosHeaders=m;h.formToJSON=A=>cA(B.isHTMLForm(A)?new FormData(A):A);h.getAdapter=lA.getAdapter;h.HttpStatusCode=MI;h.default=h;var dA=h;var{Axios:oi,AxiosError:Bi,CanceledError:Ci,isCancel:si,CancelToken:Qi,VERSION:ni,all:Ei,Cancel:ai,isAxiosError:ci,spread:fi,toFormData:li,AxiosHeaders:Di,HttpStatusCode:ui,formToJSON:hi,getAdapter:di,mergeConfig:yi}=dA;var IA,k,XA,VA={env:{emscripten_notify_memory_growth:function(A){XA=new Uint8Array(k.exports.memory.buffer)}}},yA=class{init(){return IA||(typeof fetch<"u"?IA=fetch("data:application/wasm;base64,"+KI).then(I=>I.arrayBuffer()).then(I=>WebAssembly.instantiate(I,VA)).then(this._init):IA=WebAssembly.instantiate(Buffer.from(KI,"base64"),VA).then(this._init),IA)}_init(I){k=I.instance,VA.env.emscripten_notify_memory_growth(0)}decode(I,t=0){if(!k)throw new Error("ZSTDDecoder: Await .init() before decoding.");let e=I.byteLength,g=k.exports.malloc(e);XA.set(I,g),t=t||Number(k.exports.ZSTD_findDecompressedSize(g,e));let r=k.exports.malloc(t),i=k.exports.ZSTD_decompress(r,t,g,e),s=XA.slice(r,r+i);return k.exports.free(g),k.exports.free(r),s}},KI="AGFzbQEAAAABbg5gA39/fwF/YAF/AX9gAn9/AGABfwBgBX9/f39/AX9gA39/fwBgBH9/f38Bf2AAAX9gAn9/AX9gB39/f39/f38Bf2ACf38BfmAIf39/f39/f38Bf2AFf39/f38AYA5/f39/f39/f39/f39/fwF/AicBA2Vudh9lbXNjcmlwdGVuX25vdGlmeV9tZW1vcnlfZ3Jvd3RoAAMDIyIHAAABAQMHAwEACQQABQEICAEFBgQEBAMGAAAKAAULDA0GBAUBcAEBAQUHAQGAAoCAAgYIAX8BQYCjBAsHrgELBm1lbW9yeQIABm1hbGxvYwAFBGZyZWUABgxaU1REX2lzRXJyb3IAEhlaU1REX2ZpbmREZWNvbXByZXNzZWRTaXplABwPWlNURF9kZWNvbXByZXNzACIZX19pbmRpcmVjdF9mdW5jdGlvbl90YWJsZQEAEF9fZXJybm9fbG9jYXRpb24AAQlzdGFja1NhdmUABwxzdGFja1Jlc3RvcmUACApzdGFja0FsbG9jAAkKi/IBIgUAQYQfCzMBAX8gAgRAIAAhAwNAIAMgAS0AADoAACADQQFqIQMgAUEBaiEBIAJBAWsiAg0ACwsgAAspAQF/IAIEQCAAIQMDQCADIAE6AAAgA0EBaiEDIAJBAWsiAg0ACwsgAAtsAQJ/QYAfKAIAIgEgAEEHakF4cSICaiEAAkAgAkEAIAAgAU0bDQAgAD8AQRB0SwRAIAA/AEEQdGtB//8DakEQdkAAQX9GBH9BAAVBABAAQQELRQ0BC0GAHyAANgIAIAEPC0GEH0EwNgIAQX8LuScBC38jAEEQayIKJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIABB9AFNBEBBiB8oAgAiBkEQIABBC2pBeHEgAEELSRsiBUEDdiIAdiIBQQNxBEACQCABQX9zQQFxIABqIgJBA3QiAUGwH2oiACABQbgfaigCACIBKAIIIgRGBEBBiB8gBkF+IAJ3cTYCAAwBCyAEIAA2AgwgACAENgIICyABQQhqIQAgASACQQN0IgJBA3I2AgQgASACaiIBIAEoAgRBAXI2AgQMDwsgBUGQHygCACIHTQ0BIAEEQAJAQQIgAHQiAkEAIAJrciABIAB0cWgiAUEDdCIAQbAfaiICIABBuB9qKAIAIgAoAggiBEYEQEGIHyAGQX4gAXdxIgY2AgAMAQsgBCACNgIMIAIgBDYCCAsgACAFQQNyNgIEIAAgBWoiCCABQQN0IgEgBWsiBEEBcjYCBCAAIAFqIAQ2AgAgBwRAIAdBeHFBsB9qIQFBnB8oAgAhAgJ/IAZBASAHQQN2dCIDcUUEQEGIHyADIAZyNgIAIAEMAQsgASgCCAshAyABIAI2AgggAyACNgIMIAIgATYCDCACIAM2AggLIABBCGohAEGcHyAINgIAQZAfIAQ2AgAMDwtBjB8oAgAiC0UNASALaEECdEG4IWooAgAiAigCBEF4cSAFayEDIAIhAQNAAkAgASgCECIARQRAIAEoAhQiAEUNAQsgACgCBEF4cSAFayIBIAMgASADSSIBGyEDIAAgAiABGyECIAAhAQwBCwsgAigCGCEJIAIgAigCDCIERwRAQZgfKAIAGiACKAIIIgAgBDYCDCAEIAA2AggMDgsgAkEUaiIBKAIAIgBFBEAgAigCECIARQ0DIAJBEGohAQsDQCABIQggACIEQRRqIgEoAgAiAA0AIARBEGohASAEKAIQIgANAAsgCEEANgIADA0LQX8hBSAAQb9/Sw0AIABBC2oiAEF4cSEFQYwfKAIAIghFDQBBACAFayEDAkACQAJAAn9BACAFQYACSQ0AGkEfIAVB////B0sNABogBUEmIABBCHZnIgBrdkEBcSAAQQF0a0E+agsiB0ECdEG4IWooAgAiAUUEQEEAIQAMAQtBACEAIAVBGSAHQQF2a0EAIAdBH0cbdCECA0ACQCABKAIEQXhxIAVrIgYgA08NACABIQQgBiIDDQBBACEDIAEhAAwDCyAAIAEoAhQiBiAGIAEgAkEddkEEcWooAhAiAUYbIAAgBhshACACQQF0IQIgAQ0ACwsgACAEckUEQEEAIQRBAiAHdCIAQQAgAGtyIAhxIgBFDQMgAGhBAnRBuCFqKAIAIQALIABFDQELA0AgACgCBEF4cSAFayICIANJIQEgAiADIAEbIQMgACAEIAEbIQQgACgCECIBBH8gAQUgACgCFAsiAA0ACwsgBEUNACADQZAfKAIAIAVrTw0AIAQoAhghByAEIAQoAgwiAkcEQEGYHygCABogBCgCCCIAIAI2AgwgAiAANgIIDAwLIARBFGoiASgCACIARQRAIAQoAhAiAEUNAyAEQRBqIQELA0AgASEGIAAiAkEUaiIBKAIAIgANACACQRBqIQEgAigCECIADQALIAZBADYCAAwLCyAFQZAfKAIAIgRNBEBBnB8oAgAhAAJAIAQgBWsiAUEQTwRAIAAgBWoiAiABQQFyNgIEIAAgBGogATYCACAAIAVBA3I2AgQMAQsgACAEQQNyNgIEIAAgBGoiASABKAIEQQFyNgIEQQAhAkEAIQELQZAfIAE2AgBBnB8gAjYCACAAQQhqIQAMDQsgBUGUHygCACICSQRAQZQfIAIgBWsiATYCAEGgH0GgHygCACIAIAVqIgI2AgAgAiABQQFyNgIEIAAgBUEDcjYCBCAAQQhqIQAMDQtBACEAIAVBL2oiAwJ/QeAiKAIABEBB6CIoAgAMAQtB7CJCfzcCAEHkIkKAoICAgIAENwIAQeAiIApBDGpBcHFB2KrVqgVzNgIAQfQiQQA2AgBBxCJBADYCAEGAIAsiAWoiBkEAIAFrIghxIgEgBU0NDEHAIigCACIEBEBBuCIoAgAiByABaiIJIAdNIAQgCUlyDQ0LAkBBxCItAABBBHFFBEACQAJAAkACQEGgHygCACIEBEBByCIhAANAIAQgACgCACIHTwRAIAcgACgCBGogBEsNAwsgACgCCCIADQALC0EAEAQiAkF/Rg0DIAEhBkHkIigCACIAQQFrIgQgAnEEQCABIAJrIAIgBGpBACAAa3FqIQYLIAUgBk8NA0HAIigCACIABEBBuCIoAgAiBCAGaiIIIARNIAAgCElyDQQLIAYQBCIAIAJHDQEMBQsgBiACayAIcSIGEAQiAiAAKAIAIAAoAgRqRg0BIAIhAAsgAEF/Rg0BIAVBMGogBk0EQCAAIQIMBAtB6CIoAgAiAiADIAZrakEAIAJrcSICEARBf0YNASACIAZqIQYgACECDAMLIAJBf0cNAgtBxCJBxCIoAgBBBHI2AgALIAEQBCICQX9GQQAQBCIAQX9GciAAIAJNcg0FIAAgAmsiBiAFQShqTQ0FC0G4IkG4IigCACAGaiIANgIAQbwiKAIAIABJBEBBvCIgADYCAAsCQEGgHygCACIDBEBByCIhAANAIAIgACgCACIBIAAoAgQiBGpGDQIgACgCCCIADQALDAQLQZgfKAIAIgBBACAAIAJNG0UEQEGYHyACNgIAC0EAIQBBzCIgBjYCAEHIIiACNgIAQagfQX82AgBBrB9B4CIoAgA2AgBB1CJBADYCAANAIABBA3QiAUG4H2ogAUGwH2oiBDYCACABQbwfaiAENgIAIABBAWoiAEEgRw0AC0GUHyAGQShrIgBBeCACa0EHcSIBayIENgIAQaAfIAEgAmoiATYCACABIARBAXI2AgQgACACakEoNgIEQaQfQfAiKAIANgIADAQLIAIgA00gASADS3INAiAAKAIMQQhxDQIgACAEIAZqNgIEQaAfIANBeCADa0EHcSIAaiIBNgIAQZQfQZQfKAIAIAZqIgIgAGsiADYCACABIABBAXI2AgQgAiADakEoNgIEQaQfQfAiKAIANgIADAMLQQAhBAwKC0EAIQIMCAtBmB8oAgAgAksEQEGYHyACNgIACyACIAZqIQFByCIhAAJAAkACQANAIAEgACgCAEcEQCAAKAIIIgANAQwCCwsgAC0ADEEIcUUNAQtByCIhAANAIAMgACgCACIBTwRAIAEgACgCBGoiBCADSw0DCyAAKAIIIQAMAAsACyAAIAI2AgAgACAAKAIEIAZqNgIEIAJBeCACa0EHcWoiByAFQQNyNgIEIAFBeCABa0EHcWoiBiAFIAdqIgVrIQAgAyAGRgRAQaAfIAU2AgBBlB9BlB8oAgAgAGoiADYCACAFIABBAXI2AgQMCAtBnB8oAgAgBkYEQEGcHyAFNgIAQZAfQZAfKAIAIABqIgA2AgAgBSAAQQFyNgIEIAAgBWogADYCAAwICyAGKAIEIgNBA3FBAUcNBiADQXhxIQkgA0H/AU0EQCAGKAIMIgEgBigCCCICRgRAQYgfQYgfKAIAQX4gA0EDdndxNgIADAcLIAIgATYCDCABIAI2AggMBgsgBigCGCEIIAYgBigCDCICRwRAIAYoAggiASACNgIMIAIgATYCCAwFCyAGQRRqIgEoAgAiA0UEQCAGKAIQIgNFDQQgBkEQaiEBCwNAIAEhBCADIgJBFGoiASgCACIDDQAgAkEQaiEBIAIoAhAiAw0ACyAEQQA2AgAMBAtBlB8gBkEoayIAQXggAmtBB3EiAWsiCDYCAEGgHyABIAJqIgE2AgAgASAIQQFyNgIEIAAgAmpBKDYCBEGkH0HwIigCADYCACADIARBJyAEa0EHcWpBL2siACAAIANBEGpJGyIBQRs2AgQgAUHQIikCADcCECABQcgiKQIANwIIQdAiIAFBCGo2AgBBzCIgBjYCAEHIIiACNgIAQdQiQQA2AgAgAUEYaiEAA0AgAEEHNgIEIABBCGogAEEEaiEAIARJDQALIAEgA0YNACABIAEoAgRBfnE2AgQgAyABIANrIgJBAXI2AgQgASACNgIAIAJB/wFNBEAgAkF4cUGwH2ohAAJ/QYgfKAIAIgFBASACQQN2dCICcUUEQEGIHyABIAJyNgIAIAAMAQsgACgCCAshASAAIAM2AgggASADNgIMIAMgADYCDCADIAE2AggMAQtBHyEAIAJB////B00EQCACQSYgAkEIdmciAGt2QQFxIABBAXRrQT5qIQALIAMgADYCHCADQgA3AhAgAEECdEG4IWohAQJAAkBBjB8oAgAiBEEBIAB0IgZxRQRAQYwfIAQgBnI2AgAgASADNgIADAELIAJBGSAAQQF2a0EAIABBH0cbdCEAIAEoAgAhBANAIAQiASgCBEF4cSACRg0CIABBHXYhBCAAQQF0IQAgASAEQQRxaiIGKAIQIgQNAAsgBiADNgIQCyADIAE2AhggAyADNgIMIAMgAzYCCAwBCyABKAIIIgAgAzYCDCABIAM2AgggA0EANgIYIAMgATYCDCADIAA2AggLQZQfKAIAIgAgBU0NAEGUHyAAIAVrIgE2AgBBoB9BoB8oAgAiACAFaiICNgIAIAIgAUEBcjYCBCAAIAVBA3I2AgQgAEEIaiEADAgLQYQfQTA2AgBBACEADAcLQQAhAgsgCEUNAAJAIAYoAhwiAUECdEG4IWoiBCgCACAGRgRAIAQgAjYCACACDQFBjB9BjB8oAgBBfiABd3E2AgAMAgsgCEEQQRQgCCgCECAGRhtqIAI2AgAgAkUNAQsgAiAINgIYIAYoAhAiAQRAIAIgATYCECABIAI2AhgLIAYoAhQiAUUNACACIAE2AhQgASACNgIYCyAAIAlqIQAgBiAJaiIGKAIEIQMLIAYgA0F+cTYCBCAFIABBAXI2AgQgACAFaiAANgIAIABB/wFNBEAgAEF4cUGwH2ohAQJ/QYgfKAIAIgJBASAAQQN2dCIAcUUEQEGIHyAAIAJyNgIAIAEMAQsgASgCCAshACABIAU2AgggACAFNgIMIAUgATYCDCAFIAA2AggMAQtBHyEDIABB////B00EQCAAQSYgAEEIdmciAWt2QQFxIAFBAXRrQT5qIQMLIAUgAzYCHCAFQgA3AhAgA0ECdEG4IWohAQJAAkBBjB8oAgAiAkEBIAN0IgRxRQRAQYwfIAIgBHI2AgAgASAFNgIADAELIABBGSADQQF2a0EAIANBH0cbdCEDIAEoAgAhAgNAIAIiASgCBEF4cSAARg0CIANBHXYhAiADQQF0IQMgASACQQRxaiIEKAIQIgINAAsgBCAFNgIQCyAFIAE2AhggBSAFNgIMIAUgBTYCCAwBCyABKAIIIgAgBTYCDCABIAU2AgggBUEANgIYIAUgATYCDCAFIAA2AggLIAdBCGohAAwCCwJAIAdFDQACQCAEKAIcIgBBAnRBuCFqIgEoAgAgBEYEQCABIAI2AgAgAg0BQYwfIAhBfiAAd3EiCDYCAAwCCyAHQRBBFCAHKAIQIARGG2ogAjYCACACRQ0BCyACIAc2AhggBCgCECIABEAgAiAANgIQIAAgAjYCGAsgBCgCFCIARQ0AIAIgADYCFCAAIAI2AhgLAkAgA0EPTQRAIAQgAyAFaiIAQQNyNgIEIAAgBGoiACAAKAIEQQFyNgIEDAELIAQgBUEDcjYCBCAEIAVqIgIgA0EBcjYCBCACIANqIAM2AgAgA0H/AU0EQCADQXhxQbAfaiEAAn9BiB8oAgAiAUEBIANBA3Z0IgNxRQRAQYgfIAEgA3I2AgAgAAwBCyAAKAIICyEBIAAgAjYCCCABIAI2AgwgAiAANgIMIAIgATYCCAwBC0EfIQAgA0H///8HTQRAIANBJiADQQh2ZyIAa3ZBAXEgAEEBdGtBPmohAAsgAiAANgIcIAJCADcCECAAQQJ0QbghaiEBAkACQCAIQQEgAHQiBnFFBEBBjB8gBiAIcjYCACABIAI2AgAMAQsgA0EZIABBAXZrQQAgAEEfRxt0IQAgASgCACEFA0AgBSIBKAIEQXhxIANGDQIgAEEddiEGIABBAXQhACABIAZBBHFqIgYoAhAiBQ0ACyAGIAI2AhALIAIgATYCGCACIAI2AgwgAiACNgIIDAELIAEoAggiACACNgIMIAEgAjYCCCACQQA2AhggAiABNgIMIAIgADYCCAsgBEEIaiEADAELAkAgCUUNAAJAIAIoAhwiAEECdEG4IWoiASgCACACRgRAIAEgBDYCACAEDQFBjB8gC0F+IAB3cTYCAAwCCyAJQRBBFCAJKAIQIAJGG2ogBDYCACAERQ0BCyAEIAk2AhggAigCECIABEAgBCAANgIQIAAgBDYCGAsgAigCFCIARQ0AIAQgADYCFCAAIAQ2AhgLAkAgA0EPTQRAIAIgAyAFaiIAQQNyNgIEIAAgAmoiACAAKAIEQQFyNgIEDAELIAIgBUEDcjYCBCACIAVqIgQgA0EBcjYCBCADIARqIAM2AgAgBwRAIAdBeHFBsB9qIQBBnB8oAgAhAQJ/QQEgB0EDdnQiBSAGcUUEQEGIHyAFIAZyNgIAIAAMAQsgACgCCAshBiAAIAE2AgggBiABNgIMIAEgADYCDCABIAY2AggLQZwfIAQ2AgBBkB8gAzYCAAsgAkEIaiEACyAKQRBqJAAgAAvSCwEHfwJAIABFDQAgAEEIayICIABBBGsoAgAiAUF4cSIAaiEFAkAgAUEBcQ0AIAFBA3FFDQEgAiACKAIAIgFrIgJBmB8oAgBJDQEgACABaiEAAkACQEGcHygCACACRwRAIAFB/wFNBEAgAUEDdiEEIAIoAgwiASACKAIIIgNGBEBBiB9BiB8oAgBBfiAEd3E2AgAMBQsgAyABNgIMIAEgAzYCCAwECyACKAIYIQYgAiACKAIMIgFHBEAgAigCCCIDIAE2AgwgASADNgIIDAMLIAJBFGoiBCgCACIDRQRAIAIoAhAiA0UNAiACQRBqIQQLA0AgBCEHIAMiAUEUaiIEKAIAIgMNACABQRBqIQQgASgCECIDDQALIAdBADYCAAwCCyAFKAIEIgFBA3FBA0cNAkGQHyAANgIAIAUgAUF+cTYCBCACIABBAXI2AgQgBSAANgIADwtBACEBCyAGRQ0AAkAgAigCHCIDQQJ0QbghaiIEKAIAIAJGBEAgBCABNgIAIAENAUGMH0GMHygCAEF+IAN3cTYCAAwCCyAGQRBBFCAGKAIQIAJGG2ogATYCACABRQ0BCyABIAY2AhggAigCECIDBEAgASADNgIQIAMgATYCGAsgAigCFCIDRQ0AIAEgAzYCFCADIAE2AhgLIAIgBU8NACAFKAIEIgFBAXFFDQACQAJAAkACQCABQQJxRQRAQaAfKAIAIAVGBEBBoB8gAjYCAEGUH0GUHygCACAAaiIANgIAIAIgAEEBcjYCBCACQZwfKAIARw0GQZAfQQA2AgBBnB9BADYCAA8LQZwfKAIAIAVGBEBBnB8gAjYCAEGQH0GQHygCACAAaiIANgIAIAIgAEEBcjYCBCAAIAJqIAA2AgAPCyABQXhxIABqIQAgAUH/AU0EQCABQQN2IQQgBSgCDCIBIAUoAggiA0YEQEGIH0GIHygCAEF+IAR3cTYCAAwFCyADIAE2AgwgASADNgIIDAQLIAUoAhghBiAFIAUoAgwiAUcEQEGYHygCABogBSgCCCIDIAE2AgwgASADNgIIDAMLIAVBFGoiBCgCACIDRQRAIAUoAhAiA0UNAiAFQRBqIQQLA0AgBCEHIAMiAUEUaiIEKAIAIgMNACABQRBqIQQgASgCECIDDQALIAdBADYCAAwCCyAFIAFBfnE2AgQgAiAAQQFyNgIEIAAgAmogADYCAAwDC0EAIQELIAZFDQACQCAFKAIcIgNBAnRBuCFqIgQoAgAgBUYEQCAEIAE2AgAgAQ0BQYwfQYwfKAIAQX4gA3dxNgIADAILIAZBEEEUIAYoAhAgBUYbaiABNgIAIAFFDQELIAEgBjYCGCAFKAIQIgMEQCABIAM2AhAgAyABNgIYCyAFKAIUIgNFDQAgASADNgIUIAMgATYCGAsgAiAAQQFyNgIEIAAgAmogADYCACACQZwfKAIARw0AQZAfIAA2AgAPCyAAQf8BTQRAIABBeHFBsB9qIQECf0GIHygCACIDQQEgAEEDdnQiAHFFBEBBiB8gACADcjYCACABDAELIAEoAggLIQAgASACNgIIIAAgAjYCDCACIAE2AgwgAiAANgIIDwtBHyEDIABB////B00EQCAAQSYgAEEIdmciAWt2QQFxIAFBAXRrQT5qIQMLIAIgAzYCHCACQgA3AhAgA0ECdEG4IWohAQJAAkACQEGMHygCACIEQQEgA3QiB3FFBEBBjB8gBCAHcjYCACABIAI2AgAgAiABNgIYDAELIABBGSADQQF2a0EAIANBH0cbdCEDIAEoAgAhAQNAIAEiBCgCBEF4cSAARg0CIANBHXYhASADQQF0IQMgBCABQQRxaiIHQRBqKAIAIgENAAsgByACNgIQIAIgBDYCGAsgAiACNgIMIAIgAjYCCAwBCyAEKAIIIgAgAjYCDCAEIAI2AgggAkEANgIYIAIgBDYCDCACIAA2AggLQagfQagfKAIAQQFrIgBBfyAAGzYCAAsLBAAjAAsGACAAJAALEAAjACAAa0FwcSIAJAAgAAtKAQF/IAAgAUkEQCAAIAEgAhACDwsgAgRAIAAgAmohAyABIAJqIQEDQCADQQFrIgMgAUEBayIBLQAAOgAAIAJBAWsiAg0ACwsgAAv9DgIRfwF+IwBBMGsiByQAQbh/IQgCQCAFRQ0AIAQsAAAiCUH/AXEhCwJAIAlBAEgEQCALQf4Aa0EBdiIGIAVPDQJBbCEIIAtB/wBrIgtB/wFLDQIgBEEBaiEIQQAhBQNAIAUgC08EQCALIQggBiELDAMFIAAgBWogCCAFQQF2aiIELQAAQQR2OgAAIAAgBUEBcmogBC0AAEEPcToAACAFQQJqIQUMAQsACwALIAUgC00NASAHQf8BNgIEIAYgB0EEaiAHQQhqIARBAWoiDiALEAwiBEGIf0sEQCAEIQgMAgtBVCEIIAcoAggiEEEGSw0BIAcoAgQiEUEBdCIJQQJqrUIBIBCthiIYQQEgEHQiDUEBaiIFrUIChnx8Qgt8Qvz//////////wCDQuQCVg0BQVIhCCARQf8BSw0BIA1Bf3NBAnRB5AJqrSARQQFqIhVBAXStIBh8Qgh8VA0BIAsgBGshFiAEIA5qIRcgBkGABGoiEiAFQQJ0aiIRIAlqQQJqIQ4gBkGEBGohE0GAgAIgEHRBEHYhCUEAIQVBASEPIA1BAWsiFCEKA0AgBSAVRkUEQAJAIAYgBUEBdCIIai8BACIEQf//A0YEQCATIApBAnRqIAU6AAIgCkEBayEKQQEhBAwBCyAPQQAgCSAEwUobIQ8LIAggEWogBDsBACAFQQFqIQUMAQsLIAYgDzsBggQgBiAQOwGABAJAIAogFEYEQCANQQN2IQhCACEYQQAhDwNAIAwgFUYEQCAIIA1BAXZqQQNqIglBAXQhCEEAIQRBACEKA0BBACEFIAogDU8NBANAIAVBAkZFBEAgEyAFIAlsIARqIBRxQQJ0aiAOIAUgCmpqLQAAOgACIAVBAWohBQwBCwsgCkECaiEKIAQgCGogFHEhBAwACwAFIAYgDEEBdGouAQAhCSAOIA9qIgQgGDcAAEEIIQUDQCAFIAlORQRAIAQgBWogGDcAACAFQQhqIQUMAQsLIBhCgYKEiJCgwIABfCEYIAxBAWohDCAJIA9qIQ8MAQsACwALIA1BA3YgDUEBdmpBA2ohCEEAIQUDQCAMIBVGRQRAQQAhCSAGIAxBAXRqLgEAIgRBACAEQQBKGyEEA0AgBCAJRkUEQCATIAVBAnRqIAw6AAIDQCAFIAhqIBRxIgUgCksNAAsgCUEBaiEJDAELCyAMQQFqIQwMAQsLQX8hCCAFDQILIBBBAWohCEEAIQUDQCAFIA1GRQRAIBEgEyAFQQJ0aiIOLQACQQF0aiIEIAQvAQAiCUEBajsBACAOIAggCWdBYHNqIgQ6AAMgDiAJIAR0IA1rOwEAIAVBAWohBQwBCwsCQAJAIAYvAYIEBEAgB0EcaiIEIBcgFhANIghBiH9LDQIgB0EUaiAEIBIQDiAHQQxqIAQgEhAOQQAhBQNAIAdBHGoiBBAPIAVB+wFLcg0CIAAgBWoiBiAHQRRqIAQQEDoAACAGIAdBDGogBBAQOgABIAVBAnIhBCAHQRxqEA8EQCAEIQUMAwUgACAEaiAHQRRqIAdBHGoiBBAQOgAAIAYgB0EMaiAEEBA6AAMgBUEEaiEFDAELAAsACyAHQRxqIgQgFyAWEA0iCEGIf0sNASAHQRRqIAQgEhAOIAdBDGogBCASEA5BACEFA0AgB0EcaiIEEA8gBUH7AUtyRQRAIAAgBWoiBiAHQRRqIAQQEToAACAGIAdBDGogBBAROgABIAVBAnIhBCAHQRxqEA8EQCAEIQUFIAAgBGogB0EUaiAHQRxqIgQQEToAACAGIAdBDGogBBAROgADIAVBBGohBQwCCwsLAn8DQEG6fyEIIAVB/QFLDQMgACAFaiIGIAdBFGogB0EcaiIJEBE6AAAgBkEBaiEEIAkQD0EDRgRAIAdBDGohCEECDAILIAVB/AFLDQMgBiAHQQxqIAdBHGoiBBAROgABIAVBAmohBSAEEA9BA0cNAAsgACAFaiEEIAdBFGohCEEDCyAEIAggB0EcahAROgAAIAZqIABrIQgMAQsCfwNAQbp/IQggBUH9AUsNAiAAIAVqIgYgB0EUaiAHQRxqIgkQEDoAACAGQQFqIQQgCRAPQQNGBEAgB0EMaiEIQQIMAgsgBUH8AUsNAiAGIAdBDGogB0EcaiIEEBA6AAEgBUECaiEFIAQQD0EDRw0ACyAAIAVqIQQgB0EUaiEIQQMLIAQgCCAHQRxqEBA6AAAgBmogAGshCAsgCEGIf0sNAQsgCCEEQQAhBSABQQBBNBADIQlBACEKA0AgBCAFRwRAIAAgBWoiBi0AACIBQQtLBEBBbCEIDAMFIAkgAUECdGoiASABKAIAQQFqNgIAIAVBAWohBUEBIAYtAAB0QQF1IApqIQoMAgsACwtBbCEIIApFDQAgCmciBUEfcyIBQQtLDQAgA0EgIAVrNgIAQQFBAiABdCAKayIDZ0EfcyIBdCADRw0AIAAgBGogAUEBaiIAOgAAIAkgAEECdGoiACAAKAIAQQFqNgIAIAkoAgQiAEECSSAAQQFxcg0AIAIgBEEBajYCACALQQFqIQgLIAdBMGokACAIC6AFAQx/IwBBEGsiDCQAAn8gBEEHTQRAIAxCADcDCCAMQQhqIgUgAyAEEAIaQWwgACABIAIgBUEIEAwiACAAIARLGyAAIABBiX9JGwwBCyAAQQAgASgCAEEBaiINQQF0EAMhD0FUIAMoAAAiBkEPcSIAQQpLDQAaIAIgAEEFajYCACADIARqIgJBBGshByACQQdrIQsgAEEGaiEOQQQhAiAGQQR2IQVBICAAdCIIQQFyIQlBACEAQQEhBiADIQQDQAJAIAZBAXFFBEADQCAFQX9zQYCAgIB4cmgiBkEYSUUEQCAAQSRqIQAgBCALTQR/IARBA2oFIAQgC2tBA3QgAmpBH3EhAiAHCyIEKAAAIAJ2IQUMAQsLIAIgBkEecSIKakECaiECIAZBAXZBA2wgAGogBSAKdkEDcWoiACANTw0BAn8gBCALSyACQQN2IARqIgUgB0txRQRAIAJBB3EhAiAFDAELIAQgB2tBA3QgAmpBH3EhAiAHCyIEKAAAIAJ2IQULIAUgCEEBa3EiBiAIQQF0QQFrIgogCWsiEEkEfyAOQQFrBSAFIApxIgUgEEEAIAUgCE4bayEGIA4LIQUgDyAAQQF0aiAGQQFrIgo7AQAgAEEBaiEAIAIgBWohAiAIQQEgBmsgCiAGQQBKGyAJaiIJSgRAIAlBAkgNAUEgIAlnIgVrIQ5BASAFQR9zdCEICyAAIA1PDQAgCkEARyEGAn8gBCALSyACQQN1IARqIgUgB0txRQRAIAJBB3EhAiAFDAELIAIgBCAHa0EDdGpBH3EhAiAHCyIEKAAAIAJ2IQUMAQsLQWwgCUEBRw0AGkFQIAAgDUsNABpBbCACQSBKDQAaIAEgAEEBazYCACAEIAJBB2pBA3VqIANrCyAMQRBqJAAL8gEBAX8gAkUEQCAAQgA3AgAgAEEANgIQIABCADcCCEG4fw8LIAAgATYCDCAAIAFBBGo2AhAgAkEETwRAIAAgASACaiIBQQRrIgM2AgggACADKAAANgIAIAFBAWstAAAiAQRAIAAgAWdBF2s2AgQgAg8LIABBADYCBEF/DwsgACABNgIIIAAgAS0AACIDNgIAAkACQAJAIAJBAmsOAgEAAgsgACABLQACQRB0IANyIgM2AgALIAAgAS0AAUEIdCADajYCAAsgASACakEBay0AACIBRQRAIABBADYCBEFsDwsgACABZyACQQN0a0EJajYCBCACC0QBAn8gASACLwEAIgMgASgCBGoiBDYCBCAAIANBAnRBoB1qKAIAIAEoAgBBACAEa3ZxNgIAIAEQDxogACACQQRqNgIEC58BAQR/QQMhASAAKAIEIgJBIE0EQCAAKAIIIgEgACgCEE8EQCAAIAJBB3E2AgQgACABIAJBA3ZrIgI2AgggACACKAAANgIAQQAPCyAAKAIMIgMgAUYEQEEBQQIgAkEgSRsPCyAAIAEgASADayACQQN2IgQgASAEayADSSIBGyIDayIENgIIIAAgAiADQQN0azYCBCAAIAQoAAA2AgALIAELSAEEfyAAKAIEIAAoAgBBAnRqIgItAAIgAi8BACEEIAEgASgCBCIFIAItAAMiAmo2AgQgACAEIAEoAgAgBXRBACACa3ZqNgIAC1IBBH8gACgCBCAAKAIAQQJ0aiICLQACIAIvAQAhBCABIAItAAMiAiABKAIEaiIFNgIEIAAgBCACQQJ0QaAdaigCACABKAIAQQAgBWt2cWo2AgALCAAgAEGIf0sLGgAgAARAIAEEQCACIAAgARECAA8LIAAQBgsLpggCDX8BfiMAQRBrIgkkACAJQQA2AgwgCUEANgIIAn8CQCADQegJaiADIAlBCGogCUEMaiABIAIgA0GAAWoQCyIPQYh/Sw0AQVQgCSgCDCIEIAAoAgAiAUH/AXFBAWpLDQEaIABBBGohCyAAIAFB/4GAeHEgBEEQdEGAgPwHcXI2AgBBfyAEIARBAEgbQQFqIQBBACEBIAkoAgghBUEAIQIDQCAAIAJGBEAgBUEDayEBQQAhAANAAkBBACECIAAgAU4EQANAIAAgBU4NAiADIAAgA2pB6AlqLQAAQQJ0akFAayIBIAEoAgAiAUEBajYCACABIANqIAA6AOgHIABBAWohAAwACwAFA0AgAkEERkUEQCADIAMgACACaiIHakHoCWotAABBAnRqQUBrIgggCCgCACIIQQFqNgIAIAMgCGogBzoA6AcgAkEBaiECDAELCyAAQQRqIQAMAgsACwsgBEEBaiEOIAMoAgAhB0EAIQBBASEIA0AgCCAORg0DIA4gCGshBCADIAhBAnRqKAIAIQUCQAJAAkACQAJAAkBBASAIdEEBdSINQQFrDggAAQQCBAQEAwQLQQAhAiAFQQAgBUEAShshBiAAIQEDQCACIAZGDQUgAyACIAdqai0A6AchCiALIAFBAXRqIgwgBDoAASAMIAo6AAAgAkEBaiECIAFBAWohAQwACwALQQAhAiAFQQAgBUEAShshCiAAIQEDQCACIApGDQQgCyABQQF0aiIGIAMgAiAHamotAOgHIgw6AAIgBiAEOgABIAYgDDoAACAGIAQ6AAMgAkEBaiECIAFBAmohAQwACwALQQAhAiAFQQAgBUEAShshBiAEQQh0QYD+A3EhBCAAIQEDQCACIAZGDQMgCyABQQF0aiAEIAMgAiAHamotAOgHcq1CgYCEgJCAwAB+NwAAIAJBAWohAiABQQRqIQEMAAsAC0EAIQIgBUEAIAVBAEobIQYgBEEIdEGA/gNxIQQgACEBA0AgAiAGRg0CIAsgAUEBdGoiCiAEIAMgAiAHamotAOgHcq1CgYCEgJCAwAB+IhE3AAggCiARNwAAIAJBAWohAiABQQhqIQEMAAsAC0EAIQEgBUEAIAVBAEobIQogBEEIdEGA/gNxIQwgACEEA0AgASAKRg0BIAsgBEEBdGohECAMIAMgASAHamotAOgHcq1CgYCEgJCAwAB+IRFBACECA0AgAiANTkUEQCAQIAJBAXRqIgYgETcAGCAGIBE3ABAgBiARNwAIIAYgETcAACACQRBqIQIMAQsLIAFBAWohASAEIA1qIQQMAAsACyAIQQFqIQggBSAHaiEHIAUgDWwgAGohAAwACwAFIAMgAkECdGoiB0FAayABNgIAIAJBAWohAiAHKAIAIAFqIQEMAQsACwALIA8LIAlBEGokAAvyAgEGfyMAQSBrIgUkACAEKAIAIQYgBUEMaiACIAMQDSIDQYh/TQRAIARBBGohAiAAIAFqIglBA2shBEEAIAZBEHZrQR9xIQMDQCAFQQxqEA8gACAET3JFBEAgAiAFKAIMIgYgBSgCECIHdCADdkEBdGoiCC0AASEKIAAgCC0AADoAACACIAYgByAKaiIGdCADdkEBdGoiBy0AACEIIAUgBiAHLQABajYCECAAIAg6AAEgAEECaiEADAELCwNAIAVBDGoQDyEHIAUoAgwhBiAFKAIQIQQgACAJTyAHckUEQCACIAYgBHQgA3ZBAXRqIgYtAAAhByAFIAQgBi0AAWo2AhAgACAHOgAAIABBAWohAAwBCwsDQCAAIAlPRQRAIAIgBiAEdCADdkEBdGoiBy0AASEIIAAgBy0AADoAACAAQQFqIQAgBCAIaiEEDAELC0FsQWwgASAFKAIUIAUoAhhHGyAEQSBHGyEDCyAFQSBqJAAgAwvPFAEjfyMAQdAAayIFJABBbCEJAkAgA0EKSQ0AAkAgAyACLwAEIgcgAi8AACIIIAIvAAIiDWpqQQZqIgxJDQAgBC8BAiEGIAVBPGogAkEGaiICIAgQDSIJQYh/Sw0BIAVBKGogAiAIaiICIA0QDSIJQYh/Sw0BIAVBFGogAiANaiICIAcQDSIJQYh/Sw0BIAUgAiAHaiADIAxrEA0iCUGIf0sNASAEQQRqIQogACABaiIfQQNrISBBACAGa0EfcSELIAUoAgghESAFKAIcIRIgBSgCMCETIAUoAkQhFCAFKAIEIQkgBSgCGCENIAUoAiwhDCAFKAJAIQYgBSgCECEhIAUoAiQhIiAFKAI4ISMgBSgCTCEkIAUoAgAhFSAFKAIUIRYgBSgCKCEXIAUoAjwhGEEBIQ8gACABQQNqQQJ2IgRqIgMgBGoiAiAEaiIZIQQgAiEIIAMhBwNAIA9BAXFFIAQgIE9yRQRAIAAgCiAYIAZ0IAt2QQJ0aiIOLwEAOwAAIA4tAAIhGiAOLQADIRAgByAKIBcgDHQgC3ZBAnRqIg4vAQA7AAAgDi0AAiEbIA4tAAMhDyAIIAogFiANdCALdkECdGoiDi8BADsAACAOLQACIRwgDi0AAyEdIAQgCiAVIAl0IAt2QQJ0aiIOLwEAOwAAIA4tAAIhHiAOLQADIQ4gACAQaiIlIAogGCAGIBpqIgZ0IAt2QQJ0aiIQLwEAOwAAIBAtAAIgEC0AAyEmIAcgD2oiJyAKIBcgDCAbaiIadCALdkECdGoiBy8BADsAACAHLQACIQwgBy0AAyEQIAggHWoiGyAKIBYgDSAcaiIPdCALdkECdGoiCC8BADsAACAILQACIQ0gCC0AAyEcIAQgDmoiHSAKIBUgCSAeaiIOdCALdkECdGoiCS8BADsAACAGaiEAQQMhBwJ/IBQgJEkEQCAAIQZBAwwBCyAAQQdxIQYgFCAAQQN2ayIUKAAAIRhBAAsgCS0AAyEeIAktAAIhCCAMIBpqIQAgEyAjSQR/IAAFIBMgAEEDdmsiEygAACEXQQAhByAAQQdxCyEMIA0gD2ohACAHciEJQQMhDwJ/IBIgIkkEQCAAIQ1BAwwBCyAAQQdxIQ0gEiAAQQN2ayISKAAAIRZBAAsgCCAOaiEAIAlyIBEgIUkEfyAABSARIABBA3ZrIhEoAAAhFUEAIQ8gAEEHcQshCSAlICZqIQAgECAnaiEHIBsgHGohCCAdIB5qIQQgD3JFIQ8MAQsLIAUgDDYCLCAFIAY2AkAgBSANNgIYIAUgCTYCBCAFIBQ2AkQgBSATNgIwIAUgEjYCHCAFIBE2AgggBSAYNgI8IAUgFzYCKCAFIBY2AhQgBSAVNgIAIAIgB0kgACADS3INAEFsIQkgCCAZSw0BIANBA2shCQNAIAVBPGoQD0UgACAJSXEEQCAAIAogBSgCPCINIAUoAkAiDHQgC3ZBAnRqIg4vAQA7AAAgACAOLQADaiIGIAogDSAMIA4tAAJqIgB0IAt2QQJ0aiIMLwEAOwAAIAUgACAMLQACajYCQCAGIAwtAANqIQAMAQUgA0ECayEMA0AgBUE8ahAPIQYgBSgCPCENIAUoAkAhCSAAIAxLIAZyRQRAIAAgCiANIAl0IAt2QQJ0aiIGLwEAOwAAIAUgCSAGLQACajYCQCAAIAYtAANqIQAMAQsLA0AgACAMS0UEQCAAIAogDSAJdCALdkECdGoiBi8BADsAACAAIAYtAANqIQAgCSAGLQACaiEJDAELCwJAIAAgA08NACAAIAogDSAJdCALdiIAQQJ0aiIDLQAAOgAAIAMtAANBAUYEQCAJIAMtAAJqIQkMAQsgCUEfSw0AQSAgCSAKIABBAnRqLQACaiIAIABBIE8bIQkLIAJBA2shDANAIAVBKGoQD0UgByAMSXEEQCAHIAogBSgCKCIGIAUoAiwiAHQgC3ZBAnRqIg0vAQA7AAAgByANLQADaiIDIAogBiAAIA0tAAJqIgB0IAt2QQJ0aiIGLwEAOwAAIAUgACAGLQACajYCLCADIAYtAANqIQcMAQUgAkECayEGA0AgBUEoahAPIQMgBSgCKCEMIAUoAiwhACAGIAdJIANyRQRAIAcgCiAMIAB0IAt2QQJ0aiIDLwEAOwAAIAUgACADLQACajYCLCAHIAMtAANqIQcMAQsLA0AgBiAHSUUEQCAHIAogDCAAdCALdkECdGoiAy8BADsAACAHIAMtAANqIQcgACADLQACaiEADAELCwJAIAIgB00NACAHIAogDCAAdCALdiICQQJ0aiIDLQAAOgAAIAMtAANBAUYEQCAAIAMtAAJqIQAMAQsgAEEfSw0AQSAgACAKIAJBAnRqLQACaiIAIABBIE8bIQALIBlBA2shDANAIAVBFGoQD0UgCCAMSXEEQCAIIAogBSgCFCIGIAUoAhgiAnQgC3ZBAnRqIg0vAQA7AAAgCCANLQADaiIDIAogBiACIA0tAAJqIgJ0IAt2QQJ0aiIGLwEAOwAAIAUgAiAGLQACajYCGCADIAYtAANqIQgMAQUgGUECayEDA0AgBUEUahAPIQIgBSgCFCEGIAUoAhghByADIAhJIAJyRQRAIAggCiAGIAd0IAt2QQJ0aiICLwEAOwAAIAUgByACLQACajYCGCAIIAItAANqIQgMAQsLA0AgAyAISUUEQCAIIAogBiAHdCALdkECdGoiAi8BADsAACAIIAItAANqIQggByACLQACaiEHDAELCwJAIAggGU8NACAIIAogBiAHdCALdiICQQJ0aiIDLQAAOgAAIAMtAANBAUYEQCAHIAMtAAJqIQcMAQsgB0EfSw0AQSAgByAKIAJBAnRqLQACaiICIAJBIE8bIQcLA0AgBRAPRSAEICBJcQRAIAQgCiAFKAIAIgYgBSgCBCICdCALdkECdGoiDC8BADsAACAEIAwtAANqIgMgCiAGIAIgDC0AAmoiAnQgC3ZBAnRqIgQvAQA7AAAgBSACIAQtAAJqNgIEIAMgBC0AA2ohBAwBBSAfQQJrIQMDQCAFEA8hAiAFKAIAIQYgBSgCBCEIIAMgBEkgAnJFBEAgBCAKIAYgCHQgC3ZBAnRqIgIvAQA7AAAgBSAIIAItAAJqNgIEIAQgAi0AA2ohBAwBCwsDQCADIARJRQRAIAQgCiAGIAh0IAt2QQJ0aiICLwEAOwAAIAQgAi0AA2ohBCAIIAItAAJqIQgMAQsLAkAgBCAfTw0AIAQgCiAGIAh0IAt2IgJBAnRqIgMtAAA6AAAgAy0AA0EBRgRAIAggAy0AAmohCAwBCyAIQR9LDQBBICAIIAogAkECdGotAAJqIgIgAkEgTxshCAtBbEFsQWxBbEFsQWxBbEFsIAEgCEEgRxsgBSgCCCAFKAIMRxsgB0EgRxsgBSgCHCAFKAIgRxsgAEEgRxsgBSgCMCAFKAI0RxsgCUEgRxsgBSgCRCAFKAJIRxshCQwJCwALAAsACwALAAsACwALAAtBbCEJCyAFQdAAaiQAIAkL7BABHn8jAEHQAGsiBSQAQWwhCQJAIANBCkkNAAJAIAMgAi8ABCIGIAIvAAAiByACLwACIghqakEGaiIOSQ0AIAQvAQIhDyAFQTxqIAJBBmoiAiAHEA0iCUGIf0sNASAFQShqIAIgB2oiAiAIEA0iCUGIf0sNASAFQRRqIAIgCGoiAiAGEA0iCUGIf0sNASAFIAIgBmogAyAOaxANIglBiH9LDQEgBEEEaiEKIAAgAWoiHEEDayEdQQAgD2tBH3EhCyAFKAIIIREgBSgCHCESIAUoAjAhEyAFKAJEIRQgBSgCBCEJIAUoAhghBiAFKAIsIQcgBSgCQCEIIAUoAhAhHiAFKAIkIR8gBSgCOCEgIAUoAkwhISAFKAIAIRUgBSgCFCEWIAUoAighFyAFKAI8IRhBASENIAAgAUEDakECdiICaiIOIAJqIg8gAmoiGSEEIA8hAiAOIQMDQCANRSAEIB1PckUEQCAKIBggCHQgC3ZBAXRqIgwtAAEhDSAAIAwtAAA6AAAgCiAXIAd0IAt2QQF0aiIMLQABIRAgAyAMLQAAOgAAIAogFiAGdCALdkEBdGoiDC0AASEaIAIgDC0AADoAACAKIBUgCXQgC3ZBAXRqIgwtAAEhGyAEIAwtAAA6AAAgCiAYIAggDWoiCHQgC3ZBAXRqIgwtAAEhDSAAIAwtAAA6AAEgCiAXIAcgEGoiB3QgC3ZBAXRqIgwtAAEhECADIAwtAAA6AAEgCiAWIAYgGmoiDHQgC3ZBAXRqIgYtAAEhGiACIAYtAAA6AAEgCiAVIAkgG2oiG3QgC3ZBAXRqIgktAAEhIiAEIAktAAA6AAEgCCANaiEGQQMhCQJ/IBQgIUkEQEEDIQ0gBgwBCyAUIAZBA3ZrIhQoAAAhGEEAIQ0gBkEHcQshCCAHIBBqIQYgEyAgSQR/IAYFIBMgBkEDdmsiEygAACEXQQAhCSAGQQdxCyEHIAwgGmohDCAJIA1yIRBBAyENAn8gEiAfSQRAIAwhBkEDDAELIAxBB3EhBiASIAxBA3ZrIhIoAAAhFkEACyAbICJqIQwgEHIhECARIB5JBH8gDAUgESAMQQN2ayIRKAAAIRVBACENIAxBB3ELIQkgBEECaiEEIAJBAmohAiADQQJqIQMgAEECaiEAIA0gEHJFIQ0MAQsLIAUgBzYCLCAFIAg2AkAgBSAGNgIYIAUgCTYCBCAFIBQ2AkQgBSATNgIwIAUgEjYCHCAFIBE2AgggBSAYNgI8IAUgFzYCKCAFIBY2AhQgBSAVNgIAIAAgDksgAyAPS3INAEFsIQkgAiAZSw0BIA5BA2shCQNAIAVBPGoQDyAAIAlPckUEQCAKIAUoAjwiBiAFKAJAIgd0IAt2QQF0aiIILQABIQwgACAILQAAOgAAIAogBiAHIAxqIgZ0IAt2QQF0aiIHLQAAIQggBSAGIActAAFqNgJAIAAgCDoAASAAQQJqIQAMAQsLA0AgBUE8ahAPIQcgBSgCPCEGIAUoAkAhCSAAIA5PIAdyRQRAIAogBiAJdCALdkEBdGoiBi0AACEHIAUgCSAGLQABajYCQCAAIAc6AAAgAEEBaiEADAELCwNAIAAgDk9FBEAgCiAGIAl0IAt2QQF0aiIHLQABIAAgBy0AADoAACAAQQFqIQAgCWohCQwBCwsgD0EDayEAA0AgBUEoahAPIAAgA01yRQRAIAogBSgCKCIGIAUoAiwiB3QgC3ZBAXRqIggtAAEhDiADIAgtAAA6AAAgCiAGIAcgDmoiBnQgC3ZBAXRqIgctAAAhCCAFIAYgBy0AAWo2AiwgAyAIOgABIANBAmohAwwBCwsDQCAFQShqEA8hByAFKAIoIQYgBSgCLCEAIAMgD08gB3JFBEAgCiAGIAB0IAt2QQF0aiIGLQAAIQcgBSAAIAYtAAFqNgIsIAMgBzoAACADQQFqIQMMAQsLA0AgAyAPT0UEQCAKIAYgAHQgC3ZBAXRqIgctAAEhCCADIActAAA6AAAgA0EBaiEDIAAgCGohAAwBCwsgGUEDayEDA0AgBUEUahAPIAIgA09yRQRAIAogBSgCFCIGIAUoAhgiB3QgC3ZBAXRqIggtAAEhDiACIAgtAAA6AAAgCiAGIAcgDmoiBnQgC3ZBAXRqIgctAAAhCCAFIAYgBy0AAWo2AhggAiAIOgABIAJBAmohAgwBCwsDQCAFQRRqEA8hByAFKAIUIQYgBSgCGCEDIAIgGU8gB3JFBEAgCiAGIAN0IAt2QQF0aiIGLQAAIQcgBSADIAYtAAFqNgIYIAIgBzoAACACQQFqIQIMAQsLA0AgAiAZT0UEQCAKIAYgA3QgC3ZBAXRqIgctAAEhCCACIActAAA6AAAgAkEBaiECIAMgCGohAwwBCwsDQCAFEA8gBCAdT3JFBEAgCiAFKAIAIgIgBSgCBCIGdCALdkEBdGoiBy0AASEIIAQgBy0AADoAACAKIAIgBiAIaiICdCALdkEBdGoiBi0AACEHIAUgAiAGLQABajYCBCAEIAc6AAEgBEECaiEEDAELCwNAIAUQDyEHIAUoAgAhBiAFKAIEIQIgBCAcTyAHckUEQCAKIAYgAnQgC3ZBAXRqIgYtAAAhByAFIAIgBi0AAWo2AgQgBCAHOgAAIARBAWohBAwBCwsDQCAEIBxPRQRAIAogBiACdCALdkEBdGoiBy0AASEIIAQgBy0AADoAACAEQQFqIQQgAiAIaiECDAELC0FsQWxBbEFsQWxBbEFsQWwgASACQSBHGyAFKAIIIAUoAgxHGyADQSBHGyAFKAIcIAUoAiBHGyAAQSBHGyAFKAIwIAUoAjRHGyAJQSBHGyAFKAJEIAUoAkhHGyEJDAELQWwhCQsgBUHQAGokACAJC1gBA38CQCAAKAKQ6wEiAUUNACABKAIAIAFBtNUBaigCACICIAFBuNUBaigCACIDEBMgAgRAIAMgASACEQIADAELIAEQBgsgAEEANgKg6wEgAEIANwOQ6wEL6QMCBH8CfiAAQQBBKBADIQQgAkEBQQUgAxsiAEkEQCAADwsgAUUEQEF/DwtBASEGAkACQCADQQFGDQAgAyEGIAEoAAAiBUGo6r5pRg0AQXYhAyAFQXBxQdDUtMIBRw0BQQghAyACQQhJDQEgATUABCEIIARBATYCFCAEIAg3AwBBAA8LIAEgAiAGEBoiAyACSw0AIAQgAzYCGEFyIQMgACABaiIFQQFrLQAAIgJBCHENACACQSBxIgZFBEBBcCEDIAUtAAAiBUGnAUsNASAFQQdxrUIBIAVBA3ZBCmqthiIIQgOIfiAIfCEJIABBAWohAAsgAkEGdiEFIAJBAnZBACEDAkACQAJAAkAgAkEDcUEBaw4DAAECAwsgACABai0AACEDIABBAWohAAwCCyAAIAFqLwAAIQMgAEECaiEADAELIAAgAWooAAAhAyAAQQRqIQALQQFxIQICfgJAAkACQAJAIAVBAWsOAwECAwALQn8gBkUNAxogACABajEAAAwDCyAAIAFqMwAAQoACfAwCCyAAIAFqNQAADAELIAAgAWopAAALIQggBCACNgIgIAQgAzYCHCAEIAg3AwBBACEDIARBADYCFCAEIAggCSAGGyIINwMIIARCgIAIIAggCEKAgAhaGz4CEAsgAwtfAQF/Qbh/IQMgAUEBQQUgAhsiAk8EfyAAIAJqQQFrLQAAIgBBA3FBAnRBoB5qKAIAIAJqIABBBHZBDHFBsB5qKAIAaiAAQSBxIgFFaiABQQV2IABBwABJcWoFQbh/CwsMACAAIAEgAkEAEBkLlwMCBX8CfiMAQUBqIgQkAAJAA0AgAUEFTwRAAkAgACgAAEFwcUHQ1LTCAUYEQEJ+IQcgAUEISQ0EIAAoAAQiAkF3Sw0EIAJBCGoiAyABSw0EIAJBgX9JDQEMBAsgBEEYaiAAIAEQGyECQn4gBCkDGEIAIAQoAixBAUcbIAIbIgdCfVYNAyAHIAh8IgggB1RCfiEHDQMCQAJAIAFBCEkNACAAKAAAQXBxQdDUtMIBRw0AIAAoAAQiAkF3Sw0FQbh/IAJBCGoiAiABIAJJGyEDDAELIARBGGogACABEBsiAkGIf0sEQCACIQMMAQtBuH8hAyACDQAgASAEKAIwIgJrIQUgACACaiEGA0AgBiAFIARBDGoQHSIDQYh/Sw0BIANBA2oiAiAFSwRAQbh/IQMMAgsgBSACayEFIAIgBmohBiAEKAIQRQ0ACyAEKAI4BH9BuH8hAyAFQQRJDQEgBkEEagUgBgsgAGshAwsgA0GIf0sNAwsgASADayEBIAAgA2ohAAwBCwtCfiAIIAEbIQcLIARBQGskACAHC2QBAX9BuH8hAwJAIAFBA0kNACAALQACIQEgAiAALwAAIgBBAXE2AgQgAiAAQQF2QQNxIgM2AgAgAiAAIAFBEHRyQQN2IgA2AggCQAJAIANBAWsOAwIBAAELQWwPCyAAIQMLIAMLRAECfyABIAIoAgQiAyABKAIEaiIENgIEIAAgA0ECdEGgHWooAgAgASgCAEEAIARrdnE2AgAgARAPGiAAIAJBCGo2AgQLzgEBBn9Bun8hCgJAIAIoAgQiCCACKAIAIglqIg0gASAAa0sNAEFsIQogCSAEIAMoAgAiC2tLDQAgACAJaiIEIAIoAggiDGshAiAAIAFBIGsiACALIAlBABAgIAMgCSALajYCAAJAAkAgBCAFayAMTwRAIAIhBQwBCyAMIAQgBmtLDQIgByAHIAIgBWsiAmoiASAIak8EQCAEIAEgCBAKGgwCCyACIAhqIQggBCABQQAgAmsQCiACayEECyAEIAAgBSAIQQEQIAsgDSEKCyAKC8cEAQJ/IAAgA2ohBgJAIANBB0wEQANAIAAgBk8NAiAAIAItAAA6AAAgAEEBaiEAIAJBAWohAgwACwALIARBAUYEQAJAIAAgAmsiBUEHTQRAIAAgAi0AADoAACAAIAItAAE6AAEgACACLQACOgACIAAgAi0AAzoAAyAAIAIgBUECdCIFQcAeaigCAGoiAigAADYABCACIAVB4B5qKAIAayECDAELIAAgAikAADcAAAsgAkEIaiECIABBCGohAAsgASAGTwRAIAAgA2ohASAEQQFHIAAgAmtBD0pyRQRAA0AgACACKQAANwAAIAJBCGohAiAAQQhqIgAgAUkNAAwDCwALIAAgAikAADcAACAAIAIpAAg3AAggA0ERSQ0BIABBEGohAANAIAAgAikAEDcAACAAIAIpABg3AAggACACKQAgNwAQIAAgAikAKDcAGCACQSBqIQIgAEEgaiIAIAFJDQALDAELAkAgACABSwRAIAAhAQwBCyABIABrIQUCQCAEQQFHIAAgAmtBD0pyRQRAIAIhAwNAIAAgAykAADcAACADQQhqIQMgAEEIaiIAIAFJDQALDAELIAAgAikAADcAACAAIAIpAAg3AAggBUERSA0AIABBEGohACACIQMDQCAAIAMpABA3AAAgACADKQAYNwAIIAAgAykAIDcAECAAIAMpACg3ABggA0EgaiEDIABBIGoiACABSQ0ACwsgAiAFaiECCwNAIAEgBk8NASABIAItAAA6AAAgAUEBaiEBIAJBAWohAgwACwALC64HAgV/AX4jAEGAAWsiESQAIBEgAzYCfEF/IQ8CQAJAAkACQAJAIAIOBAEAAwIECyAGRQRAQbh/IQ8MBAtBbCEPIAUtAAAiAiADSw0DIAggAkECdCICaigCACEDIAIgB2ooAgAhAiAAQQA6AAsgAEIANwIAIAAgAjYCDCAAIAM6AAogAEEAOwEIIAEgADYCAEEBIQ8MAwsgASAJNgIAQQAhDwwCCyAKRQRAQWwhDwwCC0EAIQ8gC0UgDEEZSHINAUEIIAR0QQhqIQBBACEDA0AgACADTQ0CIANBQGshAwwACwALQWwhDyARIBFB/ABqIBFB+ABqIAUgBhAMIgNBiH9LDQAgESgCeCICIARLDQAgESgCfEEBaiEJIABBCGohC0GAgAIgAnRBEHUhBUEBIRBBASACdCIPQQFrIgohEgNAIAkgDkcEQAJAIBEgDkEBdCIEai8BACIMQf//A0YEQCALIBJBA3RqIA42AgQgEkEBayESQQEhDAwBCyAQQQAgBSAMwUobIRALIAQgDWogDDsBACAOQQFqIQ4MAQsLIAAgAjYCBCAAIBA2AgACQCAKIBJGBEAgDUHqAGohBkEAIRBBACEMA0AgCSAQRgRAIA9BA3YgD0EBdmpBA2oiBUEBdCEEQQAhDEEAIRIDQEEAIQ4gDyASTQ0EA0AgDkECRwRAIAsgBSAObCAMaiAKcUEDdGogBiAOIBJqai0AADYCBCAOQQFqIQ4MAQsLIBJBAmohEiAEIAxqIApxIQwMAAsABSARIBBBAXRqLgEAIQUgBiAMaiIEIBM3AABBCCEOA0AgBSAOSgRAIAQgDmogEzcAACAOQQhqIQ4MAQsLIBNCgYKEiJCgwIABfCETIBBBAWohECAFIAxqIQwMAQsACwALIA9BA3YgD0EBdmpBA2ohBUEAIRBBACEOA0AgCSAQRg0BQQAhDCARIBBBAXRqLgEAIgRBACAEQQBKGyEEA0AgBCAMRwRAIAsgDkEDdGogEDYCBANAIAUgDmogCnEiDiASSw0ACyAMQQFqIQwMAQsLIBBBAWohEAwACwALIAJBAWohBUEAIQwDQCAMIA9HBEAgDSALIAxBA3RqIgkoAgQiBEEBdGoiAiACLwEAIgZBAWo7AQAgCSAFIAZnQWBzaiICOgADIAkgBiACdCAPazsBACAJIAggBEECdCICaigCADoAAiAJIAIgB2ooAgA2AgQgDEEBaiEMDAELCyABIAA2AgAgAyEPCyARQYABaiQAIA8L7VoCO38GfiMAQeABayIEJAACQEGw7AkQBSIFRQRAQUAhBwwBCyAFQgA3AvTqASAFQQA2AsTrASAFQQA2ArTrASAFQgA3ApzrASAFQQA2ArjpASAFQQA2AqzsCSAFQgA3AtTrASAFQgA3AqzrASAFQgA3A4jrASAFQgA3AuTqASAFQgA3AuTrASAFQYGAgMAANgK86wEgBUIANwKk6wEgBUH86gFqQQA2AgAgBUGQ6wFqQgA3AwAgBRAYIAVBrNUBaiEUIAVB+OsBaiEcIAVBsOoBaiEiIAVBoDBqISogBUGYIGohKyAFQajQAGohHiAFQRBqISwgBUEIaiEoIAVBBGohLSAFQcDpAWohKSAFQYjrAWogBEGUAWohLyAEQYwBaiEwIARBhAFqITEgBEHcAGohMiAEQdQAaiEzIARBzABqITQgACEdAkACQAJAAkACQANAQQFBBSAFKALk6gEbIQYCQANAIAMgBkkNASACKAAAQXBxQdDUtMIBRgRAQbh/IQcgA0EISQ0IIAIoAAQiDkF3SwRAQXIhBwwJCyADIA5BCGoiCUkNCCAOQYB/SwRAIAkhBwwJCyADIAlrIQMgAiAJaiECDAELCyAFQgA3AqzpASAFQgA3A+jpASAFQQA2ApjrASAFQgA3A4DqASAFQgM3A/jpASAFQbTpAWpCADcCACAFQfDpAWpCADcDACAFQajQAGoiCUGMgIDgADYCACAFQazQAWpB4BIpAgA3AgAgBUG00AFqQegSKAIANgIAIAUgBUEQajYCACAFIAVBoDBqNgIEIAUgBUGYIGo2AgggBSAJNgIMIAVBAUEFIAUoAuTqARs2ArzpAQJAIAFFDQAgBSgCrOkBIgkgHUYNACAFIAk2ArjpASAFIB02AqzpASAFKAKw6QEhDiAFIB02ArDpASAFIB0gDiAJa2o2ArTpAQtBuH8hCSADQQVBCSAFKALk6gEiBhtJDQUgAkEBQQUgBhsgBhAaIg5BiH9LBEAgDiEJDAULIAMgDkEDakkNBSApIAIgDiAGEBkiBkGIf0sEQCAGIQkMBQsgBg0FAkACQCAFKAKo6wFBAUcNACAFKAKk6wEiCUUNACAFKAKU6wFFDQAgCSgCBEEBayIHIAUoAtzpASIKrUKHla+vmLbem55/fkLJz9my8eW66ieFQheJQs/W077Sx6vZQn5C+fPd8Zn2masWfCI/QiGIID+FQs/W077Sx6vZQn4iP0IdiCA/hUL5893xmfaZqxZ+Ij9CIIggP4WncSEGIAkoAgAhFQNAQQAhCAJAIBUgBkECdGooAgAiCUUNACAJKAIIQQhJDQAgCSgCBCISKAAAQbfIwuF+Rw0AIBIoAAQhCAsgCCAKRwRAIAYgB3FBAWohBiAIDQELCyAJRQ0AIAUQGCAFQX82AqDrASAFIAk2ApTrASAFIAUoAtzpASIINgKY6wEMAQsgBSgC3OkBIQgLAkAgCEUNACAFKAKY6wEgCEYNAEFgIQkMBgsCQCAFKALg6QEEQCAFIAUoAujqASIJRTYC7OoBIAkNASAFQvnq0NDnyaHk4QA3A6jqASAFQgA3A6DqASAFQs/W077Sx6vZQjcDmOoBIAVC1uuC7ur9ifXgADcDkOoBIAVCADcDiOoBICJBAEEoEAMaDAELIAVBADYC7OoBCyABIB1qISUgBSAFKQPo6QEgDq18NwPo6QEgAyAOayEDIAIgDmohAiAdIQ4DQCACIAMgBEEsahAdIhVBiH9LBEAgFSEJDAYLIANBA2siNSAVSQ0EIAJBA2ohG0FsIQkCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAEKAIsDgMCAQAVCyAVQf//B0sNEyAVQQNJDRIgBSkDyOkBIT8CQAJAIBstAAAiCUEDcSIaQQFrDgMGAQAHCyAFKAKA6gENAEFiIQkMFQsgFUEFSQ0SIBsoAAAhAwJ/AkACQAJAIAlBAnZBA3EiCUECaw4CAQIACyAJQQBHIQcgA0EEdkH/B3EhC0EDIQYgA0EOdkH/B3EMAgtBBCEGIANBBHZB//8AcSELQQEhByADQRJ2DAELIANBBHZB//8PcSILQYCACEsNE0EBIQdBBSEGIAItAAdBCnQgA0EWdnILIgggBmoiCSAVSw0SAkAgC0GBBkkNACAFKAKc6wFFDQBBACEDA0AgA0GDgAFLDQEgA0FAayEDDAALAAsgBiAbaiEPIBpBA0cNBiAFKAIMIgItAAFBCHQhAyAHDQcgA0UNCCAEQfAAaiAPIAgQDSIDQYh/Sw0JIAJBBGohBiALIBxqIhJBA2shCkEAIAIvAQJrQR9xIQcgHCEDA0AgBEHwAGoQD0UgAyAKSXEEQCADIAYgBCgCcCIIIAQoAnQiD3QgB3ZBAnRqIgIvAQA7AAAgAyACLQADaiIDIAYgCCAPIAItAAJqIgh0IAd2QQJ0aiICLwEAOwAAIAQgCCACLQACajYCdCADIAItAANqIQMMAQUgEkECayEIA0AgBEHwAGoQDyEPIAQoAnAhCiAEKAJ0IQIgAyAISyAPckUEQCADIAYgCiACdCAHdkECdGoiCi8BADsAACAEIAIgCi0AAmo2AnQgAyAKLQADaiEDDAELCwNAIAMgCE0EQCADIAYgCiACdCAHdkECdGoiDy8BADsAACADIA8tAANqIQMgAiAPLQACaiECDAELCwJAIAMgEk8NACADIAYgCiACdCAHdkECdGoiAy0AADoAACADLQADQQFGBEAgAiADLQACaiECDAELIAJBH0sNAEEgIAIgAy0AAmoiAiACQSBPGyECC0FsQWwgCyAEKAJ4IAQoAnxHGyACQSBHGyEDDAsLAAsACyAEKAI0IgIgJSAOa0sNCiAORQRAQQAhCSACDQIMDgsgDiAbLQAAIAIQAxogAiEJDAwLIBUgJSAOa0sNCSAODQFBACEJIBVFDQwLQbZ/IQkMEQsgDiAbIBUQAhogFSEJDAoLIBwgGwJ/AkACQAJAIAlBAnZBA3FBAWsOAwEAAgALIAlBA3YhA0EBDAILIBsvAABBBHYhA0ECDAELIBVBBEkNDiACLwADIAItAAVBEHRyIgJBj4CAAUsNDiACQQR2IQNBAwsiAmotAAAgA0EgahADIQkgBSADNgKA6wEgBSAJNgLw6gEgAkEBaiEJDAULIBUCfwJAAkACQCAJQQJ2QQNxQQFrDgMBAAIACyAJQQN2IQNBAQwCCyAbLwAAQQR2IQNBAgwBCyACLwADIAItAAVBEHRyQQR2IQNBAwsiAiADaiIJQSBqSQRAIAkgFUsNDSAcIAIgG2ogAxACIQIgBSADNgKA6wEgBSACNgLw6gEgAiADaiICQgA3ABggAkIANwAQIAJCADcACCACQgA3AAAMBQsgBSADNgKA6wEgBSACIBtqNgLw6gEMBAsgB0UEQCAeIA8gCCAUEBQiAkGIf0sgAiAIT3INDCAcIAsgAiAPaiAIIAJrIB4QFSEDDAMLIAtFIAhFcg0LIAtBCHYiAyAIIAtJBH8gCEEEdCALbgVBDwtBGGwiAkGMCGooAgBsIAJBiAhqKAIAaiIGQQN2IAZqIAJBgAhqKAIAIAJBhAhqKAIAIANsakkEQCMAQRBrIhAkACAeKAIAIQMgFEHwBGpBAEHsABADIQZBVCECAkAgA0H/AXEiDEEMSw0AAkAgFEHcCWogBiAQQQhqIBBBDGogDyAIIBRB3AtqIhcQCyISQYh/Sw0AIBAoAgwiBiAMSw0BIBRBqAVqIQ0gFEGkBWohNiAeQQRqIREgA0GAgIB4cSE3IAZBAWoiEyECIAYhAwNAIAIiB0EBayECIAMiCkEBayEDIBQgCkECdGooAvAERQ0AC0EBIAcgB0EBTRshFkEAIQdBASECA0AgAiAWRwRAIBQgAkECdCIDaigC8AQhGCADIA1qIAc2AgAgAkEBaiECIAcgGGohBwwBCwsgDSAHNgIAQQAhAiAQKAIIIQMDQCACIANHBEAgDSACIBRqQdwJai0AACIYQQJ0aiIZIBkoAgAiGUEBajYCACAUIBlBAXRqIhkgGDoA3QUgGSACOgDcBSACQQFqIQIMAQsLQQAhAyANQQA2AgAgDCAGQX9zaiEGQQEhAgNAIAIgFkcEQCAUIAJBAnRqIg0gAzYCACANKALwBCACIAZqdCADaiEDIAJBAWohAgwBCwsgDCATIAprIgZrQQFqIQogBiEDA0AgAyAKSQRAIBQgA0E0bGohDUEBIQIDQCACIBZHBEAgDSACQQJ0IhhqIBQgGGooAgAgA3Y2AgAgAkEBaiECDAELCyADQQFqIQMMAQsLIBcgFEE0EAIhOCAUQZAMaiE5IBMgDGshOiAUQdwFaiEXQQAhCgNAAkACQCAHIApHBEBBASAMIBMgFyAKQQF0aiICLQABIg1rIgNrIhh0IRkgAi0AACEWIDggDUECdGoiHygCACECIAYgGE0EQCA2QQEgAyA6aiINIA1BAUwbIiBBAnQiJGooAgAhDSA5IBQgA0E0bGpBNBACISEgDUEBdCEmIBEgAkECdGohIyAgQQFNDQIgA0EQdEGAgPwHcSAWckGAgIAIciEgICEgJGooAgAhJEEAIQIDQCACICRGDQMgIyACQQJ0aiAgNgEAIAJBAWohAgwACwALIAIgAiAZaiINIAIgDUsbIQ0gA0EQdEGAgPwHcSAWckGAgIAIciEDA0AgAiANRg0DIBEgAkECdGogAzYBACACQQFqIQIMAAsACyAeIAxBEHQgN3IgDHJBgAJyNgIADAMLIAcgDWshJCAXICZqISZBACENA0AgDSAkRg0BQQEgGCATICYgDUEBdGoiJy0AASICayI7a3QiPCAhIAJBAnRqIiAoAgAiAmohPSADIDtqQRB0QYCA/AdxICctAABBCHRyIBZyQYCAgBByIScDQCAjIAJBAnRqICc2AQAgAkEBaiICID1JDQALICAgICgCACA8ajYCACANQQFqIQ0MAAsACyAfIB8oAgAgGWo2AgAgCkEBaiEKDAALAAsgEiECCyAQQRBqJAAgAkGIf0sgAiAIT3INDCAcIAsgAiAPaiAIIAJrIB4QFiEDDAMLIB4gDyAIIBQQFCICQYh/SyACIAhPcg0LIBwgCyACIA9qIAggAmsgHhAXIQMMAgsgAwRAIBwgCyAPIAggAhAWIQMMAgsgHCALIA8gCCACEBchAwwBCyAcIAsgDyAIIAIQFSEDCyADQYh/Sw0IIAUgCzYCgOsBIAUgHDYC8OoBIAVBATYCgOoBIBpBAkYEQCAFIB42AgwLIAsgHGoiAkIANwAAIAJCADcAGCACQgA3ABAgAkIANwAIIAlBiH9LDQoLIAkgFUYNCCAVIAlrIQYgBSgCnOsBIQoCQCAJIBtqIgMtAAAiD0UEQEEBIQJBACEPQbh/IQkgBkEBRg0BDAsLAn8gA0EBaiAPwCICQQBODQAaIAJBf0YEQCAGQQNIDQsgAy8AAUGA/gFqIQ8gA0EDagwBCyAGQQJIDQogAy0AASAPQQh0ckGAgAJrIQ8gA0ECagshEkG4fyEJIBJBAWoiAiAVIBtqIgdLDQogLCAFIBItAAAiEkEGdkEjQQkgAiAHIAJrQcAQQdARQfASIAUoAoTqASAKIA8gFBAhIglBiH9LDQggKyAoIBJBBHZBA3FBH0EIIAIgCWoiAiAHIAJrQYALQYAMQYAXIAUoAoTqASAFKAKc6wEgDyAUECEiCEGIf0sNCEFsIQkgKiAtIBJBAnZBA3FBNEEJIAIgCGoiAiAHIAJrQYANQeAOQZAZIAUoAoTqASAFKAKc6wEgDyAUECEiB0GIf0sNCiACIAdqIANrIgIhCSACQYh/Sw0KCyAOIA9BAExyDQELQbp/IQkMCAsgJSAOayEJIAYgAmshBiACIANqIQcCQAJAAkAgCkUEQCAPQQlIIAUpA8jpAUKBgIAIVHINAiAoKAIAIgJBCGohEiACKAIEIQpBACEDQQAhAgNAIAMgCnZFBEAgAiASIANBA3RqLQACQRZLaiECIANBAWohAwwBCwsgBUEANgKc6wEgAkEIIAprdEEUTw0BDAMLIAVBADYCnOsBCyAEIAUoAvDqASIDNgLcASAJIA5qIRYgAyAFKAKA6wFqIRcCQCAPRQRAIA4hBwwBCyAFKAK46QEhGiAFKAK06QEhGCAFKAKw6QEhEiAFQQE2AoTqAUEAIQMDQCADQQNHBEAgBCADQQJ0IgJqIAIgBWpBrNABaigCADYCZCADQQFqIQMMAQsLQWwhCSAEQThqIgIgByAGEA1BiH9LDQNBCCAPIA9BCE4bIR8gNCACIAUoAgAQHiAzIAIgBSgCCBAeIDIgAiAFKAIEEB4gDiASayEZQQAhCANAIARBOGoQD0EDRiAIIB9OckUEQCAEKAJQIAQoAkxBA3RqKQIAIkCnIgdBEHYiEUH/AXEhCyAEKAJgIAQoAlxBA3RqKQIAIkGnIgxBEHYiIUH/AXEhECAEKAJYIAQoAlRBA3RqKQIAIkJCIIinIQYgQUIgiCBAQiCIpyEDAkAgQkIQiKciCkH/AXEiAkECTwRAAkAgAkEZSSA/QoGAgBBUckUEQCAEQSAgBCgCPCIKayINIAIgAiANSxsiEyAKajYCPCAGIAQoAjggCnRBACATa3YgAiATayITdGohCiAEQThqEA8aIAIgDU0NASAEIAQoAjwiAiATajYCPCAEKAI4IAJ0QQAgE2t2IApqIQoMAQsgBCACIAQoAjwiDWo2AjwgBCgCOCANdEEAIAprdiAGaiEKIARBOGoQDxoLIAQpAmQhRCAEIAo2AmQgBCBENwJoDAELAkAgAkUEQCADBEAgBCgCZCEKDAMLIAQoAmghCgwBCyAEIAQoAjwiAkEBajYCPAJ/IAYgA0VqIAQoAjggAnRBH3ZqIgJBA0YEQCAEKAJkQQFrDAELIAJBAnQgBGooAmQLIgZFIAZqIQogAkEBRwRAIAQgBCgCaDYCbAsLIAQgBCgCZDYCaCAEIAo2AmQLpyECIEFCgID8B4NQRQRAIAQgBCgCPCIGIBBqNgI8IAQoAjggBnRBACAha3YgAmohAgsgCyAQakEUTwRAIARBOGoQDxoLIEBCgID8B4NQRQRAIAQgBCgCPCIGIAtqNgI8IAQoAjggBnRBACARa3YgA2ohAwsgBEE4ahAPGiAEIAQoAjgiBkEAIAdBGHYiCyAEKAI8aiIQa3YgC0ECdEGgHWooAgBxIAdB//8DcWo2AkwgBCAQIAxBGHYiB2oiCzYCPCAEIAdBAnRBoB1qKAIAIAZBACALa3ZxIAxB//8DcWo2AlwgBEE4ahAPGiAEIEKnIgZBGHYiByAEKAI8aiILNgI8IAQgB0ECdEGgHWooAgAgBCgCOEEAIAtrdnEgBkH//wNxajYCVCAEQfAAaiAIQQxsaiIGIAo2AgggBiACNgIEIAYgAzYCACAIQQFqIQggAyAZaiACaiEZDAELCyAIIB9IDQMgFkEgayEhIA4hBwNAIARBOGoQD0EDRiAIIA9OckUEQCAEKAJQIAQoAkxBA3RqKQIAIkCnIgZBEHYiI0H/AXEhCiAEKAJgIAQoAlxBA3RqKQIAIkGnIg1BEHYiIEH/AXEhEyAEKAJYIAQoAlRBA3RqKQIAIkJCIIinIQMgQUIgiCBAQiCIpyELAkAgQkIQiKciDEH/AXEiAkECTwRAAkAgAkEZSSA/QoGAgBBUckUEQCAEQSAgBCgCPCIMayIRIAIgAiARSxsiECAMajYCPCADIAQoAjggDHRBACAQa3YgAiAQayIMdGohECAEQThqEA8aIAIgEU0NASAEIAQoAjwiAiAMajYCPCAEKAI4IAJ0QQAgDGt2IBBqIRAMAQsgBCACIAQoAjwiEGo2AjwgBCgCOCAQdEEAIAxrdiADaiEQIARBOGoQDxoLIAQpAmQhRCAEIBA2AmQgBCBENwJoDAELAkAgAkUEQCALBEAgBCgCZCEQDAMLIAQoAmghEAwBCyAEIAQoAjwiAkEBajYCPAJ/IAMgC0VqIAQoAjggAnRBH3ZqIgJBA0YEQCAEKAJkQQFrDAELIAJBAnQgBGooAmQLIgNFIANqIRAgAkEBRwRAIAQgBCgCaDYCbAsLIAQgBCgCZDYCaCAEIBA2AmQLpyEMIEFCgID8B4NQRQRAIAQgBCgCPCICIBNqNgI8IAQoAjggAnRBACAga3YgDGohDAsgCiATakEUTwRAIARBOGoQDxoLIEBCgID8B4NQRQRAIAQgBCgCPCICIApqNgI8IAQoAjggAnRBACAja3YgC2ohCwsgBEE4ahAPGiAEIAQoAjgiAkEAIAZBGHYiAyAEKAI8aiIKa3YgA0ECdEGgHWooAgBxIAZB//8DcWo2AkwgBCAKIA1BGHYiA2oiBjYCPCAEIANBAnRBoB1qKAIAIAJBACAGa3ZxIA1B//8DcWo2AlwgBEE4ahAPGiAEIEKnIgJBGHYiAyAEKAI8aiIGNgI8IAQgA0ECdEGgHWooAgAgBCgCOEEAIAZrdnEgAkH//wNxajYCVAJAAkACQCAEKALcASIDIARB8ABqIAhBB3FBDGxqIhMoAgAiEWoiIyAXSw0AIAcgEygCBCINIBFqIgpqICFLDQAgCkEgaiAWIAdrTQ0BCyAEIBMoAgg2AhggBCATKQIANwMQIAcgFiAEQRBqIARB3AFqIBcgEiAYIBoQHyEKDAELIAcgEWohAiATKAIIIQYgByADKQAANwAAIAcgAykACDcACAJAIBFBEUkNACAHIAMpABA3ABAgByADKQAYNwAYIBFBEGtBEUgNACADQRBqIQMgB0EgaiERA0AgESADKQAQNwAAIBEgAykAGDcACCARIAMpACA3ABAgESADKQAoNwAYIANBIGohAyARQSBqIhEgAkkNAAsLIAIgBmshAyAEICM2AtwBIAIgEmsgBkkEQCAGIAIgGGtLDQcgGiAaIAMgEmsiA2oiESANak8EQCACIBEgDRAKGgwCCyADIA1qIQ0gAiARQQAgA2sQCiADayECIBIhAwsgBkEQTwRAIAIgAykAADcAACACIAMpAAg3AAggDUERSA0BIAIgDWohBiACQRBqIQIDQCACIAMpABA3AAAgAiADKQAYNwAIIAIgAykAIDcAECACIAMpACg3ABggA0EgaiEDIAJBIGoiAiAGSQ0ACwwBCwJAIAZBB00EQCACIAMtAAA6AAAgAiADLQABOgABIAIgAy0AAjoAAiACIAMtAAM6AAMgAiADIAZBAnQiBkHAHmooAgBqIgMoAAA2AAQgAyAGQeAeaigCAGshAwwBCyACIAMpAAA3AAALIA1BCUkNACACIA1qIREgAkEIaiIGIANBCGoiA2tBD0wEQANAIAYgAykAADcAACADQQhqIQMgBkEIaiIGIBFJDQAMAgsACyAGIAMpAAA3AAAgBiADKQAINwAIIA1BGUgNACACQRhqIQIDQCACIAMpABA3AAAgAiADKQAYNwAIIAIgAykAIDcAECACIAMpACg3ABggA0EgaiEDIAJBIGoiAiARSQ0ACwsgCkGIf0sEQCAKIQkMBgUgEyAQNgIIIBMgDDYCBCATIAs2AgAgCEEBaiEIIAcgCmohByALIBlqIAxqIRkMAgsACwsgCCAPSA0DIAggH2shBgNAAkAgBiAPTgRAQQAhAwNAIANBA0YNAiAFIANBAnQiAmpBrNABaiACIARqKAJkNgIAIANBAWohAwwACwALAkACQAJAIAQoAtwBIgMgBEHwAGogBkEHcUEMbGoiCCgCACIMaiIQIBdLDQAgByAIKAIEIgsgDGoiCmogIUsNACAKQSBqIBYgB2tNDQELIAQgCCgCCDYCKCAEIAgpAgA3AyAgByAWIARBIGogBEHcAWogFyASIBggGhAfIQoMAQsgByAMaiECIAgoAgghCCAHIAMpAAA3AAAgByADKQAINwAIAkAgDEERSQ0AIAcgAykAEDcAECAHIAMpABg3ABggDEEQa0ERSA0AIANBEGohAyAHQSBqIQwDQCAMIAMpABA3AAAgDCADKQAYNwAIIAwgAykAIDcAECAMIAMpACg3ABggA0EgaiEDIAxBIGoiDCACSQ0ACwsgAiAIayEDIAQgEDYC3AEgAiASayAISQRAIAggAiAYa0sNByAaIBogAyASayIDaiIMIAtqTwRAIAIgDCALEAoaDAILIAMgC2ohCyACIAxBACADaxAKIANrIQIgEiEDCyAIQRBPBEAgAiADKQAANwAAIAIgAykACDcACCALQRFIDQEgAiALaiEIIAJBEGohAgNAIAIgAykAEDcAACACIAMpABg3AAggAiADKQAgNwAQIAIgAykAKDcAGCADQSBqIQMgAkEgaiICIAhJDQALDAELAkAgCEEHTQRAIAIgAy0AADoAACACIAMtAAE6AAEgAiADLQACOgACIAIgAy0AAzoAAyACIAMgCEECdCIIQcAeaigCAGoiAygAADYABCADIAhB4B5qKAIAayEDDAELIAIgAykAADcAAAsgC0EJSQ0AIAIgC2ohDCACQQhqIgggA0EIaiIDa0EPTARAA0AgCCADKQAANwAAIANBCGohAyAIQQhqIgggDEkNAAwCCwALIAggAykAADcAACAIIAMpAAg3AAggC0EZSA0AIAJBGGohAgNAIAIgAykAEDcAACACIAMpABg3AAggAiADKQAgNwAQIAIgAykAKDcAGCADQSBqIQMgAkEgaiICIAxJDQALCyAKQYh/SwRAIAohCQwGBSAGQQFqIQYgByAKaiEHDAILAAsLIAQoAtwBIQMLQbp/IQkgFyADayICIBYgB2tLDQIgBwR/IAcgAyACEAIgAmoFQQALIA5rIQkMAgsgBUEANgKc6wELIAQgBSgC8OoBIgM2AtwBIAkgDmohDCADIAUoAoDrAWohEAJAIA9FBEAgDiEGDAELIAUoArjpASENIAUoArTpASETIAUoArDpASESIAVBATYChOoBQQAhAwNAIANBA0cEQCAEIANBAnQiAmogAiAFakGs0AFqKAIANgKcASADQQFqIQMMAQsLQWwhCSAEQfAAaiICIAcgBhANQYh/Sw0BIDEgAiAFKAIAEB4gMCACIAUoAggQHiAvIAIgBSgCBBAeIAxBIGshGCAOIQYDQCAEKAKIASAEKAKEAUEDdGopAgAiQKciCkEQdiIZQf8BcSELIAQoApgBIAQoApQBQQN0aikCACJBpyIWQRB2Ih9B/wFxIRogBCgCkAEgBCgCjAFBA3RqKQIAIkJCIIinIQcgQUIgiCBAQiCIpyEDAkAgQkIQiKciCEH/AXEiAkECTwRAAkAgAkEZSSA/QoGAgBBUckUEQCAEQSAgBCgCdCIIayIRIAIgAiARSxsiFyAIajYCdCAHIAQoAnAgCHRBACAXa3YgAiAXayIXdGohCCAEQfAAahAPGiACIBFNDQEgBCAEKAJ0IgIgF2o2AnQgBCgCcCACdEEAIBdrdiAIaiEIDAELIAQgAiAEKAJ0IhFqNgJ0IAQoAnAgEXRBACAIa3YgB2ohCCAEQfAAahAPGgsgBCkCnAEhRCAEIAg2ApwBIAQgRDcCoAEMAQsCQCACRQRAIAMEQCAEKAKcASEIDAMLIAQoAqABIQgMAQsgBCAEKAJ0IgJBAWo2AnQCfyAHIANFaiAEKAJwIAJ0QR92aiICQQNGBEAgBCgCnAFBAWsMAQsgAkECdCAEaigCnAELIgdFIAdqIQggAkEBRwRAIAQgBCgCoAE2AqQBCwsgBCAEKAKcATYCoAEgBCAINgKcAQunIQIgQUKAgPwHg1BFBEAgBCAEKAJ0IgcgGmo2AnQgBCgCcCAHdEEAIB9rdiACaiECCyALIBpqQRRPBEAgBEHwAGoQDxoLIEBCgID8B4NQRQRAIAQgBCgCdCIHIAtqNgJ0IAQoAnAgB3RBACAZa3YgA2ohAwsgBEHwAGoQDxogBCAEKAJwIgdBACAKQRh2IgsgBCgCdGoiGmt2IAtBAnRBoB1qKAIAcSAKQf//A3FqNgKEASAEIBogFkEYdiIKaiILNgJ0IAQgCkECdEGgHWooAgAgB0EAIAtrdnEgFkH//wNxajYClAEgBEHwAGoQDxogBCBCpyIHQRh2IgogBCgCdGoiCzYCdCAEIApBAnRBoB1qKAIAIAQoAnBBACALa3ZxIAdB//8DcWo2AowBIAQgAzYCOCAEIAI2AjwgBCAINgJAAkACQAJAIAQoAtwBIgsgA2oiFiAQSw0AIAYgAiADaiIKaiAYSw0AIApBIGogDCAGa00NAQsgBCAEQUBrKAIANgIIIAQgBCkDODcDACAGIAwgBCAEQdwBaiAQIBIgEyANEB8hCgwBCyADIAZqIQcgBiALKQAANwAAIAYgCykACDcACAJAIANBEUkNACAGIAspABA3ABAgBiALKQAYNwAYIANBEGtBEUgNACALQRBqIQMgBkEgaiELA0AgCyADKQAQNwAAIAsgAykAGDcACCALIAMpACA3ABAgCyADKQAoNwAYIANBIGohAyALQSBqIgsgB0kNAAsLIAcgCGshAyAEIBY2AtwBIAcgEmsgCEkEQCAIIAcgE2tLDQQgDSANIAMgEmsiA2oiCyACak8EQCAHIAsgAhAKGgwCCyAHIAtBACADaxAKIAQgAiADaiICNgI8IANrIQcgEiEDCyAIQRBPBEAgByADKQAANwAAIAcgAykACDcACCACQRFIDQEgAiAHaiEIIAdBEGohAgNAIAIgAykAEDcAACACIAMpABg3AAggAiADKQAgNwAQIAIgAykAKDcAGCADQSBqIQMgAkEgaiICIAhJDQALDAELAkAgCEEHTQRAIAcgAy0AADoAACAHIAMtAAE6AAEgByADLQACOgACIAcgAy0AAzoAAyAHIAMgCEECdCIIQcAeaigCAGoiAygAADYABCADIAhB4B5qKAIAayEDDAELIAcgAykAADcAAAsgAkEJSQ0AIAIgB2ohCyAHQQhqIgggA0EIaiIDa0EPTARAA0AgCCADKQAANwAAIANBCGohAyAIQQhqIgggC0kNAAwCCwALIAggAykAADcAACAIIAMpAAg3AAggAkEZSA0AIAdBGGohAgNAIAIgAykAEDcAACACIAMpABg3AAggAiADKQAgNwAQIAIgAykAKDcAGCADQSBqIQMgAkEgaiICIAtJDQALCyAKQYh/SwRAIAohCQwDCyAGIApqIQYgBEHwAGoQDyEDIA9BAWsiDw0AC0EAIQIgA0ECSQ0BA0AgAkEDRwRAIAUgAkECdCIDakGs0AFqIAMgBGooApwBNgIAIAJBAWohAgwBCwsgBCgC3AEhAwtBun8hCSAQIANrIgIgDCAGa0sNACAGBH8gBiADIAIQAiACagVBAAsgDmshCQsgCUGIf0sNBgsCQCAFKALs6gFFDQAgBSAFKQOI6gEgCa18NwOI6gECQCAFKALQ6gEiAiAJaiIIQR9NBEAgDkUNASACICJqIA4gCRACGiAFKALQ6gEgCWohCAwBCyAOIQMgAgRAIAIgImogA0EgIAJrEAIaIAUoAtDqASECIAVBADYC0OoBIAUgBSkDkOoBIAUpALDqAULP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDkOoBIAUgBSkDmOoBIAUpALjqAULP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDmOoBIAUgBSkDoOoBIAUpAMDqAULP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDoOoBIAUgBSkDqOoBIAUpAMjqAULP1tO+0ser2UJ+fEIfiUKHla+vmLbem55/fjcDqOoBIAMgAmtBIGohAwsgCSAOaiICIANBIGpPBEAgAkEgayEGIAUpA6jqASE/IAUpA6DqASFAIAUpA5jqASFBIAUpA5DqASFCA0AgAykAGELP1tO+0ser2UJ+ID98Qh+JQoeVr6+Ytt6bnn9+IT8gAykAEELP1tO+0ser2UJ+IEB8Qh+JQoeVr6+Ytt6bnn9+IUAgAykACELP1tO+0ser2UJ+IEF8Qh+JQoeVr6+Ytt6bnn9+IUEgAykAAELP1tO+0ser2UJ+IEJ8Qh+JQoeVr6+Ytt6bnn9+IUIgA0EgaiIDIAZNDQALIAUgPzcDqOoBIAUgQDcDoOoBIAUgQTcDmOoBIAUgQjcDkOoBCyACIANNDQEgIiADIAIgA2siCBACGgsgBSAINgLQ6gELIDUgFWshAyAVIBtqIQIgCSAOaiEOIAQoAjBFDQALICkpAwAiP0J/USA/IA4gHWusUXJFBEBBbCEJDAYLIAUoAuDpAQRAQWohCSADQQRJDQYgBSgC6OoBRQRAICIgBSgC0OoBaiEKAn4gBSkDiOoBIj9CIFoEQCAFKQOY6gEiQEIHiSAFKQOQ6gEiQUIBiXwgBSkDoOoBIkJCDIl8IAUpA6jqASJDQhKJfCBBQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9IEBCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/foVCh5Wvr5i23puef35CnaO16oOxjYr6AH0gQkLP1tO+0ser2UJ+Qh+JQoeVr6+Ytt6bnn9+hUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSBDQs/W077Sx6vZQn5CH4lCh5Wvr5i23puef36FQoeVr6+Ytt6bnn9+Qp2jteqDsY2K+gB9DAELIAUpA6DqAULFz9my8eW66id8CyA/fCE/ICIhBgNAIAogBkEIaiIHTwRAIAYpAABCz9bTvtLHq9lCfkIfiUKHla+vmLbem55/fiA/hUIbiUKHla+vmLbem55/fkKdo7Xqg7GNivoAfSE/IAchBgwBCwsCQCAKIAZBBGoiCEkEQCAGIQgMAQsgBjUAAEKHla+vmLbem55/fiA/hUIXiULP1tO+0ser2UJ+Qvnz3fGZ9pmrFnwhPwsDQCAIIApJBEAgCDEAAELFz9my8eW66id+ID+FQguJQoeVr6+Ytt6bnn9+IT8gCEEBaiEIDAELCyACKAAAID9CIYggP4VCz9bTvtLHq9lCfiI/Qh2IID+FQvnz3fGZ9pmrFn4iP0IgiCA/hadHDQcLIANBBGshAyACQQRqIQILIA4gHWsiCUGJf08NBCABIAlrIQEgCSAdaiEdQQEhPgwBCwtBuH8hByADDQQgHSAAayEHDAQLQWwhCQwBC0G4fyEJC0G4fyEHIAlBdkYgPnENAQsgCSEHCygCAA0AIAVB/OoBaigCACEBIAVB+OoBaigCACEAIAUQGCAFKAKw6wEgACABEBMgBUEANgKw6wEgBSgCpOsBIgIEQAJAAkACQAJAIAIoAgAiAwRAIABFDQIgASADIAARAgAMAQsgAEUNAgsgASACIAARAgAMAgsgAxAGCyACEAYLIAVBADYCpOsBCyAABEAgASAFIAARAgAMAQsgBRAGCyAEQeABaiQAIAcLC6gVCQBBiAgLDQEAAAABAAAAAgAAAAIAQaAIC7MGAQAAAAEAAAACAAAAAgAAACYAAACCAAAAIQUAAEoAAABnCAAAJgAAAMABAACAAAAASQUAAEoAAAC+CAAAKQAAACwCAACAAAAASQUAAEoAAAC+CAAALwAAAMoCAACAAAAAigUAAEoAAACECQAANQAAAHMDAACAAAAAnQUAAEoAAACgCQAAPQAAAIEDAACAAAAA6wUAAEsAAAA+CgAARAAAAJ4DAACAAAAATQYAAEsAAACqCgAASwAAALMDAACAAAAAwQYAAE0AAAAfDQAATQAAAFMEAACAAAAAIwgAAFEAAACmDwAAVAAAAJkEAACAAAAASwkAAFcAAACxEgAAWAAAANoEAACAAAAAbwkAAF0AAAAjFAAAVAAAAEUFAACAAAAAVAoAAGoAAACMFAAAagAAAK8FAACAAAAAdgkAAHwAAABOEAAAfAAAANICAACAAAAAYwcAAJEAAACQBwAAkgAAAAAAAAABAAAAAQAAAAUAAAANAAAAHQAAAD0AAAB9AAAA/QAAAP0BAAD9AwAA/QcAAP0PAAD9HwAA/T8AAP1/AAD9/wAA/f8BAP3/AwD9/wcA/f8PAP3/HwD9/z8A/f9/AP3//wD9//8B/f//A/3//wf9//8P/f//H/3//z/9//9/AAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAARAAAAEgAAABMAAAAUAAAAFQAAABYAAAAXAAAAGAAAABkAAAAaAAAAGwAAABwAAAAdAAAAHgAAAB8AAAADAAAABAAAAAUAAAAGAAAABwAAAAgAAAAJAAAACgAAAAsAAAAMAAAADQAAAA4AAAAPAAAAEAAAABEAAAASAAAAEwAAABQAAAAVAAAAFgAAABcAAAAYAAAAGQAAABoAAAAbAAAAHAAAAB0AAAAeAAAAHwAAACAAAAAhAAAAIgAAACMAAAAlAAAAJwAAACkAAAArAAAALwAAADMAAAA7AAAAQwAAAFMAAABjAAAAgwAAAAMBAAADAgAAAwQAAAMIAAADEAAAAyAAAANAAAADgAAAAwABAEHgDwtRAQAAAAEAAAABAAAAAQAAAAIAAAACAAAAAwAAAAMAAAAEAAAABAAAAAUAAAAHAAAACAAAAAkAAAAKAAAACwAAAAwAAAANAAAADgAAAA8AAAAQAEHEEAuLAQEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAASAAAAFAAAABYAAAAYAAAAHAAAACAAAAAoAAAAMAAAAEAAAACAAAAAAAEAAAACAAAABAAAAAgAAAAQAAAAIAAAAEAAAACAAAAAAAEAQZASC+YEAQAAAAEAAAABAAAAAQAAAAIAAAACAAAAAwAAAAMAAAAEAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAABAAAABAAAAAgAAAAAAAAAAQABAQYAAAAAAAAEAAAAABAAAAQAAAAAIAAABQEAAAAAAAAFAwAAAAAAAAUEAAAAAAAABQYAAAAAAAAFBwAAAAAAAAUJAAAAAAAABQoAAAAAAAAFDAAAAAAAAAYOAAAAAAABBRAAAAAAAAEFFAAAAAAAAQUWAAAAAAACBRwAAAAAAAMFIAAAAAAABAUwAAAAIAAGBUAAAAAAAAcFgAAAAAAACAYAAQAAAAAKBgAEAAAAAAwGABAAACAAAAQAAAAAAAAABAEAAAAAAAAFAgAAACAAAAUEAAAAAAAABQUAAAAgAAAFBwAAAAAAAAUIAAAAIAAABQoAAAAAAAAFCwAAAAAAAAYNAAAAIAABBRAAAAAAAAEFEgAAACAAAQUWAAAAAAACBRgAAAAgAAMFIAAAAAAAAwUoAAAAAAAGBEAAAAAQAAYEQAAAACAABwWAAAAAAAAJBgACAAAAAAsGAAgAADAAAAQAAAAAEAAABAEAAAAgAAAFAgAAACAAAAUDAAAAIAAABQUAAAAgAAAFBgAAACAAAAUIAAAAIAAABQkAAAAgAAAFCwAAACAAAAUMAAAAAAAABg8AAAAgAAEFEgAAACAAAQUUAAAAIAACBRgAAAAgAAIFHAAAACAAAwUoAAAAIAAEBTAAAAAAABAGAAABAAAADwYAgAAAAAAOBgBAAAAAAA0GACAAQYAXC4cCAQABAQUAAAAAAAAFAAAAAAAABgQ9AAAAAAAJBf0BAAAAAA8F/X8AAAAAFQX9/x8AAAADBQUAAAAAAAcEfQAAAAAADAX9DwAAAAASBf3/AwAAABcF/f9/AAAABQUdAAAAAAAIBP0AAAAAAA4F/T8AAAAAFAX9/w8AAAACBQEAAAAQAAcEfQAAAAAACwX9BwAAAAARBf3/AQAAABYF/f8/AAAABAUNAAAAEAAIBP0AAAAAAA0F/R8AAAAAEwX9/wcAAAABBQEAAAAQAAYEPQAAAAAACgX9AwAAAAAQBf3/AAAAABwF/f//DwAAGwX9//8HAAAaBf3//wMAABkF/f//AQAAGAX9//8AQZAZC4YEAQABAQYAAAAAAAAGAwAAAAAAAAQEAAAAIAAABQUAAAAAAAAFBgAAAAAAAAUIAAAAAAAABQkAAAAAAAAFCwAAAAAAAAYNAAAAAAAABhAAAAAAAAAGEwAAAAAAAAYWAAAAAAAABhkAAAAAAAAGHAAAAAAAAAYfAAAAAAAABiIAAAAAAAEGJQAAAAAAAQYpAAAAAAACBi8AAAAAAAMGOwAAAAAABAZTAAAAAAAHBoMAAAAAAAkGAwIAABAAAAQEAAAAAAAABAUAAAAgAAAFBgAAAAAAAAUHAAAAIAAABQkAAAAAAAAFCgAAAAAAAAYMAAAAAAAABg8AAAAAAAAGEgAAAAAAAAYVAAAAAAAABhgAAAAAAAAGGwAAAAAAAAYeAAAAAAAABiEAAAAAAAEGIwAAAAAAAQYnAAAAAAACBisAAAAAAAMGMwAAAAAABAZDAAAAAAAFBmMAAAAAAAgGAwEAACAAAAQEAAAAMAAABAQAAAAQAAAEBQAAACAAAAUHAAAAIAAABQgAAAAgAAAFCgAAACAAAAULAAAAAAAABg4AAAAAAAAGEQAAAAAAAAYUAAAAAAAABhcAAAAAAAAGGgAAAAAAAAYdAAAAAAAABiAAAAAAABAGAwABAAAADwYDgAAAAAAOBgNAAAAAAA0GAyAAAAAADAYDEAAAAAALBgMIAAAAAAoGAwQAQaQdC9kBAQAAAAMAAAAHAAAADwAAAB8AAAA/AAAAfwAAAP8AAAD/AQAA/wMAAP8HAAD/DwAA/x8AAP8/AAD/fwAA//8AAP//AQD//wMA//8HAP//DwD//x8A//8/AP//fwD///8A////Af///wP///8H////D////x////8/////fwAAAAABAAAAAgAAAAQAAAAAAAAAAgAAAAQAAAAIAAAAAAAAAAEAAAACAAAAAQAAAAQAAAAEAAAABAAAAAQAAAAIAAAACAAAAAgAAAAHAAAACAAAAAkAAAAKAAAACwBBgB8LA4ARAQ==";var OI=new yA,TI=!1;async function ce(A,I,t){let e=null;typeof A!="string"?e=A.href:A.startsWith("http")?e=A:e=`${I}/${A}`,e.endsWith(".js")&&(e=e.substring(0,e.length-3)),e.endsWith(".wasm")&&(e=e.substring(0,e.length-5));let g=`${e}.wasm`,r=await dA.get(`${g}.zst`,{responseType:"arraybuffer",params:t});TI||(await OI.init(),TI=!0);let s=OI.decode(new Uint8Array(r.data)).buffer;return(await import(`${e}.js`)).default({wasmBinary:s})}var xI=ce;var wA=new Map;async function fe(A,I,t){let e=A,g=A,r=null;return typeof A!="string"&&(e=new URL(A.href),g=e.href),wA.has(g)?r=await wA.get(g):(wA.set(g,xI(e,I,t)),r=await wA.get(g)),r}var PI=fe;var le={TextFile:"TextFile",BinaryFile:"BinaryFile",TextStream:"TextStream",BinaryStream:"BinaryStream",Image:"Image",Mesh:"Mesh",PolyData:"PolyData",JsonCompatible:"JsonCompatible"},D=le;var De={Int8:"int8",UInt8:"uint8",Int16:"int16",UInt16:"uint16",Int32:"int32",UInt32:"uint32",Int64:"int64",UInt64:"uint64",SizeValueType:"uint64",IdentifierType:"uint64",IndexValueType:"int64",OffsetValueType:"int64"},p=De;var ue={Float32:"float32",Float64:"float64",SpacePrecisionType:"float64"},P=ue;function he(A,I){let t=null;switch(A){case p.UInt8:{t=new Uint8Array(I);break}case p.Int8:{t=new Int8Array(I);break}case p.UInt16:{t=new Uint16Array(I);break}case p.Int16:{t=new Int16Array(I);break}case p.UInt32:{t=new Uint32Array(I);break}case p.Int32:{t=new Int32Array(I);break}case p.UInt64:{typeof globalThis.BigUint64Array=="function"?t=new BigUint64Array(I):t=new Uint8Array(I);break}case p.Int64:{typeof globalThis.BigInt64Array=="function"?t=new BigInt64Array(I):t=new Uint8Array(I);break}case P.Float32:{t=new Float32Array(I);break}case P.Float64:{t=new Float64Array(I);break}case"null":{t=null;break}case null:{t=null;break}default:throw new Error("Type is not supported as a TypedArray")}return t}var Y=he;var ZI=typeof globalThis.SharedArrayBuffer=="function",jI=new TextEncoder,WI=new TextDecoder("utf-8");function de(A,I){let t={flags:"r",encoding:"binary"},e=A.fs_open(I,t.flags),r=A.fs_stat(I).size,i=null;ZI?i=new SharedArrayBuffer(r):i=new ArrayBuffer(r);let s=new Uint8Array(i);return A.fs_read(e,s,0,r,0),A.fs_close(e),s}function VI(A,I,t){let e=null;ZI?e=new SharedArrayBuffer(t):e=new ArrayBuffer(t);let g=new Uint8Array(e),r=new Uint8Array(A.HEAPU8.buffer,I,t);return g.set(r),g}function y(A,I,t,e){let g=0;return I!==null&&(g=A.ccall("itk_wasm_input_array_alloc","number",["number","number","number","number"],[0,t,e,I.buffer.byteLength]),A.HEAPU8.set(new Uint8Array(I.buffer),g)),g}function j(A,I,t){let e=JSON.stringify(I),g=A.ccall("itk_wasm_input_json_alloc","number",["number","number","number"],[0,t,e.length]);A.writeAsciiToMemory(e,g,!1)}function S(A,I,t,e){let g=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,I,t]),r=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,I,t]),i=VI(A,g,r);return Y(e,i.buffer)}function zA(A,I){let t=A.ccall("itk_wasm_output_json_address","number",["number","number"],[0,I]),e=A.AsciiToString(t);return JSON.parse(e)}function ye(A,I,t,e){e!=null&&e.length>0&&e.forEach(function(n,C){switch(n.type){case D.TextStream:{let o=jI.encode(n.data.data),f=y(A,o,C,0),Q={size:o.buffer.byteLength,data:`data:application/vnd.itk.address,0:${f}`};j(A,Q,C);break}case D.JsonCompatible:{let o=jI.encode(JSON.stringify(n.data)),f=y(A,o,C,0),Q={size:o.buffer.byteLength,data:`data:application/vnd.itk.address,0:${f}`};j(A,Q,C);break}case D.BinaryStream:{let o=n.data.data,f=y(A,o,C,0),Q={size:o.buffer.byteLength,data:`data:application/vnd.itk.address,0:${f}`};j(A,Q,C);break}case D.TextFile:{A.fs_writeFile(n.data.path,n.data.data);break}case D.BinaryFile:{A.fs_writeFile(n.data.path,n.data.data);break}case D.Image:{let o=n.data,f=y(A,o.data,C,0),Q=y(A,o.direction,C,1),E=typeof o.metadata?.entries<"u"?JSON.stringify(Array.from(o.metadata.entries())):"[]",c={imageType:o.imageType,name:o.name,origin:o.origin,spacing:o.spacing,direction:`data:application/vnd.itk.address,0:${Q}`,size:o.size,data:`data:application/vnd.itk.address,0:${f}`,metadata:E};j(A,c,C);break}case D.Mesh:{let o=n.data,f=y(A,o.points,C,0),Q=y(A,o.cells,C,1),E=y(A,o.pointData,C,2),c=y(A,o.cellData,C,3),u={meshType:o.meshType,name:o.name,numberOfPoints:o.numberOfPoints,points:`data:application/vnd.itk.address,0:${f}`,numberOfCells:o.numberOfCells,cells:`data:application/vnd.itk.address,0:${Q}`,cellBufferSize:o.cellBufferSize,numberOfPointPixels:o.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${E}`,numberOfCellPixels:o.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${c}`};j(A,u,C);break}case D.PolyData:{let o=n.data,f=y(A,o.points,C,0),Q=y(A,o.vertices,C,1),E=y(A,o.lines,C,2),c=y(A,o.polygons,C,3),u=y(A,o.triangleStrips,C,4),d=y(A,o.pointData,C,5),R=y(A,o.pointData,C,6),N={polyDataType:o.polyDataType,name:o.name,numberOfPoints:o.numberOfPoints,points:`data:application/vnd.itk.address,0:${f}`,verticesBufferSize:o.verticesBufferSize,vertices:`data:application/vnd.itk.address,0:${Q}`,linesBufferSize:o.linesBufferSize,lines:`data:application/vnd.itk.address,0:${E}`,polygonsBufferSize:o.polygonsBufferSize,polygons:`data:application/vnd.itk.address,0:${c}`,triangleStripsBufferSize:o.triangleStripsBufferSize,triangleStrips:`data:application/vnd.itk.address,0:${u}`,numberOfPointPixels:o.numberOfPointPixels,pointData:`data:application/vnd.itk.address,0:${d}`,numberOfCellPixels:o.numberOfCellPixels,cellData:`data:application/vnd.itk.address,0:${R}`};j(A,N,C);break}default:throw Error("Unsupported input InterfaceType")}}),A.resetModuleStdout(),A.resetModuleStderr();let g=A.stackSave(),r=0;try{r=A.callMain(I.slice())}catch(n){throw typeof n=="number"&&(console.log("Exception while running pipeline:"),console.log("stdout:",A.getModuleStdout()),console.error("stderr:",A.getModuleStderr()),typeof A.getExceptionMessage<"u"?console.error("exception:",A.getExceptionMessage(n)):console.error("Build module in Debug mode for exception message information.")),n}finally{A.stackRestore(g)}let i=A.getModuleStdout(),s=A.getModuleStderr(),a=[];return t!=null&&t.length>0&&r===0&&t.forEach(function(n,C){let o=null;switch(n.type){case D.TextStream:{let Q=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,C,0]),E=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,C,0]),c=new Uint8Array(A.HEAPU8.buffer,Q,E);o={data:WI.decode(c)};break}case D.JsonCompatible:{let Q=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,C,0]),E=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,C,0]),c=new Uint8Array(A.HEAPU8.buffer,Q,E);o=JSON.parse(WI.decode(c));break}case D.BinaryStream:{let Q=A.ccall("itk_wasm_output_array_address","number",["number","number","number"],[0,C,0]),E=A.ccall("itk_wasm_output_array_size","number",["number","number","number"],[0,C,0]);o={data:VI(A,Q,E)};break}case D.TextFile:{o={path:n.data.path,data:A.fs_readFile(n.data.path,{encoding:"utf8"})};break}case D.BinaryFile:{o={path:n.data.path,data:de(A,n.data.path)};break}case D.Image:{let Q=zA(A,C);Q.data=S(A,C,0,Q.imageType.componentType),Q.direction=S(A,C,1,P.Float64),Q.metadata=new Map(Q.metadata),o=Q;break}case D.Mesh:{let Q=zA(A,C);Q.numberOfPoints>0?Q.points=S(A,C,0,Q.meshType.pointComponentType):Q.points=Y(Q.meshType.pointComponentType,new ArrayBuffer(0)),Q.numberOfCells>0?Q.cells=S(A,C,1,Q.meshType.cellComponentType):Q.cells=Y(Q.meshType.cellComponentType,new ArrayBuffer(0)),Q.numberOfPointPixels>0?Q.pointData=S(A,C,2,Q.meshType.pointPixelComponentType):Q.pointData=Y(Q.meshType.pointPixelComponentType,new ArrayBuffer(0)),Q.numberOfCellPixels>0?Q.cellData=S(A,C,3,Q.meshType.cellPixelComponentType):Q.cellData=Y(Q.meshType.cellPixelComponentType,new ArrayBuffer(0)),o=Q;break}case D.PolyData:{let Q=zA(A,C);Q.numberOfPoints>0?Q.points=S(A,C,0,P.Float32):Q.points=new Float32Array,Q.verticesBufferSize>0?Q.vertices=S(A,C,1,p.UInt32):Q.vertices=new Uint32Array,Q.linesBufferSize>0?Q.lines=S(A,C,2,p.UInt32):Q.lines=new Uint32Array,Q.polygonsBufferSize>0?Q.polygons=S(A,C,3,p.UInt32):Q.polygons=new Uint32Array,Q.triangleStripsBufferSize>0?Q.triangleStrips=S(A,C,4,p.UInt32):Q.triangleStrips=new Uint32Array,Q.numberOfPointPixels>0?Q.pointData=S(A,C,5,Q.polyDataType.pointPixelComponentType):Q.pointData=Y(Q.polyDataType.pointPixelComponentType,new ArrayBuffer(0)),Q.numberOfCellPixels>0?Q.cellData=S(A,C,6,Q.polyDataType.cellPixelComponentType):Q.cellData=Y(Q.polyDataType.cellPixelComponentType,new ArrayBuffer(0)),o=Q;break}default:throw Error("Unsupported output InterfaceType")}let f={type:n.type,data:o};a.push(f)}),{returnValue:r,stdout:i,stderr:s,outputs:a}}var XI=ye;var we=typeof globalThis.SharedArrayBuffer<"u";function me(A,I){if(A==null)return[];let t=[];for(let e=0;e<A.length;e++){let g=pe(A[e],I);g!==null&&t.push(g)}return t}function pe(A,I){if(A==null)return null;let t=null;return A.buffer!==void 0?t=A.buffer:A.byteLength!==void 0&&(t=A),we&&t instanceof SharedArrayBuffer?null:I?t:t.slice(0)}var zI=me;function Se(A){return[A.data,A.direction]}var _I=Se;function Fe(A){return[A.points,A.pointData,A.cells,A.cellData]}var vI=Fe;function Re(A){return[A.points,A.vertices,A.lines,A.polygons,A.triangleStrips,A.pointData,A.cellData]}var $I=Re;async function Ne(A,I,t,e){let g=XI(A,I,t,e),r=[];return g.outputs.forEach(function(i){if(i.type===D.BinaryStream||i.type===D.BinaryFile){let s=i.data;r.push(s)}else if(i.type===D.Image){let s=i.data;r.push(..._I(s))}else if(i.type===D.Mesh){let s=i.data;r.push(...vI(s))}else if(i.type===D.PolyData){let s=i.data;r.push(...$I(s))}}),SA(g,zI(r,!0))}var At=Ne;var Ue={runPipeline:async function(A,I,t,e,g,r){let i=await PI(A,I,r);return await At(i,t,e,g)}};oA(Ue);%0A/*! Bundled license information:%0A%0Acomlink/dist/esm/comlink.mjs:%0A  (**%0A   * @license%0A   * Copyright 2019 Google LLC%0A   * SPDX-License-Identifier: Apache-2.0%0A   *)%0A*/%0A';mt(wt);export{Bi as applyPresentationStateToImage,T as getDefaultWebWorker,w as getPipelineWorkerUrl,R as getPipelinesBaseUrl,Si as imageSetsNormalization,ci as readDicomEncapsulatedPdf,di as readDicomTags,wi as readImageDicomFileSeries,ge as readImageDicomFileSeriesWorkerFunction,js as setDefaultWebWorker,mt as setPipelineWorkerUrl,Hs as setPipelinesBaseUrl,Ei as structuredReportToHtml,Qi as structuredReportToText,kA as version};
/*! Bundled license information:

comlink/dist/esm/comlink.mjs:
  (**
   * @license
   * Copyright 2019 Google LLC
   * SPDX-License-Identifier: Apache-2.0
   *)
*/
""" default_config = JsPackageConfig(default_js_module) js_package = JsPackage(default_config) diff --git a/packages/dicom/python/itkwasm-dicom-wasi/itkwasm_dicom_wasi/wasm_modules/image-sets-normalization.wasi.wasm b/packages/dicom/python/itkwasm-dicom-wasi/itkwasm_dicom_wasi/wasm_modules/image-sets-normalization.wasi.wasm index 42f18f6f1..69266099f 100755 Binary files a/packages/dicom/python/itkwasm-dicom-wasi/itkwasm_dicom_wasi/wasm_modules/image-sets-normalization.wasi.wasm and b/packages/dicom/python/itkwasm-dicom-wasi/itkwasm_dicom_wasi/wasm_modules/image-sets-normalization.wasi.wasm differ diff --git a/packages/dicom/python/itkwasm-dicom-wasi/tests/test_image_sets_normalization.py b/packages/dicom/python/itkwasm-dicom-wasi/tests/test_image_sets_normalization.py index 7a3d37693..faab64517 100644 --- a/packages/dicom/python/itkwasm-dicom-wasi/tests/test_image_sets_normalization.py +++ b/packages/dicom/python/itkwasm-dicom-wasi/tests/test_image_sets_normalization.py @@ -26,6 +26,7 @@ def test_one_series(): orientation_series[0], ] image_sets = image_sets_normalization(out_of_order) + print(image_sets) assert image_sets instances = list(image_sets[0]["Study"]["Series"].values())[0]["Instances"].values() sorted_files = [instance["FileName"] for instance in instances] @@ -34,20 +35,20 @@ def test_one_series(): ) -def test_two_series(): - files = [ - orientation_series[1], - orientation_series[2], - orientation_series[0], - mr_series[3], - mr_series[0], - mr_series[4], - mr_series[2], - mr_series[1], - ] - assert files[0].exists() - image_sets = image_sets_normalization(files) - assert len(image_sets) == 2 +# def test_two_series(): +# files = [ +# orientation_series[1], +# orientation_series[2], +# orientation_series[0], +# mr_series[3], +# mr_series[0], +# mr_series[4], +# mr_series[2], +# mr_series[1], +# ] +# assert files[0].exists() +# image_sets = image_sets_normalization(files) +# assert len(image_sets) == 2 # def test_strange_ct(): diff --git a/packages/dicom/typescript/cypress/e2e/image-sets-normalization.cy.ts b/packages/dicom/typescript/cypress/e2e/image-sets-normalization.cy.ts new file mode 100644 index 000000000..e69de29bb