From 2e88aa5bf003125603079c1df26ce4ab351e340d Mon Sep 17 00:00:00 2001 From: Graham Hukill Date: Wed, 10 Dec 2025 15:49:12 -0500 Subject: [PATCH 1/3] Default exclusion_list_path to None --- transmogrifier/sources/transformer.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/transmogrifier/sources/transformer.py b/transmogrifier/sources/transformer.py index 9a76cf5..9a7f281 100644 --- a/transmogrifier/sources/transformer.py +++ b/transmogrifier/sources/transformer.py @@ -190,7 +190,7 @@ def load( cls, source: str, source_file: str, - exclusion_list_path: str = "", + exclusion_list_path: str | None = None, run_id: str | None = None, run_timestamp: str | None = None, ) -> Transformer: @@ -200,6 +200,7 @@ def load( Args: source: Source repository label. Must match a source key from config.SOURCES. source_file: A file containing source records to be transformed. + exclusion_list_path: CSV filepath to use for explicitly skipping records. run_id: A unique identifier associated with this ETL run. run_timestamp: A timestamp associated with this ETL run. """ From fb64fa620784f94b4ce41f3e17825c91a6c2ceba Mon Sep 17 00:00:00 2001 From: Graham Hukill Date: Wed, 10 Dec 2025 15:53:31 -0500 Subject: [PATCH 2/3] Parse full HTML from mitlibwebsite source records Why these changes are being introduced: Now that browsertrix-harvester is including full HTML + response headers in the source record available to Transmogrifier, we can do two things: 1. Parse metadata for mitlibwebsite TIMDEX records from the original, full HTML in a more opinionated fashion than we could in browsertrix-harvester. 2. Extract good, meaningful full-text from the full HTML to use for the new `fulltext` field. How this addresses that need: Expects a new `html_base64` field in the browsertrix-harvester source records. Uses this to extract metadata and full-text for the record. Side effects of this change: * Full-text is now available in the TIMDEX record for the mitlibwebsite source. * If needed, this HTML parsing could be utilized to extract more granular, source specific metadata in the future. Relevant ticket(s): * https://mitlibraries.atlassian.net/browse/USE-259 --- pyproject.toml | 4 ++ .../mitlibwebsite/mitlibwebsite_records.jsonl | 6 +-- tests/fixtures/mitlibwebsite/website.html | 18 ++++++++ .../website_missing_og_description.html | 16 +++++++ tests/sources/json/test_mitlibwebsite.py | 19 ++++++-- transmogrifier/sources/json/mitlibwebsite.py | 46 +++++++++++++++++-- 6 files changed, 98 insertions(+), 11 deletions(-) create mode 100644 tests/fixtures/mitlibwebsite/website.html create mode 100644 tests/fixtures/mitlibwebsite/website_missing_og_description.html diff --git a/pyproject.toml b/pyproject.toml index f5aab2a..5081712 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,6 +6,10 @@ disallow_untyped_calls = true disallow_untyped_defs = true exclude = ["tests/", "output/"] +[[tool.mypy.overrides]] +module = ["bs4", "bs4.*"] +ignore_missing_imports = true + [tool.pytest.ini_options] log_level = "INFO" diff --git a/tests/fixtures/mitlibwebsite/mitlibwebsite_records.jsonl b/tests/fixtures/mitlibwebsite/mitlibwebsite_records.jsonl index da23a20..ea8f0c8 100644 --- a/tests/fixtures/mitlibwebsite/mitlibwebsite_records.jsonl +++ b/tests/fixtures/mitlibwebsite/mitlibwebsite_records.jsonl @@ -1,3 +1,3 @@ -{"url": "https://libraries.mit.edu/search/", "cdx_warc_filename": "rec-ae2a62f6dc33-gh-test-2025-08-19-lib-website-full-no-depth-20250819202645354-7.warc.gz", "cdx_title": "Search | MIT Libraries", "cdx_offset": "303", "cdx_length": "40258", "og_title": "Search | MIT Libraries", "og_type": "website", "og_image": "https://libraries.mit.edu/app/themes/mitlib-parent/images/mit-libraries-logo-black-yellow-1200-1200.png", "og_url": "https://libraries.mit.edu/search/", "og_image_type": "image/png", "og_image_width": "1200", "og_image_height": "1200", "og_image_alt": "MIT Libraries logo", "og_description": "Use this page to learn about different ways you can search the MIT Libraries’ offerings. Use the Default Quick Search Our Quick Search is the default search on the Libraries’ homepage. This collects results from different library search tools and sorts the results into 4 categories: Books and media Articles and book chapters Archives and manuscript collections Our library website and guides The tool will search the 4 categories and present the top results from each category. It is useful to see the full breadth of what MIT Libraries has on a particular topic or author. Go straight to our […]", "fulltext": null, "fulltext_keywords": "Search,Web of Science,Search Start,Account Search Account,Borrow Direct Request,locations Locations Hours,Citation search Books,Search Hours,Books,articles,Search tools,Search Account Contact,Account Contact Search,Research,Search Search,Collections,Borrow,request,Site search Hours,Locations Hours", "og_site_name": null, "fulltext_50_words": NaN} -{"url": "https://libraries.mit.edu/about7/", "cdx_warc_filename": "rec-ae2a62f6dc33-gh-test-2025-08-19-lib-website-full-no-depth-20250819202645342-4.warc.gz", "cdx_title": "About | MIT Libraries", "cdx_offset": "303", "cdx_length": "38310", "og_title": "About | MIT Libraries", "og_type": "website", "og_image": "https://libraries.mit.edu/app/themes/mitlib-parent/images/mit-libraries-logo-black-yellow-1200-1200.png", "og_url": "https://libraries.mit.edu/about7/", "og_image_type": "image/png", "og_image_width": "1200", "og_image_height": "1200", "og_image_alt": "MIT Libraries logo", "og_description": "Saving the world, bit by bit. Our vision? A world where more people have access to knowledge and more voices are heard. Where tools and solutions can be networked, shared, and “hacked.” Where knowledge not only provides answers, but empowers and inspires. We think libraries can help build this world. Let’s get started. Discover our mission, vision, and values Read the Future of Libraries Task Force Report Envisioning Hayden Library The Libraries are pursuing a renovation of Hayden that reflects our vision for the future of libraries. Learn more Furthering MIT’s mission The final recommendations from the Open Access Task […]", "fulltext": null, "fulltext_keywords": "Web of Science,Collections Books,locations Hours Map,locations Locations Hours,Search Start,Account Search Account,Borrow Direct Request,Search Hours,Search,Site search Hours,Search Account Contact,Distinctive Collections Lewis,Collections Lewis Music,Locations Hours,Research,reserves Borrow Direct,WorldCat Books,Borrow,Books,Databases A-Z JSTOR", "og_site_name": null, "fulltext_50_words": NaN} -{"url": "https://libraries.mit.edu/research-support/", "cdx_warc_filename": "rec-ae2a62f6dc33-gh-test-2025-08-19-lib-website-full-no-depth-20250819202645511-6.warc.gz", "cdx_title": "Research support | MIT Libraries", "cdx_offset": "303", "cdx_length": "37208", "og_title": "Research support | MIT Libraries", "og_type": "website", "og_image": "https://libraries.mit.edu/app/themes/mitlib-parent/images/mit-libraries-logo-black-yellow-1200-1200.png", "og_url": "https://libraries.mit.edu/research-support/", "og_image_type": "image/png", "og_image_width": "1200", "og_image_height": "1200", "og_image_alt": "MIT Libraries logo", "og_description": "Find out where and how to get help for your research or coursework. Expert help Make an appointment for a consult with an expert librarian Research guides: specialized guides for every research interest Not sure where to begin or who to contact? Complete our Ask us email form. Quick help Connect from on & off-campus E-resource troubleshooting Guides for specific classes & programs Writing & publishing help Citing sources & avoiding plagiarism Dissertations/theses: prepare & submit your MIT thesis, or borrow others’  MIT thesis specifications DSpace@MIT: deposit your work to MIT’s repository Scholarly Communication Author identifiers: connect your name with […]", "fulltext": null, "fulltext_keywords": "Web of Science,Collections Books,Search Start,Research,Databases A-Z JSTOR,Distinctive Collections Lewis,Collections Lewis Music,locations Hours Map,Research support,Search,Borrow,Books,Search Hours,Site search Hours,WorldCat Books,locations Locations Hours,Account Search Account,Search Account Contact,request,Borrow Direct Request", "og_site_name": null, "fulltext_50_words": NaN} \ No newline at end of file +{"url": "https://libraries.mit.edu/search/", "status": "active", "cdx_warc_filename": "rec-595f2ddb3156-mitlibwebsite-20251209142416123-6.warc.gz", "cdx_title": "Search | MIT Libraries", "cdx_offset": "3524959", "cdx_length": "40691", "html_base64": "<!DOCTYPE html>
<!--[if lte IE 9]><html class="no-js lte-ie9" lang="en"><![endif]-->
<!--[if !(IE 8) | !(IE 9) ]><!-->
<html lang="en-US" class="no-js">
<!--<![endif]-->
<head>
	<meta charset="UTF-8" /><script type="text/javascript">(window.NREUM||(NREUM={})).init={privacy:{cookies_enabled:true},ajax:{deny_list:["bam.nr-data.net"]},feature_flags:["soft_nav"],distributed_tracing:{enabled:true}};(window.NREUM||(NREUM={})).loader_config={agentID:"594398788",accountID:"3844800",trustKey:"66686",xpid:"Vw4DVV5TCBAFU1lRAwIEV10=",licenseKey:"NRJS-03682cc69c1c5a39583",applicationID:"578343319",browserID:"594398788"};;/*! For license information please see nr-loader-spa-1.303.0.min.js.LICENSE.txt */
(()=>{var e,t,r={384:(e,t,r)=>{"use strict";r.d(t,{NT:()=>s,US:()=>d,Zm:()=>a,bQ:()=>u,dV:()=>c,pV:()=>l});var n=r(6154),i=r(1863),o=r(1910);const s={beacon:"bam.nr-data.net",errorBeacon:"bam.nr-data.net"};function a(){return n.gm.NREUM||(n.gm.NREUM={}),void 0===n.gm.newrelic&&(n.gm.newrelic=n.gm.NREUM),n.gm.NREUM}function c(){let e=a();return e.o||(e.o={ST:n.gm.setTimeout,SI:n.gm.setImmediate||n.gm.setInterval,CT:n.gm.clearTimeout,XHR:n.gm.XMLHttpRequest,REQ:n.gm.Request,EV:n.gm.Event,PR:n.gm.Promise,MO:n.gm.MutationObserver,FETCH:n.gm.fetch,WS:n.gm.WebSocket},(0,o.i)(...Object.values(e.o))),e}function u(e,t){let r=a();r.initializedAgents??={},t.initializedAt={ms:(0,i.t)(),date:new Date},r.initializedAgents[e]=t}function d(e,t){a()[e]=t}function l(){return function(){let e=a();const t=e.info||{};e.info={beacon:s.beacon,errorBeacon:s.errorBeacon,...t}}(),function(){let e=a();const t=e.init||{};e.init={...t}}(),c(),function(){let e=a();const t=e.loader_config||{};e.loader_config={...t}}(),a()}},782:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.pageViewTiming},860:(e,t,r)=>{"use strict";r.d(t,{$J:()=>d,K7:()=>c,P3:()=>u,XX:()=>i,Yy:()=>a,df:()=>o,qY:()=>n,v4:()=>s});const n="events",i="jserrors",o="browser/blobs",s="rum",a="browser/logs",c={ajax:"ajax",genericEvents:"generic_events",jserrors:i,logging:"logging",metrics:"metrics",pageAction:"page_action",pageViewEvent:"page_view_event",pageViewTiming:"page_view_timing",sessionReplay:"session_replay",sessionTrace:"session_trace",softNav:"soft_navigations",spa:"spa"},u={[c.pageViewEvent]:1,[c.pageViewTiming]:2,[c.metrics]:3,[c.jserrors]:4,[c.spa]:5,[c.ajax]:6,[c.sessionTrace]:7,[c.softNav]:8,[c.sessionReplay]:9,[c.logging]:10,[c.genericEvents]:11},d={[c.pageViewEvent]:s,[c.pageViewTiming]:n,[c.ajax]:n,[c.spa]:n,[c.softNav]:n,[c.metrics]:i,[c.jserrors]:i,[c.sessionTrace]:o,[c.sessionReplay]:o,[c.logging]:a,[c.genericEvents]:"ins"}},944:(e,t,r)=>{"use strict";r.d(t,{R:()=>i});var n=r(3241);function i(e,t){"function"==typeof console.debug&&(console.debug("New Relic Warning: https://github.com/newrelic/newrelic-browser-agent/blob/main/docs/warning-codes.md#".concat(e),t),(0,n.W)({agentIdentifier:null,drained:null,type:"data",name:"warn",feature:"warn",data:{code:e,secondary:t}}))}},993:(e,t,r)=>{"use strict";r.d(t,{A$:()=>o,ET:()=>s,TZ:()=>a,p_:()=>i});var n=r(860);const i={ERROR:"ERROR",WARN:"WARN",INFO:"INFO",DEBUG:"DEBUG",TRACE:"TRACE"},o={OFF:0,ERROR:1,WARN:2,INFO:3,DEBUG:4,TRACE:5},s="log",a=n.K7.logging},1687:(e,t,r)=>{"use strict";r.d(t,{Ak:()=>u,Ze:()=>f,x3:()=>d});var n=r(3241),i=r(7836),o=r(3606),s=r(860),a=r(2646);const c={};function u(e,t){const r={staged:!1,priority:s.P3[t]||0};l(e),c[e].get(t)||c[e].set(t,r)}function d(e,t){e&&c[e]&&(c[e].get(t)&&c[e].delete(t),p(e,t,!1),c[e].size&&h(e))}function l(e){if(!e)throw new Error("agentIdentifier required");c[e]||(c[e]=new Map)}function f(e="",t="feature",r=!1){if(l(e),!e||!c[e].get(t)||r)return p(e,t);c[e].get(t).staged=!0,h(e)}function h(e){const t=Array.from(c[e]);t.every(([e,t])=>t.staged)&&(t.sort((e,t)=>e[1].priority-t[1].priority),t.forEach(([t])=>{c[e].delete(t),p(e,t)}))}function p(e,t,r=!0){const s=e?i.ee.get(e):i.ee,c=o.i.handlers;if(!s.aborted&&s.backlog&&c){if((0,n.W)({agentIdentifier:e,type:"lifecycle",name:"drain",feature:t}),r){const e=s.backlog[t],r=c[t];if(r){for(let t=0;e&&t<e.length;++t)g(e[t],r);Object.entries(r).forEach(([e,t])=>{Object.values(t||{}).forEach(t=>{t[0]?.on&&t[0]?.context()instanceof a.y&&t[0].on(e,t[1])})})}}s.isolatedBacklog||delete c[t],s.backlog[t]=null,s.emit("drain-"+t,[])}}function g(e,t){var r=e[1];Object.values(t[r]||{}).forEach(t=>{var r=e[0];if(t[0]===r){var n=t[1],i=e[3],o=e[2];n.apply(i,o)}})}},1741:(e,t,r)=>{"use strict";r.d(t,{W:()=>o});var n=r(944),i=r(4261);class o{#e(e,...t){if(this[e]!==o.prototype[e])return this[e](...t);(0,n.R)(35,e)}addPageAction(e,t){return this.#e(i.hG,e,t)}register(e){return this.#e(i.eY,e)}recordCustomEvent(e,t){return this.#e(i.fF,e,t)}setPageViewName(e,t){return this.#e(i.Fw,e,t)}setCustomAttribute(e,t,r){return this.#e(i.cD,e,t,r)}noticeError(e,t){return this.#e(i.o5,e,t)}setUserId(e){return this.#e(i.Dl,e)}setApplicationVersion(e){return this.#e(i.nb,e)}setErrorHandler(e){return this.#e(i.bt,e)}addRelease(e,t){return this.#e(i.k6,e,t)}log(e,t){return this.#e(i.$9,e,t)}start(){return this.#e(i.d3)}finished(e){return this.#e(i.BL,e)}recordReplay(){return this.#e(i.CH)}pauseReplay(){return this.#e(i.Tb)}addToTrace(e){return this.#e(i.U2,e)}setCurrentRouteName(e){return this.#e(i.PA,e)}interaction(e){return this.#e(i.dT,e)}wrapLogger(e,t,r){return this.#e(i.Wb,e,t,r)}measure(e,t){return this.#e(i.V1,e,t)}consent(e){return this.#e(i.Pv,e)}}},1863:(e,t,r)=>{"use strict";function n(){return Math.floor(performance.now())}r.d(t,{t:()=>n})},1910:(e,t,r)=>{"use strict";r.d(t,{i:()=>o});var n=r(944);const i=new Map;function o(...e){return e.every(e=>{if(i.has(e))return i.get(e);const t="function"==typeof e&&e.toString().includes("[native code]");return t||(0,n.R)(64,e?.name||e?.toString()),i.set(e,t),t})}},2555:(e,t,r)=>{"use strict";r.d(t,{D:()=>a,f:()=>s});var n=r(384),i=r(8122);const o={beacon:n.NT.beacon,errorBeacon:n.NT.errorBeacon,licenseKey:void 0,applicationID:void 0,sa:void 0,queueTime:void 0,applicationTime:void 0,ttGuid:void 0,user:void 0,account:void 0,product:void 0,extra:void 0,jsAttributes:{},userAttributes:void 0,atts:void 0,transactionName:void 0,tNamePlain:void 0};function s(e){try{return!!e.licenseKey&&!!e.errorBeacon&&!!e.applicationID}catch(e){return!1}}const a=e=>(0,i.a)(e,o)},2614:(e,t,r)=>{"use strict";r.d(t,{BB:()=>s,H3:()=>n,g:()=>u,iL:()=>c,tS:()=>a,uh:()=>i,wk:()=>o});const n="NRBA",i="SESSION",o=144e5,s=18e5,a={STARTED:"session-started",PAUSE:"session-pause",RESET:"session-reset",RESUME:"session-resume",UPDATE:"session-update"},c={SAME_TAB:"same-tab",CROSS_TAB:"cross-tab"},u={OFF:0,FULL:1,ERROR:2}},2646:(e,t,r)=>{"use strict";r.d(t,{y:()=>n});class n{constructor(e){this.contextId=e}}},2843:(e,t,r)=>{"use strict";r.d(t,{u:()=>i});var n=r(3878);function i(e,t=!1,r,i){(0,n.DD)("visibilitychange",function(){if(t)return void("hidden"===document.visibilityState&&e());e(document.visibilityState)},r,i)}},3241:(e,t,r)=>{"use strict";r.d(t,{W:()=>o});var n=r(6154);const i="newrelic";function o(e={}){try{n.gm.dispatchEvent(new CustomEvent(i,{detail:e}))}catch(e){}}},3304:(e,t,r)=>{"use strict";r.d(t,{A:()=>o});var n=r(7836);const i=()=>{const e=new WeakSet;return(t,r)=>{if("object"==typeof r&&null!==r){if(e.has(r))return;e.add(r)}return r}};function o(e){try{return JSON.stringify(e,i())??""}catch(e){try{n.ee.emit("internal-error",[e])}catch(e){}return""}}},3333:(e,t,r)=>{"use strict";r.d(t,{$v:()=>d,TZ:()=>n,Xh:()=>c,Zp:()=>i,kd:()=>u,mq:()=>a,nf:()=>s,qN:()=>o});const n=r(860).K7.genericEvents,i=["auxclick","click","copy","keydown","paste","scrollend"],o=["focus","blur"],s=4,a=1e3,c=2e3,u=["PageAction","UserAction","BrowserPerformance"],d={RESOURCES:"experimental.resources",REGISTER:"register"}},3434:(e,t,r)=>{"use strict";r.d(t,{Jt:()=>o,YM:()=>u});var n=r(7836),i=r(5607);const o="nr@original:".concat(i.W),s=50;var a=Object.prototype.hasOwnProperty,c=!1;function u(e,t){return e||(e=n.ee),r.inPlace=function(e,t,n,i,o){n||(n="");const s="-"===n.charAt(0);for(let a=0;a<t.length;a++){const c=t[a],u=e[c];l(u)||(e[c]=r(u,s?c+n:n,i,c,o))}},r.flag=o,r;function r(t,r,n,c,u){return l(t)?t:(r||(r=""),nrWrapper[o]=t,function(e,t,r){if(Object.defineProperty&&Object.keys)try{return Object.keys(e).forEach(function(r){Object.defineProperty(t,r,{get:function(){return e[r]},set:function(t){return e[r]=t,t}})}),t}catch(e){d([e],r)}for(var n in e)a.call(e,n)&&(t[n]=e[n])}(t,nrWrapper,e),nrWrapper);function nrWrapper(){var o,a,l,f;let h;try{a=this,o=[...arguments],l="function"==typeof n?n(o,a):n||{}}catch(t){d([t,"",[o,a,c],l],e)}i(r+"start",[o,a,c],l,u);const p=performance.now();let g;try{return f=t.apply(a,o),g=performance.now(),f}catch(e){throw g=performance.now(),i(r+"err",[o,a,e],l,u),h=e,h}finally{const e=g-p,t={start:p,end:g,duration:e,isLongTask:e>=s,methodName:c,thrownError:h};t.isLongTask&&i("long-task",[t,a],l,u),i(r+"end",[o,a,f],l,u)}}}function i(r,n,i,o){if(!c||t){var s=c;c=!0;try{e.emit(r,n,i,t,o)}catch(t){d([t,r,n,i],e)}c=s}}}function d(e,t){t||(t=n.ee);try{t.emit("internal-error",e)}catch(e){}}function l(e){return!(e&&"function"==typeof e&&e.apply&&!e[o])}},3606:(e,t,r)=>{"use strict";r.d(t,{i:()=>o});var n=r(9908);o.on=s;var i=o.handlers={};function o(e,t,r,o){s(o||n.d,i,e,t,r)}function s(e,t,r,i,o){o||(o="feature"),e||(e=n.d);var s=t[o]=t[o]||{};(s[r]=s[r]||[]).push([e,i])}},3738:(e,t,r)=>{"use strict";r.d(t,{He:()=>i,Kp:()=>a,Lc:()=>u,Rz:()=>d,TZ:()=>n,bD:()=>o,d3:()=>s,jx:()=>l,sl:()=>f,uP:()=>c});const n=r(860).K7.sessionTrace,i="bstResource",o="resource",s="-start",a="-end",c="fn"+s,u="fn"+a,d="pushState",l=1e3,f=3e4},3785:(e,t,r)=>{"use strict";r.d(t,{R:()=>c,b:()=>u});var n=r(9908),i=r(1863),o=r(860),s=r(8154),a=r(993);function c(e,t,r={},c=a.p_.INFO,u,d=(0,i.t)()){(0,n.p)(s.xV,["API/logging/".concat(c.toLowerCase(),"/called")],void 0,o.K7.metrics,e),(0,n.p)(a.ET,[d,t,r,c,u],void 0,o.K7.logging,e)}function u(e){return"string"==typeof e&&Object.values(a.p_).some(t=>t===e.toUpperCase().trim())}},3878:(e,t,r)=>{"use strict";function n(e,t){return{capture:e,passive:!1,signal:t}}function i(e,t,r=!1,i){window.addEventListener(e,t,n(r,i))}function o(e,t,r=!1,i){document.addEventListener(e,t,n(r,i))}r.d(t,{DD:()=>o,jT:()=>n,sp:()=>i})},3962:(e,t,r)=>{"use strict";r.d(t,{AM:()=>s,O2:()=>l,OV:()=>o,Qu:()=>f,TZ:()=>c,ih:()=>h,pP:()=>a,t1:()=>d,tC:()=>i,wD:()=>u});var n=r(860);const i=["click","keydown","submit"],o="popstate",s="api",a="initialPageLoad",c=n.K7.softNav,u=5e3,d=500,l={INITIAL_PAGE_LOAD:"",ROUTE_CHANGE:1,UNSPECIFIED:2},f={INTERACTION:1,AJAX:2,CUSTOM_END:3,CUSTOM_TRACER:4},h={IP:"in progress",PF:"pending finish",FIN:"finished",CAN:"cancelled"}},4234:(e,t,r)=>{"use strict";r.d(t,{W:()=>o});var n=r(7836),i=r(1687);class o{constructor(e,t){this.agentIdentifier=e,this.ee=n.ee.get(e),this.featureName=t,this.blocked=!1}deregisterDrain(){(0,i.x3)(this.agentIdentifier,this.featureName)}}},4261:(e,t,r)=>{"use strict";r.d(t,{$9:()=>d,BL:()=>c,CH:()=>p,Dl:()=>R,Fw:()=>w,PA:()=>v,Pl:()=>n,Pv:()=>A,Tb:()=>f,U2:()=>s,V1:()=>E,Wb:()=>T,bt:()=>y,cD:()=>b,d3:()=>x,dT:()=>u,eY:()=>g,fF:()=>h,hG:()=>o,hw:()=>i,k6:()=>a,nb:()=>m,o5:()=>l});const n="api-",i=n+"ixn-",o="addPageAction",s="addToTrace",a="addRelease",c="finished",u="interaction",d="log",l="noticeError",f="pauseReplay",h="recordCustomEvent",p="recordReplay",g="register",m="setApplicationVersion",v="setCurrentRouteName",b="setCustomAttribute",y="setErrorHandler",w="setPageViewName",R="setUserId",x="start",T="wrapLogger",E="measure",A="consent"},4387:(e,t,r)=>{"use strict";function n(e={}){return!(!e.id||!e.name)}function i(e){return"string"==typeof e&&e.trim().length<501||"number"==typeof e}function o(e,t){if(2!==t?.harvestEndpointVersion)return{};const r=t.agentRef.runtime.appMetadata.agents[0].entityGuid;return n(e)?{"mfe.id":e.id,"mfe.name":e.name,eventSource:e.eventSource,"parent.id":e.parent?.id||r}:{"entity.guid":r,appId:t.agentRef.info.applicationID}}r.d(t,{Ux:()=>o,c7:()=>n,yo:()=>i})},5205:(e,t,r)=>{"use strict";r.d(t,{j:()=>_});var n=r(384),i=r(1741);var o=r(2555),s=r(3333);const a=e=>{if(!e||"string"!=typeof e)return!1;try{document.createDocumentFragment().querySelector(e)}catch{return!1}return!0};var c=r(2614),u=r(944),d=r(8122);const l="[data-nr-mask]",f=e=>(0,d.a)(e,(()=>{const e={feature_flags:[],experimental:{allow_registered_children:!1,resources:!1},mask_selector:"*",block_selector:"[data-nr-block]",mask_input_options:{color:!1,date:!1,"datetime-local":!1,email:!1,month:!1,number:!1,range:!1,search:!1,tel:!1,text:!1,time:!1,url:!1,week:!1,textarea:!1,select:!1,password:!0}};return{ajax:{deny_list:void 0,block_internal:!0,enabled:!0,autoStart:!0},api:{get allow_registered_children(){return e.feature_flags.includes(s.$v.REGISTER)||e.experimental.allow_registered_children},set allow_registered_children(t){e.experimental.allow_registered_children=t},duplicate_registered_data:!1},browser_consent_mode:{enabled:!1},distributed_tracing:{enabled:void 0,exclude_newrelic_header:void 0,cors_use_newrelic_header:void 0,cors_use_tracecontext_headers:void 0,allowed_origins:void 0},get feature_flags(){return e.feature_flags},set feature_flags(t){e.feature_flags=t},generic_events:{enabled:!0,autoStart:!0},harvest:{interval:30},jserrors:{enabled:!0,autoStart:!0},logging:{enabled:!0,autoStart:!0},metrics:{enabled:!0,autoStart:!0},obfuscate:void 0,page_action:{enabled:!0},page_view_event:{enabled:!0,autoStart:!0},page_view_timing:{enabled:!0,autoStart:!0},performance:{capture_marks:!1,capture_measures:!1,capture_detail:!0,resources:{get enabled(){return e.feature_flags.includes(s.$v.RESOURCES)||e.experimental.resources},set enabled(t){e.experimental.resources=t},asset_types:[],first_party_domains:[],ignore_newrelic:!0}},privacy:{cookies_enabled:!0},proxy:{assets:void 0,beacon:void 0},session:{expiresMs:c.wk,inactiveMs:c.BB},session_replay:{autoStart:!0,enabled:!1,preload:!1,sampling_rate:10,error_sampling_rate:100,collect_fonts:!1,inline_images:!1,fix_stylesheets:!0,mask_all_inputs:!0,get mask_text_selector(){return e.mask_selector},set mask_text_selector(t){a(t)?e.mask_selector="".concat(t,",").concat(l):""===t||null===t?e.mask_selector=l:(0,u.R)(5,t)},get block_class(){return"nr-block"},get ignore_class(){return"nr-ignore"},get mask_text_class(){return"nr-mask"},get block_selector(){return e.block_selector},set block_selector(t){a(t)?e.block_selector+=",".concat(t):""!==t&&(0,u.R)(6,t)},get mask_input_options(){return e.mask_input_options},set mask_input_options(t){t&&"object"==typeof t?e.mask_input_options={...t,password:!0}:(0,u.R)(7,t)}},session_trace:{enabled:!0,autoStart:!0},soft_navigations:{enabled:!0,autoStart:!0},spa:{enabled:!0,autoStart:!0},ssl:void 0,user_actions:{enabled:!0,elementAttributes:["id","className","tagName","type"]}}})());var h=r(6154),p=r(9324);let g=0;const m={buildEnv:p.F3,distMethod:p.Xs,version:p.xv,originTime:h.WN},v={consented:!1},b={appMetadata:{},get consented(){return this.session?.state?.consent||v.consented},set consented(e){v.consented=e},customTransaction:void 0,denyList:void 0,disabled:!1,harvester:void 0,isolatedBacklog:!1,isRecording:!1,loaderType:void 0,maxBytes:3e4,obfuscator:void 0,onerror:void 0,ptid:void 0,releaseIds:{},session:void 0,timeKeeper:void 0,registeredEntities:[],jsAttributesMetadata:{bytes:0},get harvestCount(){return++g}},y=e=>{const t=(0,d.a)(e,b),r=Object.keys(m).reduce((e,t)=>(e[t]={value:m[t],writable:!1,configurable:!0,enumerable:!0},e),{});return Object.defineProperties(t,r)};var w=r(5701);const R=e=>{const t=e.startsWith("http");e+="/",r.p=t?e:"https://"+e};var x=r(7836),T=r(3241);const E={accountID:void 0,trustKey:void 0,agentID:void 0,licenseKey:void 0,applicationID:void 0,xpid:void 0},A=e=>(0,d.a)(e,E),S=new Set;function _(e,t={},r,s){let{init:a,info:c,loader_config:u,runtime:d={},exposed:l=!0}=t;if(!c){const e=(0,n.pV)();a=e.init,c=e.info,u=e.loader_config}e.init=f(a||{}),e.loader_config=A(u||{}),c.jsAttributes??={},h.bv&&(c.jsAttributes.isWorker=!0),e.info=(0,o.D)(c);const p=e.init,g=[c.beacon,c.errorBeacon];S.has(e.agentIdentifier)||(p.proxy.assets&&(R(p.proxy.assets),g.push(p.proxy.assets)),p.proxy.beacon&&g.push(p.proxy.beacon),e.beacons=[...g],function(e){const t=(0,n.pV)();Object.getOwnPropertyNames(i.W.prototype).forEach(r=>{const n=i.W.prototype[r];if("function"!=typeof n||"constructor"===n)return;let o=t[r];e[r]&&!1!==e.exposed&&"micro-agent"!==e.runtime?.loaderType&&(t[r]=(...t)=>{const n=e[r](...t);return o?o(...t):n})})}(e),(0,n.US)("activatedFeatures",w.B),e.runSoftNavOverSpa&&=!0===p.soft_navigations.enabled&&p.feature_flags.includes("soft_nav")),d.denyList=[...p.ajax.deny_list||[],...p.ajax.block_internal?g:[]],d.ptid=e.agentIdentifier,d.loaderType=r,e.runtime=y(d),S.has(e.agentIdentifier)||(e.ee=x.ee.get(e.agentIdentifier),e.exposed=l,(0,T.W)({agentIdentifier:e.agentIdentifier,drained:!!w.B?.[e.agentIdentifier],type:"lifecycle",name:"initialize",feature:void 0,data:e.config})),S.add(e.agentIdentifier)}},5270:(e,t,r)=>{"use strict";r.d(t,{Aw:()=>s,SR:()=>o,rF:()=>a});var n=r(384),i=r(7767);function o(e){return!!(0,n.dV)().o.MO&&(0,i.V)(e)&&!0===e?.session_trace.enabled}function s(e){return!0===e?.session_replay.preload&&o(e)}function a(e,t){try{if("string"==typeof t?.type){if("password"===t.type.toLowerCase())return"*".repeat(e?.length||0);if(void 0!==t?.dataset?.nrUnmask||t?.classList?.contains("nr-unmask"))return e}}catch(e){}return"string"==typeof e?e.replace(/[\S]/g,"*"):"*".repeat(e?.length||0)}},5289:(e,t,r)=>{"use strict";r.d(t,{GG:()=>o,Qr:()=>a,sB:()=>s});var n=r(3878);function i(){return"undefined"==typeof document||"complete"===document.readyState}function o(e,t){if(i())return e();(0,n.sp)("load",e,t)}function s(e){if(i())return e();(0,n.DD)("DOMContentLoaded",e)}function a(e){if(i())return e();(0,n.sp)("popstate",e)}},5607:(e,t,r)=>{"use strict";r.d(t,{W:()=>n});const n=(0,r(9566).bz)()},5701:(e,t,r)=>{"use strict";r.d(t,{B:()=>o,t:()=>s});var n=r(3241);const i=new Set,o={};function s(e,t){const r=t.agentIdentifier;o[r]??={},e&&"object"==typeof e&&(i.has(r)||(t.ee.emit("rumresp",[e]),o[r]=e,i.add(r),(0,n.W)({agentIdentifier:r,loaded:!0,drained:!0,type:"lifecycle",name:"load",feature:void 0,data:e})))}},6154:(e,t,r)=>{"use strict";r.d(t,{A4:()=>a,OF:()=>d,RI:()=>i,WN:()=>h,bv:()=>o,gm:()=>s,lR:()=>f,m:()=>u,mw:()=>c,sb:()=>l});var n=r(1863);const i="undefined"!=typeof window&&!!window.document,o="undefined"!=typeof WorkerGlobalScope&&("undefined"!=typeof self&&self instanceof WorkerGlobalScope&&self.navigator instanceof WorkerNavigator||"undefined"!=typeof globalThis&&globalThis instanceof WorkerGlobalScope&&globalThis.navigator instanceof WorkerNavigator),s=i?window:"undefined"!=typeof WorkerGlobalScope&&("undefined"!=typeof self&&self instanceof WorkerGlobalScope&&self||"undefined"!=typeof globalThis&&globalThis instanceof WorkerGlobalScope&&globalThis),a="complete"===s?.document?.readyState,c=Boolean("hidden"===s?.document?.visibilityState),u=""+s?.location,d=/iPad|iPhone|iPod/.test(s.navigator?.userAgent),l=d&&"undefined"==typeof SharedWorker,f=(()=>{const e=s.navigator?.userAgent?.match(/Firefox[/\s](\d+\.\d+)/);return Array.isArray(e)&&e.length>=2?+e[1]:0})(),h=Date.now()-(0,n.t)()},6344:(e,t,r)=>{"use strict";r.d(t,{BB:()=>d,Qb:()=>l,TZ:()=>i,Ug:()=>s,Vh:()=>o,_s:()=>a,bc:()=>u,yP:()=>c});var n=r(2614);const i=r(860).K7.sessionReplay,o="errorDuringReplay",s=.12,a={DomContentLoaded:0,Load:1,FullSnapshot:2,IncrementalSnapshot:3,Meta:4,Custom:5},c={[n.g.ERROR]:15e3,[n.g.FULL]:3e5,[n.g.OFF]:0},u={RESET:{message:"Session was reset",sm:"Reset"},IMPORT:{message:"Recorder failed to import",sm:"Import"},TOO_MANY:{message:"429: Too Many Requests",sm:"Too-Many"},TOO_BIG:{message:"Payload was too large",sm:"Too-Big"},CROSS_TAB:{message:"Session Entity was set to OFF on another tab",sm:"Cross-Tab"},ENTITLEMENTS:{message:"Session Replay is not allowed and will not be started",sm:"Entitlement"}},d=5e3,l={API:"api",RESUME:"resume",SWITCH_TO_FULL:"switchToFull",INITIALIZE:"initialize",PRELOAD:"preload"}},6389:(e,t,r)=>{"use strict";function n(e,t=500,r={}){const n=r?.leading||!1;let i;return(...r)=>{n&&void 0===i&&(e.apply(this,r),i=setTimeout(()=>{i=clearTimeout(i)},t)),n||(clearTimeout(i),i=setTimeout(()=>{e.apply(this,r)},t))}}function i(e){let t=!1;return(...r)=>{t||(t=!0,e.apply(this,r))}}r.d(t,{J:()=>i,s:()=>n})},6630:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.pageViewEvent},6774:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.jserrors},7295:(e,t,r)=>{"use strict";r.d(t,{Xv:()=>s,gX:()=>i,iW:()=>o});var n=[];function i(e){if(!e||o(e))return!1;if(0===n.length)return!0;for(var t=0;t<n.length;t++){var r=n[t];if("*"===r.hostname)return!1;if(a(r.hostname,e.hostname)&&c(r.pathname,e.pathname))return!1}return!0}function o(e){return void 0===e.hostname}function s(e){if(n=[],e&&e.length)for(var t=0;t<e.length;t++){let r=e[t];if(!r)continue;0===r.indexOf("http://")?r=r.substring(7):0===r.indexOf("https://")&&(r=r.substring(8));const i=r.indexOf("/");let o,s;i>0?(o=r.substring(0,i),s=r.substring(i)):(o=r,s="");let[a]=o.split(":");n.push({hostname:a,pathname:s})}}function a(e,t){return!(e.length>t.length)&&t.indexOf(e)===t.length-e.length}function c(e,t){return 0===e.indexOf("/")&&(e=e.substring(1)),0===t.indexOf("/")&&(t=t.substring(1)),""===e||e===t}},7378:(e,t,r)=>{"use strict";r.d(t,{$p:()=>x,BR:()=>b,Kp:()=>R,L3:()=>y,Lc:()=>c,NC:()=>o,SG:()=>d,TZ:()=>i,U6:()=>p,UT:()=>m,d3:()=>w,dT:()=>f,e5:()=>E,gx:()=>v,l9:()=>l,oW:()=>h,op:()=>g,rw:()=>u,tH:()=>A,uP:()=>a,wW:()=>T,xq:()=>s});var n=r(384);const i=r(860).K7.spa,o=["click","submit","keypress","keydown","keyup","change"],s=999,a="fn-start",c="fn-end",u="cb-start",d="api-ixn-",l="remaining",f="interaction",h="spaNode",p="jsonpNode",g="fetch-start",m="fetch-done",v="fetch-body-",b="jsonp-end",y=(0,n.dV)().o.ST,w="-start",R="-end",x="-body",T="cb"+R,E="jsTime",A="fetch"},7485:(e,t,r)=>{"use strict";r.d(t,{D:()=>i});var n=r(6154);function i(e){if(0===(e||"").indexOf("data:"))return{protocol:"data"};try{const t=new URL(e,location.href),r={port:t.port,hostname:t.hostname,pathname:t.pathname,search:t.search,protocol:t.protocol.slice(0,t.protocol.indexOf(":")),sameOrigin:t.protocol===n.gm?.location?.protocol&&t.host===n.gm?.location?.host};return r.port&&""!==r.port||("http:"===t.protocol&&(r.port="80"),"https:"===t.protocol&&(r.port="443")),r.pathname&&""!==r.pathname?r.pathname.startsWith("/")||(r.pathname="/".concat(r.pathname)):r.pathname="/",r}catch(e){return{}}}},7699:(e,t,r)=>{"use strict";r.d(t,{It:()=>o,KC:()=>a,No:()=>i,qh:()=>s});var n=r(860);const i=16e3,o=1e6,s="SESSION_ERROR",a={[n.K7.logging]:!0,[n.K7.genericEvents]:!1,[n.K7.jserrors]:!1,[n.K7.ajax]:!1}},7767:(e,t,r)=>{"use strict";r.d(t,{V:()=>i});var n=r(6154);const i=e=>n.RI&&!0===e?.privacy.cookies_enabled},7836:(e,t,r)=>{"use strict";r.d(t,{P:()=>a,ee:()=>c});var n=r(384),i=r(8990),o=r(2646),s=r(5607);const a="nr@context:".concat(s.W),c=function e(t,r){var n={},s={},d={},l=!1;try{l=16===r.length&&u.initializedAgents?.[r]?.runtime.isolatedBacklog}catch(e){}var f={on:p,addEventListener:p,removeEventListener:function(e,t){var r=n[e];if(!r)return;for(var i=0;i<r.length;i++)r[i]===t&&r.splice(i,1)},emit:function(e,r,n,i,o){!1!==o&&(o=!0);if(c.aborted&&!i)return;t&&o&&t.emit(e,r,n);var a=h(n);g(e).forEach(e=>{e.apply(a,r)});var u=v()[s[e]];u&&u.push([f,e,r,a]);return a},get:m,listeners:g,context:h,buffer:function(e,t){const r=v();if(t=t||"feature",f.aborted)return;Object.entries(e||{}).forEach(([e,n])=>{s[n]=t,t in r||(r[t]=[])})},abort:function(){f._aborted=!0,Object.keys(f.backlog).forEach(e=>{delete f.backlog[e]})},isBuffering:function(e){return!!v()[s[e]]},debugId:r,backlog:l?{}:t&&"object"==typeof t.backlog?t.backlog:{},isolatedBacklog:l};return Object.defineProperty(f,"aborted",{get:()=>{let e=f._aborted||!1;return e||(t&&(e=t.aborted),e)}}),f;function h(e){return e&&e instanceof o.y?e:e?(0,i.I)(e,a,()=>new o.y(a)):new o.y(a)}function p(e,t){n[e]=g(e).concat(t)}function g(e){return n[e]||[]}function m(t){return d[t]=d[t]||e(f,t)}function v(){return f.backlog}}(void 0,"globalEE"),u=(0,n.Zm)();u.ee||(u.ee=c)},8122:(e,t,r)=>{"use strict";r.d(t,{a:()=>i});var n=r(944);function i(e,t){try{if(!e||"object"!=typeof e)return(0,n.R)(3);if(!t||"object"!=typeof t)return(0,n.R)(4);const r=Object.create(Object.getPrototypeOf(t),Object.getOwnPropertyDescriptors(t)),o=0===Object.keys(r).length?e:r;for(let s in o)if(void 0!==e[s])try{if(null===e[s]){r[s]=null;continue}Array.isArray(e[s])&&Array.isArray(t[s])?r[s]=Array.from(new Set([...e[s],...t[s]])):"object"==typeof e[s]&&"object"==typeof t[s]?r[s]=i(e[s],t[s]):r[s]=e[s]}catch(e){r[s]||(0,n.R)(1,e)}return r}catch(e){(0,n.R)(2,e)}}},8139:(e,t,r)=>{"use strict";r.d(t,{u:()=>f});var n=r(7836),i=r(3434),o=r(8990),s=r(6154);const a={},c=s.gm.XMLHttpRequest,u="addEventListener",d="removeEventListener",l="nr@wrapped:".concat(n.P);function f(e){var t=function(e){return(e||n.ee).get("events")}(e);if(a[t.debugId]++)return t;a[t.debugId]=1;var r=(0,i.YM)(t,!0);function f(e){r.inPlace(e,[u,d],"-",p)}function p(e,t){return e[1]}return"getPrototypeOf"in Object&&(s.RI&&h(document,f),c&&h(c.prototype,f),h(s.gm,f)),t.on(u+"-start",function(e,t){var n=e[1];if(null!==n&&("function"==typeof n||"object"==typeof n)&&"newrelic"!==e[0]){var i=(0,o.I)(n,l,function(){var e={object:function(){if("function"!=typeof n.handleEvent)return;return n.handleEvent.apply(n,arguments)},function:n}[typeof n];return e?r(e,"fn-",null,e.name||"anonymous"):n});this.wrapped=e[1]=i}}),t.on(d+"-start",function(e){e[1]=this.wrapped||e[1]}),t}function h(e,t,...r){let n=e;for(;"object"==typeof n&&!Object.prototype.hasOwnProperty.call(n,u);)n=Object.getPrototypeOf(n);n&&t(n,...r)}},8154:(e,t,r)=>{"use strict";r.d(t,{z_:()=>o,XG:()=>a,TZ:()=>n,rs:()=>i,xV:()=>s});r(6154),r(9566),r(384);const n=r(860).K7.metrics,i="sm",o="cm",s="storeSupportabilityMetrics",a="storeEventMetrics"},8374:(e,t,r)=>{r.nc=(()=>{try{return document?.currentScript?.nonce}catch(e){}return""})()},8990:(e,t,r)=>{"use strict";r.d(t,{I:()=>i});var n=Object.prototype.hasOwnProperty;function i(e,t,r){if(n.call(e,t))return e[t];var i=r();if(Object.defineProperty&&Object.keys)try{return Object.defineProperty(e,t,{value:i,writable:!0,enumerable:!1}),i}catch(e){}return e[t]=i,i}},9300:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.ajax},9324:(e,t,r)=>{"use strict";r.d(t,{AJ:()=>s,F3:()=>i,Xs:()=>o,Yq:()=>a,xv:()=>n});const n="1.303.0",i="PROD",o="CDN",s="@newrelic/rrweb",a="1.0.1"},9566:(e,t,r)=>{"use strict";r.d(t,{LA:()=>a,ZF:()=>c,bz:()=>s,el:()=>u});var n=r(6154);const i="xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";function o(e,t){return e?15&e[t]:16*Math.random()|0}function s(){const e=n.gm?.crypto||n.gm?.msCrypto;let t,r=0;return e&&e.getRandomValues&&(t=e.getRandomValues(new Uint8Array(30))),i.split("").map(e=>"x"===e?o(t,r++).toString(16):"y"===e?(3&o()|8).toString(16):e).join("")}function a(e){const t=n.gm?.crypto||n.gm?.msCrypto;let r,i=0;t&&t.getRandomValues&&(r=t.getRandomValues(new Uint8Array(e)));const s=[];for(var a=0;a<e;a++)s.push(o(r,i++).toString(16));return s.join("")}function c(){return a(16)}function u(){return a(32)}},9908:(e,t,r)=>{"use strict";r.d(t,{d:()=>n,p:()=>i});var n=r(7836).ee.get("handle");function i(e,t,r,i,o){o?(o.buffer([e],i),o.emit(e,t,r)):(n.buffer([e],i),n.emit(e,t,r))}}},n={};function i(e){var t=n[e];if(void 0!==t)return t.exports;var o=n[e]={exports:{}};return r[e](o,o.exports,i),o.exports}i.m=r,i.d=(e,t)=>{for(var r in t)i.o(t,r)&&!i.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},i.f={},i.e=e=>Promise.all(Object.keys(i.f).reduce((t,r)=>(i.f[r](e,t),t),[])),i.u=e=>({212:"nr-spa-compressor",249:"nr-spa-recorder",478:"nr-spa"}[e]+"-1.303.0.min.js"),i.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),e={},t="NRBA-1.303.0.PROD:",i.l=(r,n,o,s)=>{if(e[r])e[r].push(n);else{var a,c;if(void 0!==o)for(var u=document.getElementsByTagName("script"),d=0;d<u.length;d++){var l=u[d];if(l.getAttribute("src")==r||l.getAttribute("data-webpack")==t+o){a=l;break}}if(!a){c=!0;var f={478:"sha512-Q1pLqcoiNmLHv0rtq3wFkJBA3kofBdRJl0ExDl0mTuAoCBd0qe/1J0XWrDlQKuNlUryL6aZfVkAMPLmoikWIoQ==",249:"sha512-695ZzudsxlMtHKnpDNvkMlJd3tdMtY03IQKVCw9SX12tjUC+f7Nrx5tnWO72Vg9RFf6DSY6wVmM3cEkRM12kkQ==",212:"sha512-18Gx1wIBsppcn0AnKFhwgw4IciNgFxiw3J74W393Ape+wtg4hlg7t6SBKsIE/Dk/tfl2yltgcgBFvYRs283AFg=="};(a=document.createElement("script")).charset="utf-8",i.nc&&a.setAttribute("nonce",i.nc),a.setAttribute("data-webpack",t+o),a.src=r,0!==a.src.indexOf(window.location.origin+"/")&&(a.crossOrigin="anonymous"),f[s]&&(a.integrity=f[s])}e[r]=[n];var h=(t,n)=>{a.onerror=a.onload=null,clearTimeout(p);var i=e[r];if(delete e[r],a.parentNode&&a.parentNode.removeChild(a),i&&i.forEach(e=>e(n)),t)return t(n)},p=setTimeout(h.bind(null,void 0,{type:"timeout",target:a}),12e4);a.onerror=h.bind(null,a.onerror),a.onload=h.bind(null,a.onload),c&&document.head.appendChild(a)}},i.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},i.p="https://js-agent.newrelic.com/",(()=>{var e={38:0,788:0};i.f.j=(t,r)=>{var n=i.o(e,t)?e[t]:void 0;if(0!==n)if(n)r.push(n[2]);else{var o=new Promise((r,i)=>n=e[t]=[r,i]);r.push(n[2]=o);var s=i.p+i.u(t),a=new Error;i.l(s,r=>{if(i.o(e,t)&&(0!==(n=e[t])&&(e[t]=void 0),n)){var o=r&&("load"===r.type?"missing":r.type),s=r&&r.target&&r.target.src;a.message="Loading chunk "+t+" failed.\n("+o+": "+s+")",a.name="ChunkLoadError",a.type=o,a.request=s,n[1](a)}},"chunk-"+t,t)}};var t=(t,r)=>{var n,o,[s,a,c]=r,u=0;if(s.some(t=>0!==e[t])){for(n in a)i.o(a,n)&&(i.m[n]=a[n]);if(c)c(i)}for(t&&t(r);u<s.length;u++)o=s[u],i.o(e,o)&&e[o]&&e[o][0](),e[o]=0},r=self["webpackChunk:NRBA-1.303.0.PROD"]=self["webpackChunk:NRBA-1.303.0.PROD"]||[];r.forEach(t.bind(null,0)),r.push=t.bind(null,r.push.bind(r))})(),(()=>{"use strict";i(8374);var e=i(9566),t=i(1741);class r extends t.W{agentIdentifier=(0,e.LA)(16)}var n=i(860);const o=Object.values(n.K7);var s=i(5205);var a=i(9908),c=i(1863),u=i(4261),d=i(3241),l=i(944),f=i(5701),h=i(8154);function p(e,t,i,o){const s=o||i;!s||s[e]&&s[e]!==r.prototype[e]||(s[e]=function(){(0,a.p)(h.xV,["API/"+e+"/called"],void 0,n.K7.metrics,i.ee),(0,d.W)({agentIdentifier:i.agentIdentifier,drained:!!f.B?.[i.agentIdentifier],type:"data",name:"api",feature:u.Pl+e,data:{}});try{return t.apply(this,arguments)}catch(e){(0,l.R)(23,e)}})}function g(e,t,r,n,i){const o=e.info;null===r?delete o.jsAttributes[t]:o.jsAttributes[t]=r,(i||null===r)&&(0,a.p)(u.Pl+n,[(0,c.t)(),t,r],void 0,"session",e.ee)}var m=i(1687),v=i(4234),b=i(5289),y=i(6154),w=i(5270),R=i(7767),x=i(6389),T=i(7699);class E extends v.W{constructor(e,t){super(e.agentIdentifier,t),this.agentRef=e,this.abortHandler=void 0,this.featAggregate=void 0,this.loadedSuccessfully=void 0,this.onAggregateImported=new Promise(e=>{this.loadedSuccessfully=e}),this.deferred=Promise.resolve(),!1===e.init[this.featureName].autoStart?this.deferred=new Promise((t,r)=>{this.ee.on("manual-start-all",(0,x.J)(()=>{(0,m.Ak)(e.agentIdentifier,this.featureName),t()}))}):(0,m.Ak)(e.agentIdentifier,t)}importAggregator(e,t,r={}){if(this.featAggregate)return;const n=async()=>{let n;await this.deferred;try{if((0,R.V)(e.init)){const{setupAgentSession:t}=await i.e(478).then(i.bind(i,8766));n=t(e)}}catch(e){(0,l.R)(20,e),this.ee.emit("internal-error",[e]),(0,a.p)(T.qh,[e],void 0,this.featureName,this.ee)}try{if(!this.#t(this.featureName,n,e.init))return(0,m.Ze)(this.agentIdentifier,this.featureName),void this.loadedSuccessfully(!1);const{Aggregate:i}=await t();this.featAggregate=new i(e,r),e.runtime.harvester.initializedAggregates.push(this.featAggregate),this.loadedSuccessfully(!0)}catch(e){(0,l.R)(34,e),this.abortHandler?.(),(0,m.Ze)(this.agentIdentifier,this.featureName,!0),this.loadedSuccessfully(!1),this.ee&&this.ee.abort()}};y.RI?(0,b.GG)(()=>n(),!0):n()}#t(e,t,r){if(this.blocked)return!1;switch(e){case n.K7.sessionReplay:return(0,w.SR)(r)&&!!t;case n.K7.sessionTrace:return!!t;default:return!0}}}var A=i(6630),S=i(2614);class _ extends E{static featureName=A.T;constructor(e){var t;super(e,A.T),this.setupInspectionEvents(e.agentIdentifier),t=e,p(u.Fw,function(e,r){"string"==typeof e&&("/"!==e.charAt(0)&&(e="/"+e),t.runtime.customTransaction=(r||"http://custom.transaction")+e,(0,a.p)(u.Pl+u.Fw,[(0,c.t)()],void 0,void 0,t.ee))},t),this.importAggregator(e,()=>i.e(478).then(i.bind(i,1983)))}setupInspectionEvents(e){const t=(t,r)=>{t&&(0,d.W)({agentIdentifier:e,timeStamp:t.timeStamp,loaded:"complete"===t.target.readyState,type:"window",name:r,data:t.target.location+""})};(0,b.sB)(e=>{t(e,"DOMContentLoaded")}),(0,b.GG)(e=>{t(e,"load")}),(0,b.Qr)(e=>{t(e,"navigate")}),this.ee.on(S.tS.UPDATE,(t,r)=>{(0,d.W)({agentIdentifier:e,type:"lifecycle",name:"session",data:r})})}}var O=i(384);var N=i(2843),I=i(3878),P=i(782);class j extends E{static featureName=P.T;constructor(e){super(e,P.T),y.RI&&((0,N.u)(()=>(0,a.p)("docHidden",[(0,c.t)()],void 0,P.T,this.ee),!0),(0,I.sp)("pagehide",()=>(0,a.p)("winPagehide",[(0,c.t)()],void 0,P.T,this.ee)),this.importAggregator(e,()=>i.e(478).then(i.bind(i,9917))))}}class k extends E{static featureName=h.TZ;constructor(e){super(e,h.TZ),y.RI&&document.addEventListener("securitypolicyviolation",e=>{(0,a.p)(h.xV,["Generic/CSPViolation/Detected"],void 0,this.featureName,this.ee)}),this.importAggregator(e,()=>i.e(478).then(i.bind(i,6555)))}}var C=i(6774),L=i(3304);class H{constructor(e,t,r,n,i){this.name="UncaughtError",this.message="string"==typeof e?e:(0,L.A)(e),this.sourceURL=t,this.line=r,this.column=n,this.__newrelic=i}}function M(e){return U(e)?e:new H(void 0!==e?.message?e.message:e,e?.filename||e?.sourceURL,e?.lineno||e?.line,e?.colno||e?.col,e?.__newrelic,e?.cause)}function K(e){const t="Unhandled Promise Rejection: ";if(!e?.reason)return;if(U(e.reason)){try{e.reason.message.startsWith(t)||(e.reason.message=t+e.reason.message)}catch(e){}return M(e.reason)}const r=M(e.reason);return(r.message||"").startsWith(t)||(r.message=t+r.message),r}function D(e){if(e.error instanceof SyntaxError&&!/:\d+$/.test(e.error.stack?.trim())){const t=new H(e.message,e.filename,e.lineno,e.colno,e.error.__newrelic,e.cause);return t.name=SyntaxError.name,t}return U(e.error)?e.error:M(e)}function U(e){return e instanceof Error&&!!e.stack}function F(e,t,r,i,o=(0,c.t)()){"string"==typeof e&&(e=new Error(e)),(0,a.p)("err",[e,o,!1,t,r.runtime.isRecording,void 0,i],void 0,n.K7.jserrors,r.ee),(0,a.p)("uaErr",[],void 0,n.K7.genericEvents,r.ee)}var W=i(4387),B=i(993),V=i(3785);function G(e,{customAttributes:t={},level:r=B.p_.INFO}={},n,i,o=(0,c.t)()){(0,V.R)(n.ee,e,t,r,i,o)}function z(e,t,r,i,o=(0,c.t)()){(0,a.p)(u.Pl+u.hG,[o,e,t,i],void 0,n.K7.genericEvents,r.ee)}function Z(e,t,r,i,o=(0,c.t)()){const{start:s,end:d,customAttributes:f}=t||{},h={customAttributes:f||{}};if("object"!=typeof h.customAttributes||"string"!=typeof e||0===e.length)return void(0,l.R)(57);const p=(e,t)=>null==e?t:"number"==typeof e?e:e instanceof PerformanceMark?e.startTime:Number.NaN;if(h.start=p(s,0),h.end=p(d,o),Number.isNaN(h.start)||Number.isNaN(h.end))(0,l.R)(57);else{if(h.duration=h.end-h.start,!(h.duration<0))return(0,a.p)(u.Pl+u.V1,[h,e,i],void 0,n.K7.genericEvents,r.ee),h;(0,l.R)(58)}}function q(e,t={},r,i,o=(0,c.t)()){(0,a.p)(u.Pl+u.fF,[o,e,t,i],void 0,n.K7.genericEvents,r.ee)}function X(e){p(u.eY,function(t){return Y(e,t)},e)}function Y(e,t,r){const i={};(0,l.R)(54,"newrelic.register"),t||={},t.eventSource="MicroFrontendBrowserAgent",t.licenseKey||=e.info.licenseKey,t.blocked=!1,t.parent=r||{};let o=()=>{};const s=e.runtime.registeredEntities,u=s.find(({metadata:{target:{id:e,name:r}}})=>e===t.id);if(u)return u.metadata.target.name!==t.name&&(u.metadata.target.name=t.name),u;const d=e=>{t.blocked=!0,o=e};e.init.api.allow_registered_children||d((0,x.J)(()=>(0,l.R)(55))),(0,W.c7)(t)||d((0,x.J)(()=>(0,l.R)(48,t))),(0,W.yo)(t.id)&&(0,W.yo)(t.name)||d((0,x.J)(()=>(0,l.R)(48,t)));const f={addPageAction:(r,n={})=>m(z,[r,{...i,...n},e],t),log:(r,n={})=>m(G,[r,{...n,customAttributes:{...i,...n.customAttributes||{}}},e],t),measure:(r,n={})=>m(Z,[r,{...n,customAttributes:{...i,...n.customAttributes||{}}},e],t),noticeError:(r,n={})=>m(F,[r,{...i,...n},e],t),register:(t={})=>m(Y,[e,t],f.metadata.target),recordCustomEvent:(r,n={})=>m(q,[r,{...i,...n},e],t),setApplicationVersion:e=>g("application.version",e),setCustomAttribute:(e,t)=>g(e,t),setUserId:e=>g("enduser.id",e),metadata:{customAttributes:i,target:t}},p=()=>(t.blocked&&o(),t.blocked);p()||s.push(f);const g=(e,t)=>{p()||(i[e]=t)},m=(t,r,i)=>{if(p())return;const o=(0,c.t)();(0,a.p)(h.xV,["API/register/".concat(t.name,"/called")],void 0,n.K7.metrics,e.ee);try{return e.init.api.duplicate_registered_data&&"register"!==t.name&&t(...r,void 0,o),t(...r,i,o)}catch(e){(0,l.R)(50,e)}};return f}class J extends E{static featureName=C.T;constructor(e){var t;super(e,C.T),t=e,p(u.o5,(e,r)=>F(e,r,t),t),function(e){p(u.bt,function(t){e.runtime.onerror=t},e)}(e),function(e){let t=0;p(u.k6,function(e,r){++t>10||(this.runtime.releaseIds[e.slice(-200)]=(""+r).slice(-200))},e)}(e),X(e);try{this.removeOnAbort=new AbortController}catch(e){}this.ee.on("internal-error",(t,r)=>{this.abortHandler&&(0,a.p)("ierr",[M(t),(0,c.t)(),!0,{},e.runtime.isRecording,r],void 0,this.featureName,this.ee)}),y.gm.addEventListener("unhandledrejection",t=>{this.abortHandler&&(0,a.p)("err",[K(t),(0,c.t)(),!1,{unhandledPromiseRejection:1},e.runtime.isRecording],void 0,this.featureName,this.ee)},(0,I.jT)(!1,this.removeOnAbort?.signal)),y.gm.addEventListener("error",t=>{this.abortHandler&&(0,a.p)("err",[D(t),(0,c.t)(),!1,{},e.runtime.isRecording],void 0,this.featureName,this.ee)},(0,I.jT)(!1,this.removeOnAbort?.signal)),this.abortHandler=this.#r,this.importAggregator(e,()=>i.e(478).then(i.bind(i,2176)))}#r(){this.removeOnAbort?.abort(),this.abortHandler=void 0}}var Q=i(8990);let ee=1;function te(e){const t=typeof e;return!e||"object"!==t&&"function"!==t?-1:e===y.gm?0:(0,Q.I)(e,"nr@id",function(){return ee++})}function re(e){if("string"==typeof e&&e.length)return e.length;if("object"==typeof e){if("undefined"!=typeof ArrayBuffer&&e instanceof ArrayBuffer&&e.byteLength)return e.byteLength;if("undefined"!=typeof Blob&&e instanceof Blob&&e.size)return e.size;if(!("undefined"!=typeof FormData&&e instanceof FormData))try{return(0,L.A)(e).length}catch(e){return}}}var ne=i(8139),ie=i(7836),oe=i(3434);const se={},ae=["open","send"];function ce(e){var t=e||ie.ee;const r=function(e){return(e||ie.ee).get("xhr")}(t);if(void 0===y.gm.XMLHttpRequest)return r;if(se[r.debugId]++)return r;se[r.debugId]=1,(0,ne.u)(t);var n=(0,oe.YM)(r),i=y.gm.XMLHttpRequest,o=y.gm.MutationObserver,s=y.gm.Promise,a=y.gm.setInterval,c="readystatechange",u=["onload","onerror","onabort","onloadstart","onloadend","onprogress","ontimeout"],d=[],f=y.gm.XMLHttpRequest=function(e){const t=new i(e),o=r.context(t);try{r.emit("new-xhr",[t],o),t.addEventListener(c,(s=o,function(){var e=this;e.readyState>3&&!s.resolved&&(s.resolved=!0,r.emit("xhr-resolved",[],e)),n.inPlace(e,u,"fn-",b)}),(0,I.jT)(!1))}catch(e){(0,l.R)(15,e);try{r.emit("internal-error",[e])}catch(e){}}var s;return t};function h(e,t){n.inPlace(t,["onreadystatechange"],"fn-",b)}if(function(e,t){for(var r in e)t[r]=e[r]}(i,f),f.prototype=i.prototype,n.inPlace(f.prototype,ae,"-xhr-",b),r.on("send-xhr-start",function(e,t){h(e,t),function(e){d.push(e),o&&(p?p.then(v):a?a(v):(g=-g,m.data=g))}(t)}),r.on("open-xhr-start",h),o){var p=s&&s.resolve();if(!a&&!s){var g=1,m=document.createTextNode(g);new o(v).observe(m,{characterData:!0})}}else t.on("fn-end",function(e){e[0]&&e[0].type===c||v()});function v(){for(var e=0;e<d.length;e++)h(0,d[e]);d.length&&(d=[])}function b(e,t){return t}return r}var ue="fetch-",de=ue+"body-",le=["arrayBuffer","blob","json","text","formData"],fe=y.gm.Request,he=y.gm.Response,pe="prototype";const ge={};function me(e){const t=function(e){return(e||ie.ee).get("fetch")}(e);if(!(fe&&he&&y.gm.fetch))return t;if(ge[t.debugId]++)return t;function r(e,r,n){var i=e[r];"function"==typeof i&&(e[r]=function(){var e,r=[...arguments],o={};t.emit(n+"before-start",[r],o),o[ie.P]&&o[ie.P].dt&&(e=o[ie.P].dt);var s=i.apply(this,r);return t.emit(n+"start",[r,e],s),s.then(function(e){return t.emit(n+"end",[null,e],s),e},function(e){throw t.emit(n+"end",[e],s),e})})}return ge[t.debugId]=1,le.forEach(e=>{r(fe[pe],e,de),r(he[pe],e,de)}),r(y.gm,"fetch",ue),t.on(ue+"end",function(e,r){var n=this;if(r){var i=r.headers.get("content-length");null!==i&&(n.rxSize=i),t.emit(ue+"done",[null,r],n)}else t.emit(ue+"done",[e],n)}),t}var ve=i(7485);class be{constructor(e){this.agentRef=e}generateTracePayload(t){const r=this.agentRef.loader_config;if(!this.shouldGenerateTrace(t)||!r)return null;var n=(r.accountID||"").toString()||null,i=(r.agentID||"").toString()||null,o=(r.trustKey||"").toString()||null;if(!n||!i)return null;var s=(0,e.ZF)(),a=(0,e.el)(),c=Date.now(),u={spanId:s,traceId:a,timestamp:c};return(t.sameOrigin||this.isAllowedOrigin(t)&&this.useTraceContextHeadersForCors())&&(u.traceContextParentHeader=this.generateTraceContextParentHeader(s,a),u.traceContextStateHeader=this.generateTraceContextStateHeader(s,c,n,i,o)),(t.sameOrigin&&!this.excludeNewrelicHeader()||!t.sameOrigin&&this.isAllowedOrigin(t)&&this.useNewrelicHeaderForCors())&&(u.newrelicHeader=this.generateTraceHeader(s,a,c,n,i,o)),u}generateTraceContextParentHeader(e,t){return"00-"+t+"-"+e+"-01"}generateTraceContextStateHeader(e,t,r,n,i){return i+"@nr=0-1-"+r+"-"+n+"-"+e+"----"+t}generateTraceHeader(e,t,r,n,i,o){if(!("function"==typeof y.gm?.btoa))return null;var s={v:[0,1],d:{ty:"Browser",ac:n,ap:i,id:e,tr:t,ti:r}};return o&&n!==o&&(s.d.tk=o),btoa((0,L.A)(s))}shouldGenerateTrace(e){return this.agentRef.init?.distributed_tracing?.enabled&&this.isAllowedOrigin(e)}isAllowedOrigin(e){var t=!1;const r=this.agentRef.init?.distributed_tracing;if(e.sameOrigin)t=!0;else if(r?.allowed_origins instanceof Array)for(var n=0;n<r.allowed_origins.length;n++){var i=(0,ve.D)(r.allowed_origins[n]);if(e.hostname===i.hostname&&e.protocol===i.protocol&&e.port===i.port){t=!0;break}}return t}excludeNewrelicHeader(){var e=this.agentRef.init?.distributed_tracing;return!!e&&!!e.exclude_newrelic_header}useNewrelicHeaderForCors(){var e=this.agentRef.init?.distributed_tracing;return!!e&&!1!==e.cors_use_newrelic_header}useTraceContextHeadersForCors(){var e=this.agentRef.init?.distributed_tracing;return!!e&&!!e.cors_use_tracecontext_headers}}var ye=i(9300),we=i(7295);function Re(e){return"string"==typeof e?e:e instanceof(0,O.dV)().o.REQ?e.url:y.gm?.URL&&e instanceof URL?e.href:void 0}var xe=["load","error","abort","timeout"],Te=xe.length,Ee=(0,O.dV)().o.REQ,Ae=(0,O.dV)().o.XHR;const Se="X-NewRelic-App-Data";class _e extends E{static featureName=ye.T;constructor(e){super(e,ye.T),this.dt=new be(e),this.handler=(e,t,r,n)=>(0,a.p)(e,t,r,n,this.ee);try{const e={xmlhttprequest:"xhr",fetch:"fetch",beacon:"beacon"};y.gm?.performance?.getEntriesByType("resource").forEach(t=>{if(t.initiatorType in e&&0!==t.responseStatus){const r={status:t.responseStatus},i={rxSize:t.transferSize,duration:Math.floor(t.duration),cbTime:0};Oe(r,t.name),this.handler("xhr",[r,i,t.startTime,t.responseEnd,e[t.initiatorType]],void 0,n.K7.ajax)}})}catch(e){}me(this.ee),ce(this.ee),function(e,t,r,i){function o(e){var t=this;t.totalCbs=0,t.called=0,t.cbTime=0,t.end=E,t.ended=!1,t.xhrGuids={},t.lastSize=null,t.loadCaptureCalled=!1,t.params=this.params||{},t.metrics=this.metrics||{},t.latestLongtaskEnd=0,e.addEventListener("load",function(r){A(t,e)},(0,I.jT)(!1)),y.lR||e.addEventListener("progress",function(e){t.lastSize=e.loaded},(0,I.jT)(!1))}function s(e){this.params={method:e[0]},Oe(this,e[1]),this.metrics={}}function u(t,r){e.loader_config.xpid&&this.sameOrigin&&r.setRequestHeader("X-NewRelic-ID",e.loader_config.xpid);var n=i.generateTracePayload(this.parsedOrigin);if(n){var o=!1;n.newrelicHeader&&(r.setRequestHeader("newrelic",n.newrelicHeader),o=!0),n.traceContextParentHeader&&(r.setRequestHeader("traceparent",n.traceContextParentHeader),n.traceContextStateHeader&&r.setRequestHeader("tracestate",n.traceContextStateHeader),o=!0),o&&(this.dt=n)}}function d(e,r){var n=this.metrics,i=e[0],o=this;if(n&&i){var s=re(i);s&&(n.txSize=s)}this.startTime=(0,c.t)(),this.body=i,this.listener=function(e){try{"abort"!==e.type||o.loadCaptureCalled||(o.params.aborted=!0),("load"!==e.type||o.called===o.totalCbs&&(o.onloadCalled||"function"!=typeof r.onload)&&"function"==typeof o.end)&&o.end(r)}catch(e){try{t.emit("internal-error",[e])}catch(e){}}};for(var a=0;a<Te;a++)r.addEventListener(xe[a],this.listener,(0,I.jT)(!1))}function l(e,t,r){this.cbTime+=e,t?this.onloadCalled=!0:this.called+=1,this.called!==this.totalCbs||!this.onloadCalled&&"function"==typeof r.onload||"function"!=typeof this.end||this.end(r)}function f(e,t){var r=""+te(e)+!!t;this.xhrGuids&&!this.xhrGuids[r]&&(this.xhrGuids[r]=!0,this.totalCbs+=1)}function p(e,t){var r=""+te(e)+!!t;this.xhrGuids&&this.xhrGuids[r]&&(delete this.xhrGuids[r],this.totalCbs-=1)}function g(){this.endTime=(0,c.t)()}function m(e,r){r instanceof Ae&&"load"===e[0]&&t.emit("xhr-load-added",[e[1],e[2]],r)}function v(e,r){r instanceof Ae&&"load"===e[0]&&t.emit("xhr-load-removed",[e[1],e[2]],r)}function b(e,t,r){t instanceof Ae&&("onload"===r&&(this.onload=!0),("load"===(e[0]&&e[0].type)||this.onload)&&(this.xhrCbStart=(0,c.t)()))}function w(e,r){this.xhrCbStart&&t.emit("xhr-cb-time",[(0,c.t)()-this.xhrCbStart,this.onload,r],r)}function R(e){var t,r=e[1]||{};if("string"==typeof e[0]?0===(t=e[0]).length&&y.RI&&(t=""+y.gm.location.href):e[0]&&e[0].url?t=e[0].url:y.gm?.URL&&e[0]&&e[0]instanceof URL?t=e[0].href:"function"==typeof e[0].toString&&(t=e[0].toString()),"string"==typeof t&&0!==t.length){t&&(this.parsedOrigin=(0,ve.D)(t),this.sameOrigin=this.parsedOrigin.sameOrigin);var n=i.generateTracePayload(this.parsedOrigin);if(n&&(n.newrelicHeader||n.traceContextParentHeader))if(e[0]&&e[0].headers)a(e[0].headers,n)&&(this.dt=n);else{var o={};for(var s in r)o[s]=r[s];o.headers=new Headers(r.headers||{}),a(o.headers,n)&&(this.dt=n),e.length>1?e[1]=o:e.push(o)}}function a(e,t){var r=!1;return t.newrelicHeader&&(e.set("newrelic",t.newrelicHeader),r=!0),t.traceContextParentHeader&&(e.set("traceparent",t.traceContextParentHeader),t.traceContextStateHeader&&e.set("tracestate",t.traceContextStateHeader),r=!0),r}}function x(e,t){this.params={},this.metrics={},this.startTime=(0,c.t)(),this.dt=t,e.length>=1&&(this.target=e[0]),e.length>=2&&(this.opts=e[1]);var r=this.opts||{},n=this.target;Oe(this,Re(n));var i=(""+(n&&n instanceof Ee&&n.method||r.method||"GET")).toUpperCase();this.params.method=i,this.body=r.body,this.txSize=re(r.body)||0}function T(e,t){if(this.endTime=(0,c.t)(),this.params||(this.params={}),(0,we.iW)(this.params))return;let i;this.params.status=t?t.status:0,"string"==typeof this.rxSize&&this.rxSize.length>0&&(i=+this.rxSize);const o={txSize:this.txSize,rxSize:i,duration:(0,c.t)()-this.startTime};r("xhr",[this.params,o,this.startTime,this.endTime,"fetch"],this,n.K7.ajax)}function E(e){const t=this.params,i=this.metrics;if(!this.ended){this.ended=!0;for(let t=0;t<Te;t++)e.removeEventListener(xe[t],this.listener,!1);t.aborted||(0,we.iW)(t)||(i.duration=(0,c.t)()-this.startTime,this.loadCaptureCalled||4!==e.readyState?null==t.status&&(t.status=0):A(this,e),i.cbTime=this.cbTime,r("xhr",[t,i,this.startTime,this.endTime,"xhr"],this,n.K7.ajax))}}function A(e,r){e.params.status=r.status;var i=function(e,t){var r=e.responseType;return"json"===r&&null!==t?t:"arraybuffer"===r||"blob"===r||"json"===r?re(e.response):"text"===r||""===r||void 0===r?re(e.responseText):void 0}(r,e.lastSize);if(i&&(e.metrics.rxSize=i),e.sameOrigin&&r.getAllResponseHeaders().indexOf(Se)>=0){var o=r.getResponseHeader(Se);o&&((0,a.p)(h.rs,["Ajax/CrossApplicationTracing/Header/Seen"],void 0,n.K7.metrics,t),e.params.cat=o.split(", ").pop())}e.loadCaptureCalled=!0}t.on("new-xhr",o),t.on("open-xhr-start",s),t.on("open-xhr-end",u),t.on("send-xhr-start",d),t.on("xhr-cb-time",l),t.on("xhr-load-added",f),t.on("xhr-load-removed",p),t.on("xhr-resolved",g),t.on("addEventListener-end",m),t.on("removeEventListener-end",v),t.on("fn-end",w),t.on("fetch-before-start",R),t.on("fetch-start",x),t.on("fn-start",b),t.on("fetch-done",T)}(e,this.ee,this.handler,this.dt),this.importAggregator(e,()=>i.e(478).then(i.bind(i,3845)))}}function Oe(e,t){var r=(0,ve.D)(t),n=e.params||e;n.hostname=r.hostname,n.port=r.port,n.protocol=r.protocol,n.host=r.hostname+":"+r.port,n.pathname=r.pathname,e.parsedOrigin=r,e.sameOrigin=r.sameOrigin}const Ne={},Ie=["pushState","replaceState"];function Pe(e){const t=function(e){return(e||ie.ee).get("history")}(e);return!y.RI||Ne[t.debugId]++||(Ne[t.debugId]=1,(0,oe.YM)(t).inPlace(window.history,Ie,"-")),t}var je=i(3738);function ke(e){p(u.BL,function(t=Date.now()){const r=t-y.WN;r<0&&(0,l.R)(62,t),(0,a.p)(h.XG,[u.BL,{time:r}],void 0,n.K7.metrics,e.ee),e.addToTrace({name:u.BL,start:t,origin:"nr"}),(0,a.p)(u.Pl+u.hG,[r,u.BL],void 0,n.K7.genericEvents,e.ee)},e)}const{He:Ce,bD:Le,d3:He,Kp:Me,TZ:Ke,Lc:De,uP:Ue,Rz:Fe}=je;class We extends E{static featureName=Ke;constructor(e){var t;super(e,Ke),t=e,p(u.U2,function(e){if(!(e&&"object"==typeof e&&e.name&&e.start))return;const r={n:e.name,s:e.start-y.WN,e:(e.end||e.start)-y.WN,o:e.origin||"",t:"api"};r.s<0||r.e<0||r.e<r.s?(0,l.R)(61,{start:r.s,end:r.e}):(0,a.p)("bstApi",[r],void 0,n.K7.sessionTrace,t.ee)},t),ke(e);if(!(0,R.V)(e.init))return void this.deregisterDrain();const r=this.ee;let o;Pe(r),this.eventsEE=(0,ne.u)(r),this.eventsEE.on(Ue,function(e,t){this.bstStart=(0,c.t)()}),this.eventsEE.on(De,function(e,t){(0,a.p)("bst",[e[0],t,this.bstStart,(0,c.t)()],void 0,n.K7.sessionTrace,r)}),r.on(Fe+He,function(e){this.time=(0,c.t)(),this.startPath=location.pathname+location.hash}),r.on(Fe+Me,function(e){(0,a.p)("bstHist",[location.pathname+location.hash,this.startPath,this.time],void 0,n.K7.sessionTrace,r)});try{o=new PerformanceObserver(e=>{const t=e.getEntries();(0,a.p)(Ce,[t],void 0,n.K7.sessionTrace,r)}),o.observe({type:Le,buffered:!0})}catch(e){}this.importAggregator(e,()=>i.e(478).then(i.bind(i,6974)),{resourceObserver:o})}}var Be=i(6344);class Ve extends E{static featureName=Be.TZ;#n;recorder;constructor(e){var t;let r;super(e,Be.TZ),t=e,p(u.CH,function(){(0,a.p)(u.CH,[],void 0,n.K7.sessionReplay,t.ee)},t),function(e){p(u.Tb,function(){(0,a.p)(u.Tb,[],void 0,n.K7.sessionReplay,e.ee)},e)}(e);try{r=JSON.parse(localStorage.getItem("".concat(S.H3,"_").concat(S.uh)))}catch(e){}(0,w.SR)(e.init)&&this.ee.on(u.CH,()=>this.#i()),this.#o(r)&&this.importRecorder().then(e=>{e.startRecording(Be.Qb.PRELOAD,r?.sessionReplayMode)}),this.importAggregator(this.agentRef,()=>i.e(478).then(i.bind(i,6167)),this),this.ee.on("err",e=>{this.blocked||this.agentRef.runtime.isRecording&&(this.errorNoticed=!0,(0,a.p)(Be.Vh,[e],void 0,this.featureName,this.ee))})}#o(e){return e&&(e.sessionReplayMode===S.g.FULL||e.sessionReplayMode===S.g.ERROR)||(0,w.Aw)(this.agentRef.init)}importRecorder(){return this.recorder?Promise.resolve(this.recorder):(this.#n??=Promise.all([i.e(478),i.e(249)]).then(i.bind(i,4866)).then(({Recorder:e})=>(this.recorder=new e(this),this.recorder)).catch(e=>{throw this.ee.emit("internal-error",[e]),this.blocked=!0,e}),this.#n)}#i(){this.blocked||(this.featAggregate?this.featAggregate.mode!==S.g.FULL&&this.featAggregate.initializeRecording(S.g.FULL,!0,Be.Qb.API):this.importRecorder().then(()=>{this.recorder.startRecording(Be.Qb.API,S.g.FULL)}))}}var Ge=i(3962);function ze(e){const t=e.ee.get("tracer");function r(){}p(u.dT,function(e){return(new r).get("object"==typeof e?e:{})},e);const i=r.prototype={createTracer:function(r,i){var o={},s=this,d="function"==typeof i;return(0,a.p)(h.xV,["API/createTracer/called"],void 0,n.K7.metrics,e.ee),e.runSoftNavOverSpa||(0,a.p)(u.hw+"tracer",[(0,c.t)(),r,o],s,n.K7.spa,e.ee),function(){if(t.emit((d?"":"no-")+"fn-start",[(0,c.t)(),s,d],o),d)try{return i.apply(this,arguments)}catch(e){const r="string"==typeof e?new Error(e):e;throw t.emit("fn-err",[arguments,this,r],o),r}finally{t.emit("fn-end",[(0,c.t)()],o)}}}};["actionText","setName","setAttribute","save","ignore","onEnd","getContext","end","get"].forEach(t=>{p.apply(this,[t,function(){return(0,a.p)(u.hw+t,[(0,c.t)(),...arguments],this,e.runSoftNavOverSpa?n.K7.softNav:n.K7.spa,e.ee),this},e,i])}),p(u.PA,function(){e.runSoftNavOverSpa?(0,a.p)(u.hw+"routeName",[performance.now(),...arguments],void 0,n.K7.softNav,e.ee):(0,a.p)(u.Pl+"routeName",[(0,c.t)(),...arguments],this,n.K7.spa,e.ee)},e)}class Ze extends E{static featureName=Ge.TZ;constructor(e){if(super(e,Ge.TZ),ze(e),!y.RI||!(0,O.dV)().o.MO)return;const t=Pe(this.ee);try{this.removeOnAbort=new AbortController}catch(e){}Ge.tC.forEach(e=>{(0,I.sp)(e,e=>{s(e)},!0,this.removeOnAbort?.signal)});const r=()=>(0,a.p)("newURL",[(0,c.t)(),""+window.location],void 0,this.featureName,this.ee);t.on("pushState-end",r),t.on("replaceState-end",r),(0,I.sp)(Ge.OV,e=>{s(e),(0,a.p)("newURL",[e.timeStamp,""+window.location],void 0,this.featureName,this.ee)},!0,this.removeOnAbort?.signal);let n=!1;const o=new((0,O.dV)().o.MO)((e,t)=>{n||(n=!0,requestAnimationFrame(()=>{(0,a.p)("newDom",[(0,c.t)()],void 0,this.featureName,this.ee),n=!1}))}),s=(0,x.s)(e=>{(0,a.p)("newUIEvent",[e],void 0,this.featureName,this.ee),o.observe(document.body,{attributes:!0,childList:!0,subtree:!0,characterData:!0})},100,{leading:!0});this.abortHandler=function(){this.removeOnAbort?.abort(),o.disconnect(),this.abortHandler=void 0},this.importAggregator(e,()=>i.e(478).then(i.bind(i,4393)),{domObserver:o})}}var qe=i(7378);const Xe={},Ye=["appendChild","insertBefore","replaceChild"];function Je(e){const t=function(e){return(e||ie.ee).get("jsonp")}(e);if(!y.RI||Xe[t.debugId])return t;Xe[t.debugId]=!0;var r=(0,oe.YM)(t),n=/[?&](?:callback|cb)=([^&#]+)/,i=/(.*)\.([^.]+)/,o=/^(\w+)(\.|$)(.*)$/;function s(e,t){if(!e)return t;const r=e.match(o),n=r[1];return s(r[3],t[n])}return r.inPlace(Node.prototype,Ye,"dom-"),t.on("dom-start",function(e){!function(e){if(!e||"string"!=typeof e.nodeName||"script"!==e.nodeName.toLowerCase())return;if("function"!=typeof e.addEventListener)return;var o=(a=e.src,c=a.match(n),c?c[1]:null);var a,c;if(!o)return;var u=function(e){var t=e.match(i);if(t&&t.length>=3)return{key:t[2],parent:s(t[1],window)};return{key:e,parent:window}}(o);if("function"!=typeof u.parent[u.key])return;var d={};function l(){t.emit("jsonp-end",[],d),e.removeEventListener("load",l,(0,I.jT)(!1)),e.removeEventListener("error",f,(0,I.jT)(!1))}function f(){t.emit("jsonp-error",[],d),t.emit("jsonp-end",[],d),e.removeEventListener("load",l,(0,I.jT)(!1)),e.removeEventListener("error",f,(0,I.jT)(!1))}r.inPlace(u.parent,[u.key],"cb-",d),e.addEventListener("load",l,(0,I.jT)(!1)),e.addEventListener("error",f,(0,I.jT)(!1)),t.emit("new-jsonp",[e.src],d)}(e[0])}),t}const $e={};function Qe(e){const t=function(e){return(e||ie.ee).get("promise")}(e);if($e[t.debugId])return t;$e[t.debugId]=!0;var r=t.context,n=(0,oe.YM)(t),i=y.gm.Promise;return i&&function(){function e(r){var o=t.context(),s=n(r,"executor-",o,null,!1);const a=Reflect.construct(i,[s],e);return t.context(a).getCtx=function(){return o},a}y.gm.Promise=e,Object.defineProperty(e,"name",{value:"Promise"}),e.toString=function(){return i.toString()},Object.setPrototypeOf(e,i),["all","race"].forEach(function(r){const n=i[r];e[r]=function(e){let i=!1;[...e||[]].forEach(e=>{this.resolve(e).then(s("all"===r),s(!1))});const o=n.apply(this,arguments);return o;function s(e){return function(){t.emit("propagate",[null,!i],o,!1,!1),i=i||!e}}}}),["resolve","reject"].forEach(function(r){const n=i[r];e[r]=function(e){const r=n.apply(this,arguments);return e!==r&&t.emit("propagate",[e,!0],r,!1,!1),r}}),e.prototype=i.prototype;const o=i.prototype.then;i.prototype.then=function(...e){var i=this,s=r(i);s.promise=i,e[0]=n(e[0],"cb-",s,null,!1),e[1]=n(e[1],"cb-",s,null,!1);const a=o.apply(this,e);return s.nextPromise=a,t.emit("propagate",[i,!0],a,!1,!1),a},i.prototype.then[oe.Jt]=o,t.on("executor-start",function(e){e[0]=n(e[0],"resolve-",this,null,!1),e[1]=n(e[1],"resolve-",this,null,!1)}),t.on("executor-err",function(e,t,r){e[1](r)}),t.on("cb-end",function(e,r,n){t.emit("propagate",[n,!0],this.nextPromise,!1,!1)}),t.on("propagate",function(e,r,n){if(!this.getCtx||r){const r=this,n=e instanceof Promise?t.context(e):null;let i;this.getCtx=function(){return i||(i=n&&n!==r?"function"==typeof n.getCtx?n.getCtx():n:r,i)}}})}(),t}const et={},tt="setTimeout",rt="setInterval",nt="clearTimeout",it="-start",ot=[tt,"setImmediate",rt,nt,"clearImmediate"];function st(e){const t=function(e){return(e||ie.ee).get("timer")}(e);if(et[t.debugId]++)return t;et[t.debugId]=1;var r=(0,oe.YM)(t);return r.inPlace(y.gm,ot.slice(0,2),tt+"-"),r.inPlace(y.gm,ot.slice(2,3),rt+"-"),r.inPlace(y.gm,ot.slice(3),nt+"-"),t.on(rt+it,function(e,t,n){e[0]=r(e[0],"fn-",null,n)}),t.on(tt+it,function(e,t,n){this.method=n,this.timerDuration=isNaN(e[1])?0:+e[1],e[0]=r(e[0],"fn-",this,n)}),t}const at={};function ct(e){const t=function(e){return(e||ie.ee).get("mutation")}(e);if(!y.RI||at[t.debugId])return t;at[t.debugId]=!0;var r=(0,oe.YM)(t),n=y.gm.MutationObserver;return n&&(window.MutationObserver=function(e){return this instanceof n?new n(r(e,"fn-")):n.apply(this,arguments)},MutationObserver.prototype=n.prototype),t}const{TZ:ut,d3:dt,Kp:lt,$p:ft,wW:ht,e5:pt,tH:gt,uP:mt,rw:vt,Lc:bt}=qe;class yt extends E{static featureName=ut;constructor(e){if(super(e,ut),ze(e),!y.RI)return;try{this.removeOnAbort=new AbortController}catch(e){}let t,r=0;const n=this.ee.get("tracer"),o=Je(this.ee),s=Qe(this.ee),u=st(this.ee),d=ce(this.ee),l=this.ee.get("events"),f=me(this.ee),h=Pe(this.ee),p=ct(this.ee);function g(e,t){h.emit("newURL",[""+window.location,t])}function m(){r++,t=window.location.hash,this[mt]=(0,c.t)()}function v(){r--,window.location.hash!==t&&g(0,!0);var e=(0,c.t)();this[pt]=~~this[pt]+e-this[mt],this[bt]=e}function b(e,t){e.on(t,function(){this[t]=(0,c.t)()})}this.ee.on(mt,m),s.on(vt,m),o.on(vt,m),this.ee.on(bt,v),s.on(ht,v),o.on(ht,v),this.ee.on("fn-err",(...t)=>{t[2]?.__newrelic?.[e.agentIdentifier]||(0,a.p)("function-err",[...t],void 0,this.featureName,this.ee)}),this.ee.buffer([mt,bt,"xhr-resolved"],this.featureName),l.buffer([mt],this.featureName),u.buffer(["setTimeout"+lt,"clearTimeout"+dt,mt],this.featureName),d.buffer([mt,"new-xhr","send-xhr"+dt],this.featureName),f.buffer([gt+dt,gt+"-done",gt+ft+dt,gt+ft+lt],this.featureName),h.buffer(["newURL"],this.featureName),p.buffer([mt],this.featureName),s.buffer(["propagate",vt,ht,"executor-err","resolve"+dt],this.featureName),n.buffer([mt,"no-"+mt],this.featureName),o.buffer(["new-jsonp","cb-start","jsonp-error","jsonp-end"],this.featureName),b(f,gt+dt),b(f,gt+"-done"),b(o,"new-jsonp"),b(o,"jsonp-end"),b(o,"cb-start"),h.on("pushState-end",g),h.on("replaceState-end",g),window.addEventListener("hashchange",g,(0,I.jT)(!0,this.removeOnAbort?.signal)),window.addEventListener("load",g,(0,I.jT)(!0,this.removeOnAbort?.signal)),window.addEventListener("popstate",function(){g(0,r>1)},(0,I.jT)(!0,this.removeOnAbort?.signal)),this.abortHandler=this.#r,this.importAggregator(e,()=>i.e(478).then(i.bind(i,5592)))}#r(){this.removeOnAbort?.abort(),this.abortHandler=void 0}}var wt=i(3333);class Rt extends E{static featureName=wt.TZ;constructor(e){super(e,wt.TZ);const t=[e.init.page_action.enabled,e.init.performance.capture_marks,e.init.performance.capture_measures,e.init.user_actions.enabled,e.init.performance.resources.enabled];var r;r=e,p(u.hG,(e,t)=>z(e,t,r),r),function(e){p(u.fF,(t,r)=>q(t,r,e),e)}(e),ke(e),X(e),function(e){p(u.V1,(t,r)=>Z(t,r,e),e)}(e);const o=e.init.feature_flags.includes("user_frustrations");let s;if(y.RI&&o&&(me(this.ee),ce(this.ee),s=Pe(this.ee)),y.RI){if(e.init.user_actions.enabled&&(wt.Zp.forEach(e=>(0,I.sp)(e,e=>(0,a.p)("ua",[e],void 0,this.featureName,this.ee),!0)),wt.qN.forEach(e=>{const t=(0,x.s)(e=>{(0,a.p)("ua",[e],void 0,this.featureName,this.ee)},500,{leading:!0});(0,I.sp)(e,t)}),o)){function c(t){const r=(0,ve.D)(t);return e.beacons.includes(r.hostname+":"+r.port)}function d(){s.emit("navChange")}y.gm.addEventListener("error",()=>{(0,a.p)("uaErr",[],void 0,n.K7.genericEvents,this.ee)},(0,I.jT)(!1,this.removeOnAbort?.signal)),this.ee.on("open-xhr-start",(e,t)=>{c(e[1])||t.addEventListener("readystatechange",()=>{2===t.readyState&&(0,a.p)("uaXhr",[],void 0,n.K7.genericEvents,this.ee)})}),this.ee.on("fetch-start",e=>{e.length>=1&&!c(Re(e[0]))&&(0,a.p)("uaXhr",[],void 0,n.K7.genericEvents,this.ee)}),s.on("pushState-end",d),s.on("replaceState-end",d),window.addEventListener("hashchange",d,(0,I.jT)(!0,this.removeOnAbort?.signal)),window.addEventListener("popstate",d,(0,I.jT)(!0,this.removeOnAbort?.signal))}if(e.init.performance.resources.enabled&&y.gm.PerformanceObserver?.supportedEntryTypes.includes("resource")){new PerformanceObserver(e=>{e.getEntries().forEach(e=>{(0,a.p)("browserPerformance.resource",[e],void 0,this.featureName,this.ee)})}).observe({type:"resource",buffered:!0})}}try{this.removeOnAbort=new AbortController}catch(l){}this.abortHandler=()=>{this.removeOnAbort?.abort(),this.abortHandler=void 0},t.some(e=>e)?this.importAggregator(e,()=>i.e(478).then(i.bind(i,8019))):this.deregisterDrain()}}var xt=i(2646);const Tt=new Map;function Et(e,t,r,n){if("object"!=typeof t||!t||"string"!=typeof r||!r||"function"!=typeof t[r])return(0,l.R)(29);const i=function(e){return(e||ie.ee).get("logger")}(e),o=(0,oe.YM)(i),s=new xt.y(ie.P);s.level=n.level,s.customAttributes=n.customAttributes;const a=t[r]?.[oe.Jt]||t[r];return Tt.set(a,s),o.inPlace(t,[r],"wrap-logger-",()=>Tt.get(a)),i}var At=i(1910);class St extends E{static featureName=B.TZ;constructor(e){var t;super(e,B.TZ),t=e,p(u.$9,(e,r)=>G(e,r,t),t),function(e){p(u.Wb,(t,r,{customAttributes:n={},level:i=B.p_.INFO}={})=>{Et(e.ee,t,r,{customAttributes:n,level:i})},e)}(e),X(e);const r=this.ee;["log","error","warn","info","debug","trace"].forEach(e=>{(0,At.i)(y.gm.console[e]),Et(r,y.gm.console,e,{level:"log"===e?"info":e})}),this.ee.on("wrap-logger-end",function([e]){const{level:t,customAttributes:n}=this;(0,V.R)(r,e,n,t)}),this.importAggregator(e,()=>i.e(478).then(i.bind(i,5288)))}}new class extends r{constructor(e){var t;(super(),y.gm)?(this.features={},(0,O.bQ)(this.agentIdentifier,this),this.desiredFeatures=new Set(e.features||[]),this.desiredFeatures.add(_),this.runSoftNavOverSpa=[...this.desiredFeatures].some(e=>e.featureName===n.K7.softNav),(0,s.j)(this,e,e.loaderType||"agent"),t=this,p(u.cD,function(e,r,n=!1){if("string"==typeof e){if(["string","number","boolean"].includes(typeof r)||null===r)return g(t,e,r,u.cD,n);(0,l.R)(40,typeof r)}else(0,l.R)(39,typeof e)},t),function(e){p(u.Dl,function(t){if("string"==typeof t||null===t)return g(e,"enduser.id",t,u.Dl,!0);(0,l.R)(41,typeof t)},e)}(this),function(e){p(u.nb,function(t){if("string"==typeof t||null===t)return g(e,"application.version",t,u.nb,!1);(0,l.R)(42,typeof t)},e)}(this),function(e){p(u.d3,function(){e.ee.emit("manual-start-all")},e)}(this),function(e){p(u.Pv,function(t=!0){if("boolean"==typeof t){if((0,a.p)(u.Pl+u.Pv,[t],void 0,"session",e.ee),e.runtime.consented=t,t){const t=e.features.page_view_event;t.onAggregateImported.then(e=>{const r=t.featAggregate;e&&!r.sentRum&&r.sendRum()})}}else(0,l.R)(65,typeof t)},e)}(this),this.run()):(0,l.R)(21)}get config(){return{info:this.info,init:this.init,loader_config:this.loader_config,runtime:this.runtime}}get api(){return this}run(){try{const e=function(e){const t={};return o.forEach(r=>{t[r]=!!e[r]?.enabled}),t}(this.init),t=[...this.desiredFeatures];t.sort((e,t)=>n.P3[e.featureName]-n.P3[t.featureName]),t.forEach(t=>{if(!e[t.featureName]&&t.featureName!==n.K7.pageViewEvent)return;if(this.runSoftNavOverSpa&&t.featureName===n.K7.spa)return;if(!this.runSoftNavOverSpa&&t.featureName===n.K7.softNav)return;const r=function(e){switch(e){case n.K7.ajax:return[n.K7.jserrors];case n.K7.sessionTrace:return[n.K7.ajax,n.K7.pageViewEvent];case n.K7.sessionReplay:return[n.K7.sessionTrace];case n.K7.pageViewTiming:return[n.K7.pageViewEvent];default:return[]}}(t.featureName).filter(e=>!(e in this.features));r.length>0&&(0,l.R)(36,{targetFeature:t.featureName,missingDependencies:r}),this.features[t.featureName]=new t(this)})}catch(e){(0,l.R)(22,e);for(const e in this.features)this.features[e].abortHandler?.();const t=(0,O.Zm)();delete t.initializedAgents[this.agentIdentifier]?.features,delete this.sharedAggregator;return t.ee.get(this.agentIdentifier).abort(),!1}}}({features:[_e,_,j,We,Ve,k,J,Rt,St,Ze,yt],loaderType:"spa"})})()})();</script>
	<!-- <meta name="format-detection" content="telephone=no"> -->
	<!--<meta name="viewport" content="width=device-width" />-->
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<meta name="description" content="The libraries of the Massachusetts Institute of Technology - Search, Visit, Research, Explore" />
	<title>Search | MIT Libraries</title>
	<meta property="og:title" content="Search | MIT Libraries"/>
<meta property="og:type" content="website" />
<meta property="og:image" content="https://libraries.mit.edu/app/themes/mitlib-parent/images/mit-libraries-logo-black-yellow-1200-1200.png"/>
<meta property="og:image:type" content="image/png" />
<meta property="og:image:width" content="1200" />
<meta property="og:image:height" content="1200" />
<meta property="og:image:alt" content="MIT Libraries logo" />
<meta property="og:description" content="Use this page to learn about different ways you can search the MIT Libraries’ offerings. Use the Default Quick Search Our Quick Search is the default search on the Libraries’ homepage. This collects results from different library search tools and sorts the results into 4 categories: Books and media Articles and book chapters Archives and manuscript collections Our library website and guides The tool will search the 4 categories and present the top results from each category. It is useful to see the full breadth of what MIT Libraries has on a particular topic or author. Go straight to our [&hellip;]" />
<meta property="og:url" content="https://libraries.mit.edu/search/">
	<link rel="profile" href="https://gmpg.org/xfn/11" />
	<link rel="pingback" href="https://libraries.mit.edu/wp/xmlrpc.php" />
	<link rel="icon" href="https://cdn.libraries.mit.edu/files/branding/favicons/favicon.ico" sizes="32x32">
	<link rel="icon" href="https://cdn.libraries.mit.edu/files/branding/favicons/favicon.svg" type="image/svg+xml">
	<link rel="apple-touch-icon" href="https://cdn.libraries.mit.edu/files/branding/favicons/apple-touch-icon.png"><!-- 180×180 -->
	<link rel="manifest" href="https://cdn.libraries.mit.edu/files/branding/favicons/manifest.json">
	<meta name='robots' content='max-image-preview:large' />
	<style>img:is([sizes="auto" i], [sizes^="auto," i]) { contain-intrinsic-size: 3000px 1500px }</style>
	<link rel='dns-prefetch' href='//libraries.mit.edu' />
<link rel='dns-prefetch' href='//maxcdn.bootstrapcdn.com' />
<link rel='dns-prefetch' href='//use.typekit.net' />
<script type="text/javascript">
/* <![CDATA[ */
window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/16.0.1\/72x72\/","ext":".png","svgUrl":"https:\/\/s.w.org\/images\/core\/emoji\/16.0.1\/svg\/","svgExt":".svg","source":{"concatemoji":"https:\/\/libraries.mit.edu\/wp\/wp-includes\/js\/wp-emoji-release.min.js?ver=6.8.2"}};
/*! This file is auto-generated */
!function(s,n){var o,i,e;function c(e){try{var t={supportTests:e,timestamp:(new Date).valueOf()};sessionStorage.setItem(o,JSON.stringify(t))}catch(e){}}function p(e,t,n){e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(t,0,0);var t=new Uint32Array(e.getImageData(0,0,e.canvas.width,e.canvas.height).data),a=(e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(n,0,0),new Uint32Array(e.getImageData(0,0,e.canvas.width,e.canvas.height).data));return t.every(function(e,t){return e===a[t]})}function u(e,t){e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(t,0,0);for(var n=e.getImageData(16,16,1,1),a=0;a<n.data.length;a++)if(0!==n.data[a])return!1;return!0}function f(e,t,n,a){switch(t){case"flag":return n(e,"\ud83c\udff3\ufe0f\u200d\u26a7\ufe0f","\ud83c\udff3\ufe0f\u200b\u26a7\ufe0f")?!1:!n(e,"\ud83c\udde8\ud83c\uddf6","\ud83c\udde8\u200b\ud83c\uddf6")&&!n(e,"\ud83c\udff4\udb40\udc67\udb40\udc62\udb40\udc65\udb40\udc6e\udb40\udc67\udb40\udc7f","\ud83c\udff4\u200b\udb40\udc67\u200b\udb40\udc62\u200b\udb40\udc65\u200b\udb40\udc6e\u200b\udb40\udc67\u200b\udb40\udc7f");case"emoji":return!a(e,"\ud83e\udedf")}return!1}function g(e,t,n,a){var r="undefined"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope?new OffscreenCanvas(300,150):s.createElement("canvas"),o=r.getContext("2d",{willReadFrequently:!0}),i=(o.textBaseline="top",o.font="600 32px Arial",{});return e.forEach(function(e){i[e]=t(o,e,n,a)}),i}function t(e){var t=s.createElement("script");t.src=e,t.defer=!0,s.head.appendChild(t)}"undefined"!=typeof Promise&&(o="wpEmojiSettingsSupports",i=["flag","emoji"],n.supports={everything:!0,everythingExceptFlag:!0},e=new Promise(function(e){s.addEventListener("DOMContentLoaded",e,{once:!0})}),new Promise(function(t){var n=function(){try{var e=JSON.parse(sessionStorage.getItem(o));if("object"==typeof e&&"number"==typeof e.timestamp&&(new Date).valueOf()<e.timestamp+604800&&"object"==typeof e.supportTests)return e.supportTests}catch(e){}return null}();if(!n){if("undefined"!=typeof Worker&&"undefined"!=typeof OffscreenCanvas&&"undefined"!=typeof URL&&URL.createObjectURL&&"undefined"!=typeof Blob)try{var e="postMessage("+g.toString()+"("+[JSON.stringify(i),f.toString(),p.toString(),u.toString()].join(",")+"));",a=new Blob([e],{type:"text/javascript"}),r=new Worker(URL.createObjectURL(a),{name:"wpTestEmojiSupports"});return void(r.onmessage=function(e){c(n=e.data),r.terminate(),t(n)})}catch(e){}c(n=g(i,f,p,u))}t(n)}).then(function(e){for(var t in e)n.supports[t]=e[t],n.supports.everything=n.supports.everything&&n.supports[t],"flag"!==t&&(n.supports.everythingExceptFlag=n.supports.everythingExceptFlag&&n.supports[t]);n.supports.everythingExceptFlag=n.supports.everythingExceptFlag&&!n.supports.flag,n.DOMReady=!1,n.readyCallback=function(){n.DOMReady=!0}}).then(function(){return e}).then(function(){var e;n.supports.everything||(n.readyCallback(),(e=n.source||{}).concatemoji?t(e.concatemoji):e.wpemoji&&e.twemoji&&(t(e.twemoji),t(e.wpemoji)))}))}((window,document),window._wpemojiSettings);
/* ]]> */
</script>
<style id='wp-emoji-styles-inline-css' type='text/css'>

	img.wp-smiley, img.emoji {
		display: inline !important;
		border: none !important;
		box-shadow: none !important;
		height: 1em !important;
		width: 1em !important;
		margin: 0 0.07em !important;
		vertical-align: -0.1em !important;
		background: none !important;
		padding: 0 !important;
	}
</style>
<link rel='stylesheet' id='wp-block-library-css' href='https://libraries.mit.edu/wp/wp-includes/css/dist/block-library/style.min.css?ver=6.8.2' type='text/css' media='all' />
<style id='classic-theme-styles-inline-css' type='text/css'>
/*! This file is auto-generated */
.wp-block-button__link{color:#fff;background-color:#32373c;border-radius:9999px;box-shadow:none;text-decoration:none;padding:calc(.667em + 2px) calc(1.333em + 2px);font-size:1.125em}.wp-block-file__button{background:#32373c;color:#fff;text-decoration:none}
</style>
<style id='global-styles-inline-css' type='text/css'>
:root{--wp--preset--aspect-ratio--square: 1;--wp--preset--aspect-ratio--4-3: 4/3;--wp--preset--aspect-ratio--3-4: 3/4;--wp--preset--aspect-ratio--3-2: 3/2;--wp--preset--aspect-ratio--2-3: 2/3;--wp--preset--aspect-ratio--16-9: 16/9;--wp--preset--aspect-ratio--9-16: 9/16;--wp--preset--color--black: #000000;--wp--preset--color--cyan-bluish-gray: #abb8c3;--wp--preset--color--white: #ffffff;--wp--preset--color--pale-pink: #f78da7;--wp--preset--color--vivid-red: #cf2e2e;--wp--preset--color--luminous-vivid-orange: #ff6900;--wp--preset--color--luminous-vivid-amber: #fcb900;--wp--preset--color--light-green-cyan: #7bdcb5;--wp--preset--color--vivid-green-cyan: #00d084;--wp--preset--color--pale-cyan-blue: #8ed1fc;--wp--preset--color--vivid-cyan-blue: #0693e3;--wp--preset--color--vivid-purple: #9b51e0;--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple: linear-gradient(135deg,rgba(6,147,227,1) 0%,rgb(155,81,224) 100%);--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan: linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%);--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange: linear-gradient(135deg,rgba(252,185,0,1) 0%,rgba(255,105,0,1) 100%);--wp--preset--gradient--luminous-vivid-orange-to-vivid-red: linear-gradient(135deg,rgba(255,105,0,1) 0%,rgb(207,46,46) 100%);--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray: linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%);--wp--preset--gradient--cool-to-warm-spectrum: linear-gradient(135deg,rgb(74,234,220) 0%,rgb(151,120,209) 20%,rgb(207,42,186) 40%,rgb(238,44,130) 60%,rgb(251,105,98) 80%,rgb(254,248,76) 100%);--wp--preset--gradient--blush-light-purple: linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%);--wp--preset--gradient--blush-bordeaux: linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%);--wp--preset--gradient--luminous-dusk: linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%);--wp--preset--gradient--pale-ocean: linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%);--wp--preset--gradient--electric-grass: linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%);--wp--preset--gradient--midnight: linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%);--wp--preset--font-size--small: 13px;--wp--preset--font-size--medium: 20px;--wp--preset--font-size--large: 36px;--wp--preset--font-size--x-large: 42px;--wp--preset--spacing--20: 0.44rem;--wp--preset--spacing--30: 0.67rem;--wp--preset--spacing--40: 1rem;--wp--preset--spacing--50: 1.5rem;--wp--preset--spacing--60: 2.25rem;--wp--preset--spacing--70: 3.38rem;--wp--preset--spacing--80: 5.06rem;--wp--preset--shadow--natural: 6px 6px 9px rgba(0, 0, 0, 0.2);--wp--preset--shadow--deep: 12px 12px 50px rgba(0, 0, 0, 0.4);--wp--preset--shadow--sharp: 6px 6px 0px rgba(0, 0, 0, 0.2);--wp--preset--shadow--outlined: 6px 6px 0px -3px rgba(255, 255, 255, 1), 6px 6px rgba(0, 0, 0, 1);--wp--preset--shadow--crisp: 6px 6px 0px rgba(0, 0, 0, 1);}:where(.is-layout-flex){gap: 0.5em;}:where(.is-layout-grid){gap: 0.5em;}body .is-layout-flex{display: flex;}.is-layout-flex{flex-wrap: wrap;align-items: center;}.is-layout-flex > :is(*, div){margin: 0;}body .is-layout-grid{display: grid;}.is-layout-grid > :is(*, div){margin: 0;}:where(.wp-block-columns.is-layout-flex){gap: 2em;}:where(.wp-block-columns.is-layout-grid){gap: 2em;}:where(.wp-block-post-template.is-layout-flex){gap: 1.25em;}:where(.wp-block-post-template.is-layout-grid){gap: 1.25em;}.has-black-color{color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-color{color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-color{color: var(--wp--preset--color--white) !important;}.has-pale-pink-color{color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-color{color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-color{color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-color{color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-color{color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-color{color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-color{color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-color{color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-color{color: var(--wp--preset--color--vivid-purple) !important;}.has-black-background-color{background-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-background-color{background-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-background-color{background-color: var(--wp--preset--color--white) !important;}.has-pale-pink-background-color{background-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-background-color{background-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-background-color{background-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-background-color{background-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-background-color{background-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-background-color{background-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-background-color{background-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-background-color{background-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-background-color{background-color: var(--wp--preset--color--vivid-purple) !important;}.has-black-border-color{border-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-border-color{border-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-border-color{border-color: var(--wp--preset--color--white) !important;}.has-pale-pink-border-color{border-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-border-color{border-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-border-color{border-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-border-color{border-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-border-color{border-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-border-color{border-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-border-color{border-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-border-color{border-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-border-color{border-color: var(--wp--preset--color--vivid-purple) !important;}.has-vivid-cyan-blue-to-vivid-purple-gradient-background{background: var(--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple) !important;}.has-light-green-cyan-to-vivid-green-cyan-gradient-background{background: var(--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan) !important;}.has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange) !important;}.has-luminous-vivid-orange-to-vivid-red-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-orange-to-vivid-red) !important;}.has-very-light-gray-to-cyan-bluish-gray-gradient-background{background: var(--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray) !important;}.has-cool-to-warm-spectrum-gradient-background{background: var(--wp--preset--gradient--cool-to-warm-spectrum) !important;}.has-blush-light-purple-gradient-background{background: var(--wp--preset--gradient--blush-light-purple) !important;}.has-blush-bordeaux-gradient-background{background: var(--wp--preset--gradient--blush-bordeaux) !important;}.has-luminous-dusk-gradient-background{background: var(--wp--preset--gradient--luminous-dusk) !important;}.has-pale-ocean-gradient-background{background: var(--wp--preset--gradient--pale-ocean) !important;}.has-electric-grass-gradient-background{background: var(--wp--preset--gradient--electric-grass) !important;}.has-midnight-gradient-background{background: var(--wp--preset--gradient--midnight) !important;}.has-small-font-size{font-size: var(--wp--preset--font-size--small) !important;}.has-medium-font-size{font-size: var(--wp--preset--font-size--medium) !important;}.has-large-font-size{font-size: var(--wp--preset--font-size--large) !important;}.has-x-large-font-size{font-size: var(--wp--preset--font-size--x-large) !important;}
:where(.wp-block-post-template.is-layout-flex){gap: 1.25em;}:where(.wp-block-post-template.is-layout-grid){gap: 1.25em;}
:where(.wp-block-columns.is-layout-flex){gap: 2em;}:where(.wp-block-columns.is-layout-grid){gap: 2em;}
:root :where(.wp-block-pullquote){font-size: 1.5em;line-height: 1.6;}
</style>
<link rel='stylesheet' id='contact-form-7-css' href='https://libraries.mit.edu/app/plugins/contact-form-7/includes/css/styles.css?ver=6.1' type='text/css' media='all' />
<style id='contact-form-7-inline-css' type='text/css'>
.wpcf7 .wpcf7-recaptcha iframe {margin-bottom: 0;}.wpcf7 .wpcf7-recaptcha[data-align="center"] > div {margin: 0 auto;}.wpcf7 .wpcf7-recaptcha[data-align="right"] > div {margin: 0 0 0 auto;}
</style>
<link rel='stylesheet' id='sn-fontAwesome-css-css' href='//maxcdn.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css?ver=1.1' type='text/css' media='all' />
<link rel='stylesheet' id='sn-animate-css-css' href='https://libraries.mit.edu/app/plugins/dynamic-menu-manager/duogeek/inc/animate.css?ver=1.1' type='text/css' media='all' />
<link rel='stylesheet' id='dg-grid-css-css' href='https://libraries.mit.edu/app/plugins/dynamic-menu-manager/duogeek/inc/dg-grid.css?ver=1.1' type='text/css' media='all' />
<link rel='stylesheet' id='parent-styles-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/style.css?ver=0.8' type='text/css' media='all' />
<link rel='stylesheet' id='parent-global-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/css/build/global.css?ver=0.8' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='parent-ie-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/css/ie.css?ver=20121010' type='text/css' media='all' />
<![endif]-->
<link rel='stylesheet' id='adobe-fonts-css' href='//use.typekit.net/ixd2vgq.css?ver=0.8' type='text/css' media='all' />
<link rel='stylesheet' id='parent-forms-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/css/build/forms.css?ver=0.8' type='text/css' media='all' />
<link rel='stylesheet' id='cf7cf-style-css' href='https://libraries.mit.edu/app/plugins/cf7-conditional-fields/style.css?ver=2.2.3' type='text/css' media='all' />
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/libs/modernizr.min.js?ver=2.8.3" id="modernizr-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/jquery.min.js?ver=1.11.1-local" id="jquery-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/search-ie.js?ver=0.8" id="search-ie-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/search.js?ver=0.8" id="parent-search-js"></script>
<link rel="https://api.w.org/" href="https://libraries.mit.edu/wp-json/" /><link rel="alternate" title="JSON" type="application/json" href="https://libraries.mit.edu/wp-json/wp/v2/pages/149" /><link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://libraries.mit.edu/wp/xmlrpc.php?rsd" />
<meta name="generator" content="WordPress 6.8.2" />
<link rel="canonical" href="https://libraries.mit.edu/search/" />
<link rel='shortlink' href='https://libraries.mit.edu/?p=149' />
<link rel="alternate" title="oEmbed (JSON)" type="application/json+oembed" href="https://libraries.mit.edu/wp-json/oembed/1.0/embed?url=https%3A%2F%2Flibraries.mit.edu%2Fsearch%2F" />
<link rel="alternate" title="oEmbed (XML)" type="text/xml+oembed" href="https://libraries.mit.edu/wp-json/oembed/1.0/embed?url=https%3A%2F%2Flibraries.mit.edu%2Fsearch%2F&#038;format=xml" />

	<!-- Matomo Tag Manager -->
<script>
  var _mtm = window._mtm = window._mtm || [];
  _mtm.push({'mtm.startTime': (new Date().getTime()), 'event': 'mtm.Start'});
  (function() {
    var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
    g.async=true; g.src='https://matomo.libraries.mit.edu/js/container_oFWMSb3g.js'; s.parentNode.insertBefore(g,s);
  })();
</script>
<!-- End Matomo Tag Manager -->		<style type="text/css" id="wp-custom-css">
			/* special temporary styling for branded about page */
body.page-id-140 {
  background: #fff;
  color: #000;
}

body.page-id-140 .content {
  margin: 0;
  font-family: 'NHaasGroteskTxt', 'Helvetica Neue', 'Helvetica', 'Arial', sans-serif !important;
  line-height: 1.2;
}

body.page-id-140 .breadcrumbs--better {
  background-color: #555; 
  color: #eee;
}
body.page-id-140 .breadcrumbs--better a {
    color: #eee;
}

body.page-id-140 .main-content { 
  background: #fff url('/images/network-graphic/logo10.png') no-repeat right top;
  color: #000;
  padding-left: 0; 
  padding-right: 0;
  margin-bottom: 0;
}

body.page-id-140 .layout-band {
  padding: 2% 15px 1% 15px;
}

body.page-id-140 .ttl {
  font-family: 'NHaasGroteskDisp', 'Helvetica Neue', 'Helvetica', 'Arial', sans-serif !important; 
	font-weight: 600;
}
body.page-id-140 .main-content p {
  line-height: 1.1;
}

body.page-id-140 .main-content .list-unbulleted li {
  list-style: none;
  margin-left: 0;
}

body.page-id-140 .main-content .cta-link {
  transition: background-color ease-in-out .3s;
  display: inline-block;
  padding: 10px;  
  color: #000;
  font-size: 20px;
  font-weight: 600;
  text-decoration: underline;
}

body.page-id-140 .main-content .cta-link:hover {
  background-color: #d300cc;
  color: #fff;
}

body.page-id-140 .wrap-intro {
  padding: 4% 15px;
  color: #000;
}

body.page-id-140 .wrap-intro .ttl {
  font-size: 36px;
  font-weight: 600;
  line-height: .92;
  margin-bottom: .3em;
}

body.page-id-140 .wrap-intro .pull {
  font-size: 20px;
  line-height: 1.2;
}

body.page-id-140 .wrap-we-are {
  margin-top: 1rem;
}

body.page-id-140 .card { 
  transition: background-color ease-in-out .3s;
  background: #fff;
  color: #000;
  margin: 15px;
  padding-top: 5px;
  line-height: 0;
}

body.page-id-140 .card:hover {
  background-color: #0000FF;
  background-image: none;
  color: #fff;
}

body.page-id-140 .card:hover a {
  color: #fff !important;
}

body.page-id-140 .card .c-image {
  width: 100%;
  background-color: #000;
}

body.page-id-140 .card .c-content {
  padding: 10px 3%;
  font-size: 14px;
} 

body.page-id-140 .card .c-ttl1 {
  font-size: 20px;
  font-weight: 600;
  line-height: .92;
  margin: 0;
}

body.page-id-140 .card .c-ttl2 {
  margin-top: .2em;
  font-size: 14px;
  line-height: 1.2;
  font-weight: 400;
}

body.page-id-140 .wrap-fol {
  padding: 2% 15px 3% 15px;
  color: #000;
  font-size: 14px;
}

body.page-id-140 .wrap-fol .ttl {
  font-size: 36px;
  font-weight: 600;
  line-height: .92;
}

body.page-id-140 .wrap-fol .vision-item strong {
  display: block;
  margin: 1em 0 .2em 0;
  font-size: 20px;
  line-height: .92;
}

body.page-id-140 .wrap-fol .cta-link {
  margin-top: .5em;
}

body.page-id-140 .list-social {
  display: flex;
  justify-content: space-between;
}

body.page-id-140 .list-social a {
  flex: 1 1 auto;
  padding: 20px;  
  background-color: #fff;
  font-size: 28px;
  color: #234;  
  text-align: center;
}

body.page-id-140 .list-social a:hover {
  background-color: #00C800;
  color: #000;
}

body.page-id-140 .list-pipe {
  text-align: center;
}
body.page-id-140 .list-pipe li {
  list-style-type: none;
  display: inline-block;  
  margin: 0;  
  padding-right: 10px;
}
body.page-id-140 .list-pipe li:after  {
  content: "|";
  padding-left: 10px;
}

body.page-id-140 .list-pipe li:last-child:after  {
content: "";
}

@media only screen and (min-width: 768px) {

}

@media only screen and (min-width: 480px) {

  body.page-id-140 .wrap-case-studies, 
  body.page-id-140 .wrap-linkblocks {
    display: flex;
  } 
    
  body.page-id-140 .card {
    flex: 1 1 auto; 
    width: 30%; 
    align-items: stretch;
    margin: 15px 0 15px 15px;    
  }

  body.page-id-140 .card:last-child {
    margin-right: 15px;
  }
}


/* CREOS page styles */
body.page-id-27945 .title-page, 
body.page-id-27945 h2.subtitle {
	  font-family: 'NHaasGroteskTxt', 'Helvetica Neue', 'Khula', 'Helvetica', sans-serif !important;

}
body.page-id-27945 .title-page h1 {
	font-size: 110px;
	font-weight: 600;
	line-height: .8;
	margin-top: .2em;
}

body.page-id-27945 h2.subtitle {
	font-size: 24px;
	font-weight: 600;
	margin-bottom: .8em;
}
/* widget utility classes */
.sidebar .no-top-border {
	border-top: none;
}

.sidebar .hide-title .widget-title { 
	display: none;
}

.sidebar .callout.widget {
	background: #e4e4e4 ;
	border-top: 2px solid #c63 ;
	padding-left: 20px ;
	padding-right: 20px ;
		padding-top: 15px ;
		padding-bottom: 15px ;
		margin-bottom: 20px;
}		</style>
			<script>
		todayDate="";
	</script>
</head>

<body class="wp-singular page-template page-template-templates page-template-page page-template-templatespage-php page page-id-149 wp-theme-mitlib-parent page-search single-author">
	<div id="skip"><a href="#content">Skip to Main Content</a></div>
	<div class="wrap-page">
		<header class="header-main flex-container flex-end">
							<nav>
	<button class="menu--toggle"><!-- Mobile Hamburger icon -->
		<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="18.909px" height="13.091px" viewBox="2.182 6.545 18.909 13.091" enable-background="new 2.182 6.545 18.909 13.091" xml:space="preserve"><path d="M2.909,6.545h17.454c0.197,0,0.367,0.072,0.512,0.216c0.145,0.144,0.216,0.314,0.216,0.511s-0.071,0.367-0.216,0.511
		c-0.145,0.144-0.314,0.216-0.512,0.216H2.909c-0.197,0-0.367-0.072-0.511-0.216C2.254,7.639,2.182,7.469,2.182,7.272
		s0.072-0.367,0.216-0.511C2.542,6.617,2.712,6.545,2.909,6.545z M20.363,13.818H2.909c-0.197,0-0.367-0.072-0.511-0.216
		s-0.216-0.314-0.216-0.511c0-0.196,0.072-0.367,0.216-0.511s0.314-0.216,0.511-0.216h17.454c0.197,0,0.367,0.072,0.512,0.216
		s0.216,0.314,0.216,0.511c0,0.197-0.071,0.367-0.216,0.511S20.561,13.818,20.363,13.818z M20.363,19.636H2.909
		c-0.197,0-0.367-0.071-0.511-0.216s-0.216-0.314-0.216-0.511s0.072-0.367,0.216-0.511c0.144-0.145,0.314-0.217,0.511-0.217h17.454
		c0.197,0,0.367,0.072,0.512,0.217c0.145,0.144,0.216,0.314,0.216,0.511s-0.071,0.366-0.216,0.511S20.561,19.636,20.363,19.636z"/>
		</svg>
	</button><!-- end hamburger icon -->
</nav>

<!-- Menu shown on mobile screens, when the hamburger icon is tapped. -->
<nav id="nav-mobile" class="nav-main hidden-non-mobile" aria-hidden="true">
	<ul>
		<li><a href="/search" class="no-underline mobile-nav-link hide-mobile-nav-link">Search</a></li>
		<li><a href="/hours" class="no-underline mobile-nav-link hide-mobile-nav-link">Hours & locations</a></li>
		<li><a href="/borrow" class="no-underline mobile-nav-link hide-mobile-nav-link">Borrow & request</a></li>
		<li><a href="/research-support" class="no-underline mobile-nav-link hide-mobile-nav-link">Research support</a></li>
		<li><a href="/about" class="no-underline mobile-nav-link hide-mobile-nav-link">About</a></li>
	</ul>
</nav>
						
<h1 class="name-site group nav-logo">
	<a href="/" class="logo-mit-lib">
		<svg xmlns="http://www.w3.org/2000/svg" viewBox="5 -3 210 95"><title>MIT Libraries logo</title><path d="M8.12,9H20l4.35,15.65c.17.57.36,1.31.58,2.22s.44,1.81.67,2.68.53,2.12.8,3.25h.1c.23-1.13.48-2.22.75-3.25.2-.87.42-1.76.65-2.67s.43-1.65.6-2.22L32.92,9h12V44.75h-8.1V22.66c0-.93,0-1.95.1-3.05h-.1c-.27,1-.5,2-.7,2.85s-.38,1.61-.53,2.22l-.42,1.58-5.1,18.49h-7.3L17.67,26.3c-.1-.33-.25-.87-.45-1.6s-.38-1.48-.55-2.25-.42-1.82-.67-2.85h-.1v3c0,.8,0,1.6.08,2.4a8.53,8.53,0,0,1,0,1.75v18H8V9Zm40,0H57V44.75H48.12Zm22.1,7.45H59.82V9H89.57v7.45H79.07v28.3H70.22ZM8.12,50H17V78.25H33.64v7.5H8.12Zm28.7,0H45v6.6H36.82Zm0,10.15H45v25.6H36.82Zm27,26.4a9.82,9.82,0,0,1-4.55-1,7.9,7.9,0,0,1-3.2-3H56v3.2H48.2V50h8.15V63h.15a9.45,9.45,0,0,1,2.9-2.55,8.62,8.62,0,0,1,4.37-1,9.86,9.86,0,0,1,4.53,1,10,10,0,0,1,3.45,2.85A13.51,13.51,0,0,1,74,67.6a17.89,17.89,0,0,1,.7,5.4,19.45,19.45,0,0,1-.78,5.72A12.53,12.53,0,0,1,71.72,83a9.48,9.48,0,0,1-3.45,2.67A10.63,10.63,0,0,1,63.82,86.55Zm-2.3-6.45a4.14,4.14,0,0,0,3.67-1.92,9.45,9.45,0,0,0,1.28-5.27,9.74,9.74,0,0,0-1.28-5.3,4.2,4.2,0,0,0-3.77-2,4.43,4.43,0,0,0-4,2.1A9.7,9.7,0,0,0,56.12,73a8.49,8.49,0,0,0,1.45,5.17,4.69,4.69,0,0,0,4,2Zm15.11-20h7.8v4h.15a9.56,9.56,0,0,1,3-3.35,7.29,7.29,0,0,1,4-1,4.57,4.57,0,0,1,1.6.2v7H93a7.34,7.34,0,0,0-6,1.27q-2.16,1.78-2.16,6v11.5H76.63Zm26,26.3a12.1,12.1,0,0,1-3.53-.5,7.55,7.55,0,0,1-2.77-1.5A7,7,0,0,1,94.48,82a8.09,8.09,0,0,1-.66-3.4,7.29,7.29,0,0,1,.78-3.52,6.74,6.74,0,0,1,2.12-2.35,10.79,10.79,0,0,1,3.1-1.43,27,27,0,0,1,3.77-.75,24.35,24.35,0,0,0,5-1A1.93,1.93,0,0,0,110,67.7a2.56,2.56,0,0,0-.83-2,3.91,3.91,0,0,0-2.67-.7,4.41,4.41,0,0,0-3,.85,3.66,3.66,0,0,0-1.2,2.45H94.8a8.52,8.52,0,0,1,.8-3.4,8.14,8.14,0,0,1,2.17-2.8,10.65,10.65,0,0,1,3.58-1.9,16.29,16.29,0,0,1,5-.7,19.72,19.72,0,0,1,4.9.52,9.7,9.7,0,0,1,3.4,1.58,7.31,7.31,0,0,1,2.45,3,10.5,10.5,0,0,1,.8,4.25v12.9a13.08,13.08,0,0,0,.17,2.42,1.8,1.8,0,0,0,.73,1.23v.35h-7.9a3.53,3.53,0,0,1-.5-1.12,14.56,14.56,0,0,1-.35-1.72h0a8.4,8.4,0,0,1-2.73,2.54,10,10,0,0,1-4.68,1Zm2.6-5.2a5.46,5.46,0,0,0,3.68-1.2,4.27,4.27,0,0,0,1.42-3.35v-3a11.5,11.5,0,0,1-1.87.73c-.72.22-1.5.43-2.34.62a10.36,10.36,0,0,0-3.4,1.27,2.48,2.48,0,0,0-1,2.17,2.43,2.43,0,0,0,1,2.2,4.53,4.53,0,0,0,2.5.55h0Zm15.87-21h7.77v4H129a9.56,9.56,0,0,1,3-3.35,7.29,7.29,0,0,1,4-1,4.57,4.57,0,0,1,1.6.2v7h-.2a7.34,7.34,0,0,0-6,1.27c-1.49,1.22-2.24,3.22-2.23,6V85.75H121V60.15ZM140,50.1h8.13v6.6H140Zm0,10.15h8.13v25.5H140ZM164,86.6a15,15,0,0,1-5.7-1,12.07,12.07,0,0,1-4.3-2.85,12.84,12.84,0,0,1-2.7-4.33,15.07,15.07,0,0,1-1-5.4,14.74,14.74,0,0,1,1-5.33,12.72,12.72,0,0,1,2.7-4.3,12.58,12.58,0,0,1,4.13-2.94,14.62,14.62,0,0,1,10.28-.17,12.29,12.29,0,0,1,3.83,2.35A12.7,12.7,0,0,1,175.65,68a20.83,20.83,0,0,1,1.08,7.13H158.32a7.53,7.53,0,0,0,1.8,4.1,5.14,5.14,0,0,0,4,1.5,4.84,4.84,0,0,0,2.65-.68,4.28,4.28,0,0,0,1.6-1.87h8a9.47,9.47,0,0,1-1.5,3.33,10.85,10.85,0,0,1-2.8,2.73A12.06,12.06,0,0,1,168.49,86a15.31,15.31,0,0,1-4.52.5Zm4.5-16.3a6,6,0,0,0-1.5-3.65,4.37,4.37,0,0,0-3.3-1.35,4.64,4.64,0,0,0-3.6,1.35,7,7,0,0,0-1.65,3.65Zm21.9,16.35q-5.66,0-9-2.42a8.34,8.34,0,0,1-3.52-6.78h7.7A4.15,4.15,0,0,0,187,80.3a5.06,5.06,0,0,0,3.25,1,5.61,5.61,0,0,0,2.92-.65,2.08,2.08,0,0,0,1.08-1.9,1.82,1.82,0,0,0-.55-1.37,4.08,4.08,0,0,0-1.45-.85,11.46,11.46,0,0,0-2.08-.5c-.78-.11-1.59-.25-2.42-.42q-1.65-.3-3.3-.72a10,10,0,0,1-3-1.28,6.41,6.41,0,0,1-2.12-2.27,7.47,7.47,0,0,1-.8-3.68,7.21,7.21,0,0,1,.87-3.55,7.61,7.61,0,0,1,2.35-2.66,11.15,11.15,0,0,1,3.53-1.55,17.18,17.18,0,0,1,4.28-.52c3.63,0,6.42.73,8.35,2.2a8,8,0,0,1,3.2,6h-7.5a3,3,0,0,0-1.33-2.37,5.48,5.48,0,0,0-2.78-.62,5,5,0,0,0-2.52.58A1.9,1.9,0,0,0,186,67a1.34,1.34,0,0,0,.5,1.1,4.27,4.27,0,0,0,1.35.67,13.55,13.55,0,0,0,2,.48l2.33.4c1.13.2,2.27.44,3.42.73a10.5,10.5,0,0,1,3.17,1.32,7,7,0,0,1,2.3,2.42,7.84,7.84,0,0,1,.9,4,7.35,7.35,0,0,1-3.32,6.38,11.84,11.84,0,0,1-3.7,1.6,18.75,18.75,0,0,1-4.66.5Z" style="fill:#fff;" /></svg>
		<span class="sr">MIT Libraries</span>
	</a><!-- End MIT Libraries Logo -->
</h1><!-- End H1.name-site -->
							
<!-- Menu shown on non-mobile screens -->
<nav class="nav-main hidden-mobile" aria-label="Primary">
	<ul class="nav-main-list flex-container">
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-searchmenu-title" href="#" class="no-underline search-link main-nav-link menu-control">Search</a>
			</h2>
			<div aria-labelledby="main-nav-searchmenu-title" id="main-nav-searchmenu" class="links-sub flex-container group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Start here</h3>
					<ul class="list-unbulleted">
						<li><a href="/search">Search tools home</a></li>
						<li><a href="/search-collections">Search Our Collections <span class="about">Books, articles, and more</span></a></li>
						<li><a href="/worldcat">WorldCat<span class="about">Books &amp; more worldwide</span></a></li>
						<li><a href="https://libguides.mit.edu/az.php">Databases A-Z<span class="about">JSTOR, PubMed, Web of Science, etc.</span></a></li>
						<li><a href="/search-reserves">Course reserves</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">Also try</h3>
					<ul class="list-unbulleted">
						<li><a href="/google-scholar-tips">Google Scholar for MIT <span class="about">Change settings to get better access</span></a></li>
						<li><a href="/dspace">DSpace@MIT <span class="about">MIT research</span></a></li>
						<li><a href="/dome">Dome <span class="about">MIT-digitized images, maps, etc.</span></a></li>
						<li><a href="/site-search">Site search</a></li>
					</ul>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-hoursmenu-title" href="#" class="no-underline main-nav-link menu-control">Hours &amp; locations</a>
			</h2>
			<div aria-labelledby="main-nav-hoursmenu-title" id="main-nav-hoursmenu" class="links-sub flex-container group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Locations</h3>
					<ul class="list-unbulleted">
						<li><a href="/hours">Hours and locations home</a></li>
						<li><a href="/barker">Barker Library</a></li>
						<li><a href="/dewey">Dewey Library</a></li>
						<li><a href="/hayden">Hayden Library</a></li>
						<li><a href="/rotch">Rotch Library</a></li>
						<li><a href="/distinctive-collections">Distinctive Collections</a></li>
						<li><a href="/music">Lewis Music Library</a></li>
						<li><a href="/lsa">Library Storage Annex</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">Using the Libraries</h3>
					<ul class="list-unbulleted">
						<li><a href="/locations">Map of locations</a></li>
						<li><a href="/study">Study spaces</a></li>
						<li><a href="/disabilities">Persons with disabilities</a></li>
						<li><a href="/copying">Scan &amp; print</a></li>
						<li><a href="/exhibits">Exhibits &amp; galleries</a></li>
						<li><a href="/visitors">Visitors</a></li>
						<li><a href="/use-policies">Library use policy</a></li>
					</ul>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-borrowmenu-title" href="#" class="no-underline main-nav-link menu-control">Borrow &amp; request</a>
			</h2>
			<div aria-labelledby="main-nav-borrowmenu-title" id="main-nav-borrowmenu" class="links-sub flex-container group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Renew, request, suggest</h3>
					<ul class="list-unbulleted">
						<li><a href="/borrow">Borrow &amp; request home</a></li>
						<li><a href="/accounts">Accounts overview <span class="about">Your Account, ILLiad, Aeon, etc.</span></a></li>
						<li><a href="/search-collections">Search Our Collections <span class="about">Request items owned by MIT</span></a></li>
						<li><a href="/worldcat">WorldCat <span class="about">Request items not owned by MIT</span></a></li>
						<li><a href="/illiad">ILLiad <span class="about">Track your Interlibrary Borrowing requests</span></a></li>
						<li><a href="/suggest-purchase">Suggest a purchase</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">More information</h3>
					<ul class="list-unbulleted">
						<li><a href="/reserves">Course reserves</a></li>
						<li><a href="/borrow-direct">Borrow Direct <span class="about">Request items from Harvard, Yale, etc.</span></a></li>
						<li><a href="/otherlibraries">Visit non-MIT libraries <span class="about">Harvard, Borrow Direct, etc.</span></a></li>
					</ul>
				</div>
			</div>
		</li>
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-researchmenu-title" href="#" class="no-underline main-nav-link menu-control">Research support</a>
			</h2>
			<div aria-labelledby="main-nav-researchmenu-title" id="main-nav-researchmenu" class="links-sub flex-container push group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Help &amp; useful tools</h3>
					<ul class="list-unbulleted">
						<li><a href="/research-support">Research support home</a></li>
						<li><a href="/ask">Ask us <span class="about">Email, chat, call, drop by</span></a></li>
						<li><a href="/experts">Research guides &amp; expert librarians <span class="about">For every research interest</span></a></li>
						<li><a href="/authenticate">Authenticate to online resources <span class="about">Tips &amp; tricks</span></a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">Publishing &amp; content management</h3>
					<ul class="list-unbulleted">
						<li><a href="/references">Citation &amp; writing tools <span class="about">Mendeley, Zotero, &amp; Overleaf</span></a></li>
						<li><a href="/citing">Citing sources <span class="about">Avoid plagiarism, format references, etc.</span></a></li>
						<li><a href="/data-services">Data services <span class="about">GIS, data management, statistical support</span></a></li>
						<li><a href="/scholarly">Scholarly communications <span class="about">Open access, copyright, &amp; publishing</span></a></li>
						<li><a href="/apis">APIs for scholarly resources</a></li>
					</ul>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-aboutmenu-title" href="#" class="no-underline main-nav-link menu-control">About</a>
			</h2>
			<div aria-labelledby="main-nav-aboutmenu-title" id="main-nav-aboutmenu" class="links-sub flex-container push group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">About the Libraries</h3>
					<ul class="list-unbulleted">
						<li><a href="/about/">About us home</a></li>
						<li><a href="/contact">Contact us</a></li>
						<li><a href="/jobs">Jobs</a></li>
						<li><a href="/giving">Giving to the MIT Libraries</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">News, events, &amp; exhibits</h3>
					<a href="/events">Classes &amp; events</a>
					<a href="/news">News</a>
					<a href="/exhibits">Exhibits &amp; galleries</a>
					<a href="/news/in-the-media">In the media</a>
					<a href="/mit-reads/">MIT Reads</a>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end small chat push">
			<h2 class="main-nav-header">
				<a id="main-nav-askusmenu-title" href="#" class="no-underline main-nav-link menu-control"><svg version="1.1" xmlns="http://www.w3.org/2000/svg" x="0px" y="0px" width="16.593px" height="16px" viewBox="0 0 16.593 16" enable-background="new 0 0 16.593 16" xml:space="preserve"><path d="M16.593 6.278c0 1.074-0.074 2.148-0.241 3.185 -0.204 1.353-1.722 2.574-3.055 2.722 -1.353 0.131-2.686 0.204-4.02 0.223L5.74 15.833C5.63 15.944 5.481 16 5.334 16c-0.094 0-0.167-0.019-0.241-0.037C4.871 15.87 4.74 15.647 4.74 15.407V12.37c-0.481-0.036-0.963-0.055-1.443-0.111 -1.334-0.148-2.853-1.443-3.074-2.796C0.074 8.426 0 7.352 0 6.296c0-1.092 0.074-2.185 0.223-3.24 0.222-1.352 1.74-2.648 3.074-2.797C4.963 0.093 6.63 0 8.297 0s3.333 0.093 5 0.259c1.333 0.149 2.851 1.445 3.055 2.797C16.519 4.111 16.593 5.204 16.593 6.278"/></svg><span>Ask Us</span></a>
			</h2>
			<div aria-labelledby="main-nav-askusmenu-title" id="main-nav-askusmenu" class="links-sub push">
				<div class="wrap-button-chat">
					<div id='libchat_be2c654b63dd43f31c56295ee5d78d88'></div>
				</div>
				<a class="more" href="/ask">More ways to ask us</a>
			</div>
		</li>
		<li class="link-primary flex-end small">
			<h2 class="main-nav-header">
				<a href="/accounts" class="no-underline main-nav-link account-link">
					<svg version="1.1" xmlns="http://www.w3.org/2000/svg" x="0" y="0" width="15.4" height="16" viewBox="0 0 15.4 16" enable-background="new 0 0 15.445 16" xml:space="preserve"><path d="M13.4 15.7C12.2 15.9 10.4 16 7.7 16c-5.4 0-7.3-0.6-7.3-0.6 -0.3-0.1-0.4-0.4-0.4-0.7 0.3-1.6 1.2-2.5 2.5-3.3 0.3-0.2 0.8-0.4 1.2-0.6 0.8-0.3 1.8-0.7 2-1.3C5.8 9.2 5.7 8.6 5.2 7.9c-1.4-2.3-1.7-4.3-0.8-5.9C5.1 0.7 6.4 0 7.7 0c1.4 0 2.6 0.7 3.3 2 0.9 1.6 0.7 3.6-0.8 5.9C9.8 8.6 9.6 9.2 9.8 9.6c0.2 0.6 1.2 1 2 1.3 0.4 0.2 0.9 0.4 1.2 0.6 1.2 0.8 2.1 1.6 2.5 3.3 0.1 0.3-0.1 0.6-0.4 0.7C15 15.4 14.5 15.6 13.4 15.7"/></svg><span>Account</span>
				</a>
			</h2>
		</li>
	</ul>
</nav>
						<a class="link-logo-mit" href="http://www.mit.edu"><img src="https://cdn.libraries.mit.edu/files/branding/local/mit_logo_std_rgb_white.svg" height="32" alt="MIT logo" >
			</a><!-- End MIT Logo -->
							
<a href="/search" class="link-site-search hidden-non-mobile">
	<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="12" height="16" viewBox="0 0 12 12" class="icon-search"><path d="M7.273 0.727q1.187 0 2.19 0.585t1.588 1.588 0.585 2.19-0.585 2.19-1.588 1.588-2.19 0.585q-1.278 0-2.33-0.676l-3.284 3.301q-0.295 0.284-0.688 0.284-0.403 0-0.688-0.284t-0.284-0.688 0.284-0.688l3.301-3.284q-0.676-1.051-0.676-2.33 0-1.188 0.585-2.19t1.588-1.588 2.19-0.585zM7.273 8q0.591 0 1.128-0.23t0.929-0.622 0.622-0.929 0.23-1.128-0.23-1.128-0.622-0.929-0.929-0.622-1.128-0.23-1.128 0.23-0.929 0.622-0.622 0.929-0.23 1.128 0.23 1.128 0.622 0.929 0.929 0.622 1.128 0.23z"></path></svg>
	<span class="bottom">Search</span>
</a><!-- End /search -->

<a href="/accounts" class="link-account hidden-non-mobile">
	<svg version="1.1" xmlns="http://www.w3.org/2000/svg" x="0" y="0" width="15.4" height="16" viewBox="0 0 15.4 16" enable-background="new 0 0 15.445 16" xml:space="preserve" class="icon-account"><path d="M13.4 15.7C12.2 15.9 10.4 16 7.7 16c-5.4 0-7.3-0.6-7.3-0.6 -0.3-0.1-0.4-0.4-0.4-0.7 0.3-1.6 1.2-2.5 2.5-3.3 0.3-0.2 0.8-0.4 1.2-0.6 0.8-0.3 1.8-0.7 2-1.3C5.8 9.2 5.7 8.6 5.2 7.9c-1.4-2.3-1.7-4.3-0.8-5.9C5.1 0.7 6.4 0 7.7 0c1.4 0 2.6 0.7 3.3 2 0.9 1.6 0.7 3.6-0.8 5.9C9.8 8.6 9.6 9.2 9.8 9.6c0.2 0.6 1.2 1 2 1.3 0.4 0.2 0.9 0.4 1.2 0.6 1.2 0.8 2.1 1.6 2.5 3.3 0.1 0.3-0.1 0.6-0.4 0.7C15 15.4 14.5 15.6 13.4 15.7"/></svg>
	<span class="bottom">Account</span>
</a><!-- End /barton-account -->

<a href="/contact" class="link-contact hidden-non-mobile">
	<i class="fa fa-book" aria-hidden="true"></i>
	<span class="bottom">Contact</span>
</a><!-- End /contact -->
					</header>

	<div id="sidebar-search" class="widget-area" role="complementary">
		<noscript><p>It appears that your browser does not support javascript.</p><p>Search books and other media worldwide.</p>
<form action="https://mit.worldcat.org/search" method="get" id="booksearch">
	<div class="hidden">
		<input type="hidden" name="qt" value="wc_org_mit">
		<input type="hidden" name="qt" value="affiliate">
	</div>
	<div class="row">
		<input type="text" class="request" name="q" placeholder="Search books, films, music scores, maps...">
		<input type="submit" value="Search">
	</div>
</form>
</noscript><div id="multisearch" class="wrap-search nojs"><h2 id="searchtabsheader" class="sr">Search the MIT libraries</h2>
			<ul id="search_tabs_nav" aria-labelledby="searchtabsheader">
				<li><a id="tab-all" href="#search-all"><span>All</span></a></li>
				<li><a id="tab-books" href="#search-books"><span>Books + media</span></a></li>
				<li><a id="tab-articles" href="#search-articles"><span>Articles + chapters</span></a></li>
				<li><a id="tab-more" href="#search-more"><span>More...</span></a></li>
			</ul><div id="search-all" aria-labelledby="tab-all"><h3 class="sr">All panel</h3>
<form
	class="form search-bento"
	action="https://lib.mit.edu/search/bento"
	method="get"
	data-target="bento">
	<label for="searchinput-bento">Search the libraries</label>
	<div class="wrap-flex">
		<div class="flex-left">
			<input
				class="field field-text"
				type="text"
				id="searchinput-bento"
				name="q"
				placeholder="ex. artificial intelligence, journal of heat transfer, jstor, dresselhaus">
		</div>
		<div class="flex-right">
			<input class="button button-search" type="submit" value="Search">
		</div>
	</div>
</form>
<p class="also search-all">
	<a href="/search-advanced/">Advanced search</a> | <a href="/citation-search/">Citation search</a>
</p>
</div><div id="search-books" aria-labelledby="tab-books"><h3 class="sr">Books and media panel</h3>
<form
	action=""
	id="booksearch"
	method="get"
	class="form search-bookslocal">
	<div class="hidden"></div>
	<label for="searchinput-bookslocal">Search for books, ebooks, journals, databases, music, and videos</label>
	<div class="wrap-flex">
		<div class="flex-left">
			<div class="flex-left-inner">
				<input
					class="field field-text"
					id="searchinput-bookslocal"
					name="search"
					placeholder="ex. artificial intelligence, journal of heat transfer, jstor, dresselhaus"
					type="text">
				<div class="field-wrap-select">
					<label class="sr" for="searchlimit-bookslocal">limit to</label>
					<select class="field field-select" id="searchlimit-bookslocal" name="limit">
						<option value="">Keyword</option>
						<option value="TI">Title</option>
						<option value="AU">Author</option>
					</select>
				</div>
			</div>
			<ul id="books-target" class="select-books-target">
				<li>
					<label>
						<input type="radio" name="books-target" value="localbooks" checked="checked">at MIT
					</label>
				</li>
				<li>
					<label>
						<input type="radio" name="books-target" value="worldcat">libraries worldwide (WorldCat)
					</label>
				</li>
			</ul>
		</div>
		<div class="flex-right">
			<input class="button button-search" type="submit" value="Search">
		</div>
	</div>
</form>
<p class="also">Also search for:
	<a href="/search-mit-theses/">MIT theses</a> or
	<a href="/search-reserves/">Course reserves</a>
</p>
<script type="text/javascript">
function setPrimoSearch(form) {
	// Set action
	form.action = 'https://mit.primo.exlibrisgroup.com/discovery/search';

	// Load hidden fields
	jQuery(form).find(".hidden")
		.empty()
		.append('<input name="vid" value="01MIT_INST:MIT" type="hidden">')
		.append('<input name="tab" value="all" type="hidden">')
		.append('<input name="search_scope" value="catalog" type="hidden">')
		.append('<input name="lang" value="en" type="hidden">')
		.append('<input name="query" type="hidden">');

	// Build search field
	var searchtype = 'any';
	if ( form.limit.value == 'TI' ) {
		searchtype = 'title';
	} else if ( form.limit.value == 'AU' ) {
		searchtype = 'creator';
	}
	form.query.value = searchtype + ",contains," + form.search.value.replace(/[,]/g, " ");
}

function setWorldcatSearch(form) {
	// Set action
	form.action = 'https://mit.on.worldcat.org/search';

	// Load hidden fields
	jQuery(form).find(".hidden")
		.empty()
		.append('<input type="hidden" name="queryString">');

	// Transfer search string to actual field
	form.queryString.value = form.search.value.trim();

	// Build search field with title/author syntax
	if ( form.limit.value !== '' ) {
		form.queryString.value = form.limit.value.toLowerCase() + ':(' + form.queryString.value + ')';
	}
}

jQuery( document ).ready( function() {
	// Watch for form submissions
	jQuery( 'form#booksearch' ).on( 'submit', function(event) {
		// Read state of target
		var target = jQuery("#books-target input[name=books-target]:checked").val();

		if ( 'worldcat' === target ) {
			setWorldcatSearch(this);
		} else {
			setPrimoSearch(this);
		}
	});
});
</script>
</div><div id="search-articles" aria-labelledby="tab-articles"><h3 class="sr">Articles and chapters panel</h3>
<form
	class="form search-articles"
	action="https://mit.primo.exlibrisgroup.com/discovery/search"
	enctype="application/x-www-form-urlencoded; charset=utf-8"
	id="primosearch"
	method="get"
	data-target="eds">
	<div class="hidden">
		<input type="hidden" name="vid" value="01MIT_INST:MIT">
		<input type="hidden" name="tab" value="all">
		<input type="hidden" name="search_scope" value="cdi">
		<input type="hidden" name="lang" value="en">
		<input type="hidden" name="query" id="primoQuery">
	</div>
	<label for="searchinput-article">
		Search articles, book chapters, and more from scholarly journals, newspapers, and online collections
	</label>
	<div class="wrap-flex">
		<div class="flex-left">
			<div class="flex-left-inner">
				<input 
					class="field field-text" 
					type="text" 
					id="searchinput-article" 
					name="search" 
					placeholder="ex. game theory for control of optical networks, artificial intelligence, dresselhaus">
				<div class="field-wrap-select">
					<label class="sr" for="searchlimit-articles">limit to</label>
					<select class="field field-select" name="limit" id="searchlimit-articles">
						<option value="">Keyword</option>
						<option value="TI ">Title</option>
						<option value="AU ">Author</option>
					</select>
				</div>
			</div>
		</div>
		<div class="flex-right">
			<input class="button button-search" type="submit" value="Search">
		</div>
	</div>
</form>
<script type="text/javascript">
	jQuery( document ).ready( function() {
		jQuery( 'form#primosearch' ).on( 'submit', function() {
			// Primo uses comma-separated-values to influence search behavior for
			// keyword, title, and author searching. So we assemble the search 
			// string on submit.
			var searchtype = 'any';
			if ( this.limit.value.trim() == 'TI' ) {
				searchtype = 'title';
			} else if ( this.limit.value.trim() == 'AU' ) {
				searchtype = 'creator';
			}
			this.query.value = searchtype + ",contains," + this.search.value.replace(/[,]/g, " ");

			return true;
		});
	});
</script>
<p class="also">Also search for:
	<a href="/search-journals/">Journals</a> or
	<a href="/search-databases/">Databases</a> or use
	<a href="/citation-search/">Citation search</a>
</p>
</div><div id="search-more" aria-labelledby="tab-more"><h3 class="sr">More panel</h3>
<div class="wrap-3cols">
	<div class="col col-1">
		<h3 class="header-col">Looking for something else?</h3>
		<ul>
			<li><a href="/reserves">Course reserves</a></li>
			<li><a href="/theses">MIT theses</a></li>
			<li><a href="https://dspace.mit.edu">DSpace@MIT</a></li>
			<li><a href="https://archivesspace.mit.edu/">ArchivesSpace</a></li>
			<li><a href="https://dataverse.harvard.edu/dataverse/mit-libraries">MIT Libraries Dataverse</a></li>
			<li><a href="/experts/">Search tools by subject</a></li>
			<li><a href="/search">More search options: images, data, etc.</a></li>
		</ul>
	</div>
	<div class="col col-2">
		<h3 class="header-col">Other useful tools</h3>
		<ul>
			<li><a href="https://libraries.mit.edu/worldcat">WorldCat</a></li>
			<li><a href="https://libguides.mit.edu/google/googlescholar">Google Scholar for MIT</a></li>
		</ul>
	</div>
	<div class="col col-3">
		<h3 class="sr">Get help from a librarian</h3>
		<p class="wrap-askus">
			<a class="askus-link" href="https://libraries.mit.edu/ask">
				<span class="askus-name">Ask Us</span> 
				<span class="askus-desc">chat and email</span>
			</a>
		</p>
	</div>
</div>
<form class="form search-site" action="https://www.google.com/cse" method="get" data-target="google">
	<input type="hidden" name="cx" value="016240528703941589557:i7wrbu9cdxu">
	<input type="hidden" name="ie" value="UTF-8">
	<h3><label for="searchinput-site">Search the library website</label></h3>
	<div class="wrap-flex">
		<div class="flex-left">
			<input id="searchinput-site" class="field field-text" type="text" name="q" placeholder="ex. hours">
		</div>
		<div class="flex-right">
			<input type="submit" class="button button-search" name="sa" value="Search">
		</div>
	</div>
</form>
</div></div>	</div>

	<div class="breadcrumbs--better hidden-phone group" role="navigation" aria-label="breadcrumbs">
	<span><a href="/">Libraries home</a></span>
	Search<span></span></div>


	<div id="stage" class="inner" role="main">

					
<div class="title-page">
			<h1>Search</h1>
	</div>
		
		<div id="content" class="content has-sidebar">

							

<div class="main-content content-main">
	<div class="entry-content">
		<div class="entry-page-title">
				</div>
		<p>Use this page to learn about different ways you can search the MIT Libraries’ offerings.</p>
<h2>Use the Default Quick Search</h2>
<p>Our Quick Search is the default search on the Libraries’ homepage. This collects results from different library search tools and sorts the results into 4 categories:</p>
<ul>
<li>Books and media</li>
<li>Articles and book chapters</li>
<li>Archives and manuscript collections</li>
<li>Our library website and guides</li>
</ul>
<p>The tool will search the 4 categories and present the top results from each category. It is useful to see the full breadth of what MIT Libraries has on a particular topic or author.</p>
<h2>Go straight to our catalog</h2>
<p>Our catalog allows you to search through our books, archival collections, and physical media. It also searches online materials, including journal articles, ebooks, videos, and more. It does not search the library website.</p>
<ul>
<li>Shortcut URL: <a href="https://libraries.mit.edu/search-collections/">https://libraries.mit.edu/search-collections/</a></li>
<li>Main navigation under “Search” – see “Search Our Collections”</li>
</ul>
<h3>Use search tools for a targeted search</h3>
<ul>
<li>Click on “Advanced search” under the search box</li>
<li>Or switch to the “Books and media” or “Articles and chapters” tabs.</li>
</ul>
<p>Learn more about the different categories below.</p>
<h3>Books and media</h3>
<p>The “Books and media” tab searches our catalog for books, ebooks, databases, music, and videos. You can find materials not at MIT by selecting the “libraries worldwide” option and going to the item page to request it.</p>
<h3>Articles and chapters</h3>
<p>The “Articles and chapters” tab searches articles, book chapters, and more from scholarly journals, newspapers, etc.</p>
<h3><a id="othertools"></a>More&#8230;</h3>
<p>This tab also has links to other commonly used search tools. The “More” tab also provides a search box for the Libraries’ website.  Search here for library staff, services, research guides, etc.</p>
<h2>Search for specific materials</h2>
<ul>
<li><strong><a href="https://libguides.mit.edu/az.php">A-Z Databases</a></strong>: A filterable and searchable list of online resources, including databases, journals, and ebook platforms.</li>
<li><strong><a href="http://archnet.org/">Archnet</a></strong>: Resources on architecture, urbanism, environmental &amp; landscape design, visual culture, and conservation issues related to the Muslim world.</li>
<li><a href="http://archivesspace.mit.edu/"><strong>ArchivesSpace</strong></a>: Archives and manuscript collections in <a href="/distinctive-collections">Distinctive Collections</a>.</li>
<li><a href="https://libraries.mit.edu/dome"><strong>Dome</strong></a>: Search for images, maps, and other documents from the MIT Libraries’ digitized collections.</li>
<li><strong><a href="/dspace">DSpace@MIT</a></strong>: MIT theses, papers, articles, technical reports, and other research materials in MIT’s institutional repository.</li>
<li><a href="https://geodata.libraries.mit.edu/"><strong>GeoData</strong></a>: Find GIS/spatial data available at MIT.</li>
<li><a href="https://dataverse.harvard.edu/dataverse/mit-libraries"><strong>MIT Libraries Dataverse</strong></a>: A repository of datasets for use in academic research by the MIT community. For access details, see terms of use for each dataset.</li>
<li><a href="/experts"><strong>Subject guides + experts</strong></a>: Subject guides can help you figure out which databases to use to find specialized information for your subject. Or ask one of our librarians with subject expertise for help.</li>
</ul>
	</div>
</div>
			
								
	<div id="sidebarContent" class="sidebar span3">
		<div class="sidebarWidgets">
			<aside id="black-studio-tinymce-14" class="widget-odd widget-last widget-first widget-1 widget widget_black_studio_tinymce" role="complementary"><h2 class="widget-title">Ask us</h2><div class="textwidget"><p><strong><a href="/ask">Ask us<br /></a></strong>Via chat, email, phone</p>
<p><strong><a href="/consultations">Research consultation<br /></a></strong>Meet with an expert</p></div></aside>		</div>
	</div>      
			
		</div><!-- end div#content -->

	</div><!-- end div#stage -->


	<footer>

		<div class="footer-main flex-container">
	<div class="links-all flex-container">
		<div class="flex-item">
			<h4><a href="/search">Search</a></h4>
			<a href="/search-collections" class="link-sub">Search Our Collections</a>
			<a href="/worldcat" class="link-sub">WorldCat</a>
			<a href="https://libguides.mit.edu/az.php" class="link-sub">Databases A-Z</a>
			<a href="/search-reserves" class="link-sub">Course reserves</a>
			<a href="/site-search" class="link-sub">Site search</a>
			<a href="/search" class="link-sub">More search options</a>
		</div>
		<div class="flex-item">
			<h4><a href="/hours">Hours &amp; locations</a></h4>
			<a href="/hours" class="link-sub">Hours</a>
			<a href="/locations" class="link-sub">Map of locations</a>
			<a href="/study" class="link-sub">Study spaces</a>
			<a href="/exhibits" class="link-sub">Exhibits &amp; galleries</a>
		</div>
		<div class="flex-item">
			<h4><a href="/borrow">Borrow &amp; request</a></h4>
			<a href="/accounts" class="link-sub">Accounts overview</a>
			<a href="/reserves" class="link-sub">Course reserves</a>
			<a href="/otherlibraries" class="link-sub">Visit non-MIT libraries</a>
			<a href="/borrow" class="link-sub">More borrow &amp; request options</a>
		</div>
		<div class="flex-item">
			<h4><a href="/research-support">Research support</a></h4>
			<a href="/ask" class="link-sub">Ask us</a>
			<a href="/experts" class="link-sub">Research guides &amp; expert librarians</a>
			<a href="/scholarly" class="link-sub">Scholarly communications</a>
			<a href="/references" class="link-sub">Citation &amp; writing software</a>
			<a href="/research-support" class="link-sub">More research support options</a>
		</div>
		<div class="flex-item">
			<h4><a href="/about">About us</a></h4>
			<span class="link-sub"><a href="/contact">Contact us</a> | <a href="/follow">Follow us</a></span>
			<span class="link-sub"><a href="/news">News</a></span>
			<span class="link-sub"><a href="/events">Classes &amp; events</a></span>
			<span class="link-sub"><a href="/use-policies">Use policy</a></span>
			<span class="link-sub"><a href="/giving">Giving</a></span>
			<span class="link-sub"><a href="/about">More about us</a></span>
		</div>
	</div><!-- end div.links-all -->

	<div class="identity flex-container">
		<a href="/" class="logo-mit-lib"><img src="https://cdn.libraries.mit.edu/files/branding/local/mitlib-wordmark.svg" alt="MIT Libraries logo"></a><!-- End MIT Libraries Logo -->

		<div class="links-primary flex-container">
			<span><a href="https://libraries.mit.edu/privacy" class="link-sub">Privacy</a></span>
			<span><a href="https://libraries.mit.edu/permissions" class="link-sub">Permissions</a></span>
			<span><a href="https://libraries.mit.edu/accessibility" class="link-sub">Accessibility</a></span>
			<span><a href="https://libraries.mit.edu/contact" class="link-sub">Contact us</a></span>
		</div><!-- End div.links-primary -->

	</div><!-- End div.identity -->
</div>

		<div class="footer-info-institute">
			<a class="link-logo-mit" href="https://www.mit.edu">
				<img src="https://cdn.libraries.mit.edu/files/branding/local/mit_lockup_std-three-line_rgb_white.svg" alt="MIT" width="152">
			</a>

			<div class="license">Content created by the MIT Libraries, <a href="https://creativecommons.org/licenses/by-nc/4.0/">CC BY-NC</a> unless otherwise noted. <a href="https://libraries.mit.edu/research-support/notices/copyright-notify/">Notify us about copyright concerns</a>.</div>
		</div><!-- End div.footer-info-institure -->
	</footer>

</div><!-- End div.wrap-page -->

<script type="speculationrules">
{"prefetch":[{"source":"document","where":{"and":[{"href_matches":"\/*"},{"not":{"href_matches":["\/wp\/wp-*.php","\/wp\/wp-admin\/*","\/app\/uploads\/*","\/app\/*","\/app\/plugins\/*","\/app\/themes\/mitlib-parent\/*","\/*\\?(.+)"]}},{"not":{"selector_matches":"a[rel~=\"nofollow\"]"}},{"not":{"selector_matches":".no-prefetch, .no-prefetch a"}}]},"eagerness":"conservative"}]}
</script>
            <script type="text/javascript">
                jQuery(function($) {
                    function equalHeight(group) {
                        tallest = 0;
                        group.each(function() {
                            thisHeight = $(this).height();
                            if(thisHeight > tallest) {
                                tallest = thisHeight;
                            }
                        });
                        group.height(tallest);
                    }

                    equalHeight($(".dg-grid-shortcode .dg_grid-shortcode-col"));

                    $(window).resize(function() {
                        equalHeight($(".dg-grid-shortcode .dg_grid-shortcode-col"));
                    });
                });
            </script>
            <link rel='stylesheet' id='responsivetabs-css-css' href='https://libraries.mit.edu/app/plugins/mitlib-multisearch-widget/libs/responsive-tabs.css?ver=1.6.1' type='text/css' media='all' />
<link rel='stylesheet' id='multisearch-tabs-css' href='https://libraries.mit.edu/app/plugins/mitlib-multisearch-widget/mitlib-multisearch-widget.css?ver=1.3.0' type='text/css' media='all' />
<script type="text/javascript" src="https://libraries.mit.edu/wp/wp-includes/js/dist/hooks.min.js?ver=4d63a3d491d11ffd8ac6" id="wp-hooks-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/wp/wp-includes/js/dist/i18n.min.js?ver=5e580eb46a90c2b997e6" id="wp-i18n-js"></script>
<script type="text/javascript" id="wp-i18n-js-after">
/* <![CDATA[ */
wp.i18n.setLocaleData( { 'text direction\u0004ltr': [ 'ltr' ] } );
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/contact-form-7/includes/swv/js/index.js?ver=6.1" id="swv-js"></script>
<script type="text/javascript" id="contact-form-7-js-before">
/* <![CDATA[ */
var wpcf7 = {
    "api": {
        "root": "https:\/\/libraries.mit.edu\/wp-json\/",
        "namespace": "contact-form-7\/v1"
    }
};
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/contact-form-7/includes/js/index.js?ver=6.1" id="contact-form-7-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/dev.js?ver=0.8" id="dev-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/libchat.js?ver=0.8" id="libchat-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/menu.toggle.js?ver=0.8" id="menu-toggle-js"></script>
<script type="text/javascript" id="parent-production-js-before">
/* <![CDATA[ */
const THEME_ROOT = "https://libraries.mit.edu/app/themes/mitlib-parent";
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/alerts.js?ver=0.8" id="parent-production-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/core.js?ver=0.8" id="parent-interior-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/page-links-to/dist/new-tab.js?ver=3.3.7" id="page-links-to-js"></script>
<script type="text/javascript" id="wpcf7cf-scripts-js-extra">
/* <![CDATA[ */
var wpcf7cf_global_settings = {"ajaxurl":"https:\/\/libraries.mit.edu\/wp\/wp-admin\/admin-ajax.php"};
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/cf7-conditional-fields/js/scripts.js?ver=2.2.3" id="wpcf7cf-scripts-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/mitlib-multisearch-widget/libs/jquery.responsiveTabs.min.js?ver=1.6.1" id="responsivetabs-js-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/mitlib-multisearch-widget/mitlib-multisearch-widget.js?ver=1.4.1" id="multisearch-js-js"></script>
<script type="text/javascript">window.NREUM||(NREUM={});NREUM.info={"beacon":"bam.nr-data.net","licenseKey":"NRJS-03682cc69c1c5a39583","applicationID":"578343319","transactionName":"NQdVMkoCWUBYURENWAxNdgVMClhdFkIEA1I=","queueTime":0,"applicationTime":190,"atts":"GUBWRAIYSk4=","errorBeacon":"bam.nr-data.net","agent":""}</script></body>
</html>
", "response_headers": {"accept-ranges": ["bytes"], "age": ["427428"], "cache-control": ["public, max-age=604800"], "content-length": ["129095"], "content-type": ["text/html; charset=UTF-8"], "date": ["Tue, 09 Dec 2025 14:33:41 GMT"], "link": ["; rel=\"https://api.w.org/\", ; rel=\"alternate\"; title=\"JSON\"; type=\"application/json\", ; rel=shortlink"], "permissions-policy": ["geolocation=(), microphone=(), camera=()"], "referrer-policy": ["no-referrer-when-downgrade"], "server": ["nginx"], "strict-transport-security": ["max-age=300"], "vary": ["Accept-Encoding, Cookie"], "via": ["1.1 varnish"], "x-cache": ["HIT"], "x-cache-hits": ["1"], "x-content-type-options": ["nosniff"], "x-frame-options": ["SAMEORIGIN"], "x-pantheon-styx-hostname": ["styx-fe3-b-5df8569779-zckhf"], "x-served-by": ["cache-chi-kigq8000105-CHI"], "x-styx-req-id": ["dfbd42aa-d128-11f0-85c8-4ea4934838e2"], "x-timer": ["S1765290822.680357,VS0,VE3"], "x-orig-content-encoding": ["gzip"]}} +{"url": "https://libraries.mit.edu/about7/", "status": "active", "cdx_warc_filename": "rec-595f2ddb3156-mitlibwebsite-20251209142416123-6.warc.gz", "cdx_title": "About | MIT Libraries", "cdx_offset": "249278", "cdx_length": "38741", "html_base64": "<!DOCTYPE html>
<!--[if lte IE 9]><html class="no-js lte-ie9" lang="en"><![endif]-->
<!--[if !(IE 8) | !(IE 9) ]><!-->
<html lang="en-US" class="no-js">
<!--<![endif]-->
<head>
	<meta charset="UTF-8" /><script type="text/javascript">(window.NREUM||(NREUM={})).init={privacy:{cookies_enabled:true},ajax:{deny_list:["bam.nr-data.net"]},feature_flags:["soft_nav"],distributed_tracing:{enabled:true}};(window.NREUM||(NREUM={})).loader_config={agentID:"594398788",accountID:"3844800",trustKey:"66686",xpid:"Vw4DVV5TCBAFU1lRAwIEV10=",licenseKey:"NRJS-03682cc69c1c5a39583",applicationID:"578343319",browserID:"594398788"};;/*! For license information please see nr-loader-spa-1.303.0.min.js.LICENSE.txt */
(()=>{var e,t,r={384:(e,t,r)=>{"use strict";r.d(t,{NT:()=>s,US:()=>d,Zm:()=>a,bQ:()=>u,dV:()=>c,pV:()=>l});var n=r(6154),i=r(1863),o=r(1910);const s={beacon:"bam.nr-data.net",errorBeacon:"bam.nr-data.net"};function a(){return n.gm.NREUM||(n.gm.NREUM={}),void 0===n.gm.newrelic&&(n.gm.newrelic=n.gm.NREUM),n.gm.NREUM}function c(){let e=a();return e.o||(e.o={ST:n.gm.setTimeout,SI:n.gm.setImmediate||n.gm.setInterval,CT:n.gm.clearTimeout,XHR:n.gm.XMLHttpRequest,REQ:n.gm.Request,EV:n.gm.Event,PR:n.gm.Promise,MO:n.gm.MutationObserver,FETCH:n.gm.fetch,WS:n.gm.WebSocket},(0,o.i)(...Object.values(e.o))),e}function u(e,t){let r=a();r.initializedAgents??={},t.initializedAt={ms:(0,i.t)(),date:new Date},r.initializedAgents[e]=t}function d(e,t){a()[e]=t}function l(){return function(){let e=a();const t=e.info||{};e.info={beacon:s.beacon,errorBeacon:s.errorBeacon,...t}}(),function(){let e=a();const t=e.init||{};e.init={...t}}(),c(),function(){let e=a();const t=e.loader_config||{};e.loader_config={...t}}(),a()}},782:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.pageViewTiming},860:(e,t,r)=>{"use strict";r.d(t,{$J:()=>d,K7:()=>c,P3:()=>u,XX:()=>i,Yy:()=>a,df:()=>o,qY:()=>n,v4:()=>s});const n="events",i="jserrors",o="browser/blobs",s="rum",a="browser/logs",c={ajax:"ajax",genericEvents:"generic_events",jserrors:i,logging:"logging",metrics:"metrics",pageAction:"page_action",pageViewEvent:"page_view_event",pageViewTiming:"page_view_timing",sessionReplay:"session_replay",sessionTrace:"session_trace",softNav:"soft_navigations",spa:"spa"},u={[c.pageViewEvent]:1,[c.pageViewTiming]:2,[c.metrics]:3,[c.jserrors]:4,[c.spa]:5,[c.ajax]:6,[c.sessionTrace]:7,[c.softNav]:8,[c.sessionReplay]:9,[c.logging]:10,[c.genericEvents]:11},d={[c.pageViewEvent]:s,[c.pageViewTiming]:n,[c.ajax]:n,[c.spa]:n,[c.softNav]:n,[c.metrics]:i,[c.jserrors]:i,[c.sessionTrace]:o,[c.sessionReplay]:o,[c.logging]:a,[c.genericEvents]:"ins"}},944:(e,t,r)=>{"use strict";r.d(t,{R:()=>i});var n=r(3241);function i(e,t){"function"==typeof console.debug&&(console.debug("New Relic Warning: https://github.com/newrelic/newrelic-browser-agent/blob/main/docs/warning-codes.md#".concat(e),t),(0,n.W)({agentIdentifier:null,drained:null,type:"data",name:"warn",feature:"warn",data:{code:e,secondary:t}}))}},993:(e,t,r)=>{"use strict";r.d(t,{A$:()=>o,ET:()=>s,TZ:()=>a,p_:()=>i});var n=r(860);const i={ERROR:"ERROR",WARN:"WARN",INFO:"INFO",DEBUG:"DEBUG",TRACE:"TRACE"},o={OFF:0,ERROR:1,WARN:2,INFO:3,DEBUG:4,TRACE:5},s="log",a=n.K7.logging},1687:(e,t,r)=>{"use strict";r.d(t,{Ak:()=>u,Ze:()=>f,x3:()=>d});var n=r(3241),i=r(7836),o=r(3606),s=r(860),a=r(2646);const c={};function u(e,t){const r={staged:!1,priority:s.P3[t]||0};l(e),c[e].get(t)||c[e].set(t,r)}function d(e,t){e&&c[e]&&(c[e].get(t)&&c[e].delete(t),p(e,t,!1),c[e].size&&h(e))}function l(e){if(!e)throw new Error("agentIdentifier required");c[e]||(c[e]=new Map)}function f(e="",t="feature",r=!1){if(l(e),!e||!c[e].get(t)||r)return p(e,t);c[e].get(t).staged=!0,h(e)}function h(e){const t=Array.from(c[e]);t.every(([e,t])=>t.staged)&&(t.sort((e,t)=>e[1].priority-t[1].priority),t.forEach(([t])=>{c[e].delete(t),p(e,t)}))}function p(e,t,r=!0){const s=e?i.ee.get(e):i.ee,c=o.i.handlers;if(!s.aborted&&s.backlog&&c){if((0,n.W)({agentIdentifier:e,type:"lifecycle",name:"drain",feature:t}),r){const e=s.backlog[t],r=c[t];if(r){for(let t=0;e&&t<e.length;++t)g(e[t],r);Object.entries(r).forEach(([e,t])=>{Object.values(t||{}).forEach(t=>{t[0]?.on&&t[0]?.context()instanceof a.y&&t[0].on(e,t[1])})})}}s.isolatedBacklog||delete c[t],s.backlog[t]=null,s.emit("drain-"+t,[])}}function g(e,t){var r=e[1];Object.values(t[r]||{}).forEach(t=>{var r=e[0];if(t[0]===r){var n=t[1],i=e[3],o=e[2];n.apply(i,o)}})}},1741:(e,t,r)=>{"use strict";r.d(t,{W:()=>o});var n=r(944),i=r(4261);class o{#e(e,...t){if(this[e]!==o.prototype[e])return this[e](...t);(0,n.R)(35,e)}addPageAction(e,t){return this.#e(i.hG,e,t)}register(e){return this.#e(i.eY,e)}recordCustomEvent(e,t){return this.#e(i.fF,e,t)}setPageViewName(e,t){return this.#e(i.Fw,e,t)}setCustomAttribute(e,t,r){return this.#e(i.cD,e,t,r)}noticeError(e,t){return this.#e(i.o5,e,t)}setUserId(e){return this.#e(i.Dl,e)}setApplicationVersion(e){return this.#e(i.nb,e)}setErrorHandler(e){return this.#e(i.bt,e)}addRelease(e,t){return this.#e(i.k6,e,t)}log(e,t){return this.#e(i.$9,e,t)}start(){return this.#e(i.d3)}finished(e){return this.#e(i.BL,e)}recordReplay(){return this.#e(i.CH)}pauseReplay(){return this.#e(i.Tb)}addToTrace(e){return this.#e(i.U2,e)}setCurrentRouteName(e){return this.#e(i.PA,e)}interaction(e){return this.#e(i.dT,e)}wrapLogger(e,t,r){return this.#e(i.Wb,e,t,r)}measure(e,t){return this.#e(i.V1,e,t)}consent(e){return this.#e(i.Pv,e)}}},1863:(e,t,r)=>{"use strict";function n(){return Math.floor(performance.now())}r.d(t,{t:()=>n})},1910:(e,t,r)=>{"use strict";r.d(t,{i:()=>o});var n=r(944);const i=new Map;function o(...e){return e.every(e=>{if(i.has(e))return i.get(e);const t="function"==typeof e&&e.toString().includes("[native code]");return t||(0,n.R)(64,e?.name||e?.toString()),i.set(e,t),t})}},2555:(e,t,r)=>{"use strict";r.d(t,{D:()=>a,f:()=>s});var n=r(384),i=r(8122);const o={beacon:n.NT.beacon,errorBeacon:n.NT.errorBeacon,licenseKey:void 0,applicationID:void 0,sa:void 0,queueTime:void 0,applicationTime:void 0,ttGuid:void 0,user:void 0,account:void 0,product:void 0,extra:void 0,jsAttributes:{},userAttributes:void 0,atts:void 0,transactionName:void 0,tNamePlain:void 0};function s(e){try{return!!e.licenseKey&&!!e.errorBeacon&&!!e.applicationID}catch(e){return!1}}const a=e=>(0,i.a)(e,o)},2614:(e,t,r)=>{"use strict";r.d(t,{BB:()=>s,H3:()=>n,g:()=>u,iL:()=>c,tS:()=>a,uh:()=>i,wk:()=>o});const n="NRBA",i="SESSION",o=144e5,s=18e5,a={STARTED:"session-started",PAUSE:"session-pause",RESET:"session-reset",RESUME:"session-resume",UPDATE:"session-update"},c={SAME_TAB:"same-tab",CROSS_TAB:"cross-tab"},u={OFF:0,FULL:1,ERROR:2}},2646:(e,t,r)=>{"use strict";r.d(t,{y:()=>n});class n{constructor(e){this.contextId=e}}},2843:(e,t,r)=>{"use strict";r.d(t,{u:()=>i});var n=r(3878);function i(e,t=!1,r,i){(0,n.DD)("visibilitychange",function(){if(t)return void("hidden"===document.visibilityState&&e());e(document.visibilityState)},r,i)}},3241:(e,t,r)=>{"use strict";r.d(t,{W:()=>o});var n=r(6154);const i="newrelic";function o(e={}){try{n.gm.dispatchEvent(new CustomEvent(i,{detail:e}))}catch(e){}}},3304:(e,t,r)=>{"use strict";r.d(t,{A:()=>o});var n=r(7836);const i=()=>{const e=new WeakSet;return(t,r)=>{if("object"==typeof r&&null!==r){if(e.has(r))return;e.add(r)}return r}};function o(e){try{return JSON.stringify(e,i())??""}catch(e){try{n.ee.emit("internal-error",[e])}catch(e){}return""}}},3333:(e,t,r)=>{"use strict";r.d(t,{$v:()=>d,TZ:()=>n,Xh:()=>c,Zp:()=>i,kd:()=>u,mq:()=>a,nf:()=>s,qN:()=>o});const n=r(860).K7.genericEvents,i=["auxclick","click","copy","keydown","paste","scrollend"],o=["focus","blur"],s=4,a=1e3,c=2e3,u=["PageAction","UserAction","BrowserPerformance"],d={RESOURCES:"experimental.resources",REGISTER:"register"}},3434:(e,t,r)=>{"use strict";r.d(t,{Jt:()=>o,YM:()=>u});var n=r(7836),i=r(5607);const o="nr@original:".concat(i.W),s=50;var a=Object.prototype.hasOwnProperty,c=!1;function u(e,t){return e||(e=n.ee),r.inPlace=function(e,t,n,i,o){n||(n="");const s="-"===n.charAt(0);for(let a=0;a<t.length;a++){const c=t[a],u=e[c];l(u)||(e[c]=r(u,s?c+n:n,i,c,o))}},r.flag=o,r;function r(t,r,n,c,u){return l(t)?t:(r||(r=""),nrWrapper[o]=t,function(e,t,r){if(Object.defineProperty&&Object.keys)try{return Object.keys(e).forEach(function(r){Object.defineProperty(t,r,{get:function(){return e[r]},set:function(t){return e[r]=t,t}})}),t}catch(e){d([e],r)}for(var n in e)a.call(e,n)&&(t[n]=e[n])}(t,nrWrapper,e),nrWrapper);function nrWrapper(){var o,a,l,f;let h;try{a=this,o=[...arguments],l="function"==typeof n?n(o,a):n||{}}catch(t){d([t,"",[o,a,c],l],e)}i(r+"start",[o,a,c],l,u);const p=performance.now();let g;try{return f=t.apply(a,o),g=performance.now(),f}catch(e){throw g=performance.now(),i(r+"err",[o,a,e],l,u),h=e,h}finally{const e=g-p,t={start:p,end:g,duration:e,isLongTask:e>=s,methodName:c,thrownError:h};t.isLongTask&&i("long-task",[t,a],l,u),i(r+"end",[o,a,f],l,u)}}}function i(r,n,i,o){if(!c||t){var s=c;c=!0;try{e.emit(r,n,i,t,o)}catch(t){d([t,r,n,i],e)}c=s}}}function d(e,t){t||(t=n.ee);try{t.emit("internal-error",e)}catch(e){}}function l(e){return!(e&&"function"==typeof e&&e.apply&&!e[o])}},3606:(e,t,r)=>{"use strict";r.d(t,{i:()=>o});var n=r(9908);o.on=s;var i=o.handlers={};function o(e,t,r,o){s(o||n.d,i,e,t,r)}function s(e,t,r,i,o){o||(o="feature"),e||(e=n.d);var s=t[o]=t[o]||{};(s[r]=s[r]||[]).push([e,i])}},3738:(e,t,r)=>{"use strict";r.d(t,{He:()=>i,Kp:()=>a,Lc:()=>u,Rz:()=>d,TZ:()=>n,bD:()=>o,d3:()=>s,jx:()=>l,sl:()=>f,uP:()=>c});const n=r(860).K7.sessionTrace,i="bstResource",o="resource",s="-start",a="-end",c="fn"+s,u="fn"+a,d="pushState",l=1e3,f=3e4},3785:(e,t,r)=>{"use strict";r.d(t,{R:()=>c,b:()=>u});var n=r(9908),i=r(1863),o=r(860),s=r(8154),a=r(993);function c(e,t,r={},c=a.p_.INFO,u,d=(0,i.t)()){(0,n.p)(s.xV,["API/logging/".concat(c.toLowerCase(),"/called")],void 0,o.K7.metrics,e),(0,n.p)(a.ET,[d,t,r,c,u],void 0,o.K7.logging,e)}function u(e){return"string"==typeof e&&Object.values(a.p_).some(t=>t===e.toUpperCase().trim())}},3878:(e,t,r)=>{"use strict";function n(e,t){return{capture:e,passive:!1,signal:t}}function i(e,t,r=!1,i){window.addEventListener(e,t,n(r,i))}function o(e,t,r=!1,i){document.addEventListener(e,t,n(r,i))}r.d(t,{DD:()=>o,jT:()=>n,sp:()=>i})},3962:(e,t,r)=>{"use strict";r.d(t,{AM:()=>s,O2:()=>l,OV:()=>o,Qu:()=>f,TZ:()=>c,ih:()=>h,pP:()=>a,t1:()=>d,tC:()=>i,wD:()=>u});var n=r(860);const i=["click","keydown","submit"],o="popstate",s="api",a="initialPageLoad",c=n.K7.softNav,u=5e3,d=500,l={INITIAL_PAGE_LOAD:"",ROUTE_CHANGE:1,UNSPECIFIED:2},f={INTERACTION:1,AJAX:2,CUSTOM_END:3,CUSTOM_TRACER:4},h={IP:"in progress",PF:"pending finish",FIN:"finished",CAN:"cancelled"}},4234:(e,t,r)=>{"use strict";r.d(t,{W:()=>o});var n=r(7836),i=r(1687);class o{constructor(e,t){this.agentIdentifier=e,this.ee=n.ee.get(e),this.featureName=t,this.blocked=!1}deregisterDrain(){(0,i.x3)(this.agentIdentifier,this.featureName)}}},4261:(e,t,r)=>{"use strict";r.d(t,{$9:()=>d,BL:()=>c,CH:()=>p,Dl:()=>R,Fw:()=>w,PA:()=>v,Pl:()=>n,Pv:()=>A,Tb:()=>f,U2:()=>s,V1:()=>E,Wb:()=>T,bt:()=>y,cD:()=>b,d3:()=>x,dT:()=>u,eY:()=>g,fF:()=>h,hG:()=>o,hw:()=>i,k6:()=>a,nb:()=>m,o5:()=>l});const n="api-",i=n+"ixn-",o="addPageAction",s="addToTrace",a="addRelease",c="finished",u="interaction",d="log",l="noticeError",f="pauseReplay",h="recordCustomEvent",p="recordReplay",g="register",m="setApplicationVersion",v="setCurrentRouteName",b="setCustomAttribute",y="setErrorHandler",w="setPageViewName",R="setUserId",x="start",T="wrapLogger",E="measure",A="consent"},4387:(e,t,r)=>{"use strict";function n(e={}){return!(!e.id||!e.name)}function i(e){return"string"==typeof e&&e.trim().length<501||"number"==typeof e}function o(e,t){if(2!==t?.harvestEndpointVersion)return{};const r=t.agentRef.runtime.appMetadata.agents[0].entityGuid;return n(e)?{"mfe.id":e.id,"mfe.name":e.name,eventSource:e.eventSource,"parent.id":e.parent?.id||r}:{"entity.guid":r,appId:t.agentRef.info.applicationID}}r.d(t,{Ux:()=>o,c7:()=>n,yo:()=>i})},5205:(e,t,r)=>{"use strict";r.d(t,{j:()=>_});var n=r(384),i=r(1741);var o=r(2555),s=r(3333);const a=e=>{if(!e||"string"!=typeof e)return!1;try{document.createDocumentFragment().querySelector(e)}catch{return!1}return!0};var c=r(2614),u=r(944),d=r(8122);const l="[data-nr-mask]",f=e=>(0,d.a)(e,(()=>{const e={feature_flags:[],experimental:{allow_registered_children:!1,resources:!1},mask_selector:"*",block_selector:"[data-nr-block]",mask_input_options:{color:!1,date:!1,"datetime-local":!1,email:!1,month:!1,number:!1,range:!1,search:!1,tel:!1,text:!1,time:!1,url:!1,week:!1,textarea:!1,select:!1,password:!0}};return{ajax:{deny_list:void 0,block_internal:!0,enabled:!0,autoStart:!0},api:{get allow_registered_children(){return e.feature_flags.includes(s.$v.REGISTER)||e.experimental.allow_registered_children},set allow_registered_children(t){e.experimental.allow_registered_children=t},duplicate_registered_data:!1},browser_consent_mode:{enabled:!1},distributed_tracing:{enabled:void 0,exclude_newrelic_header:void 0,cors_use_newrelic_header:void 0,cors_use_tracecontext_headers:void 0,allowed_origins:void 0},get feature_flags(){return e.feature_flags},set feature_flags(t){e.feature_flags=t},generic_events:{enabled:!0,autoStart:!0},harvest:{interval:30},jserrors:{enabled:!0,autoStart:!0},logging:{enabled:!0,autoStart:!0},metrics:{enabled:!0,autoStart:!0},obfuscate:void 0,page_action:{enabled:!0},page_view_event:{enabled:!0,autoStart:!0},page_view_timing:{enabled:!0,autoStart:!0},performance:{capture_marks:!1,capture_measures:!1,capture_detail:!0,resources:{get enabled(){return e.feature_flags.includes(s.$v.RESOURCES)||e.experimental.resources},set enabled(t){e.experimental.resources=t},asset_types:[],first_party_domains:[],ignore_newrelic:!0}},privacy:{cookies_enabled:!0},proxy:{assets:void 0,beacon:void 0},session:{expiresMs:c.wk,inactiveMs:c.BB},session_replay:{autoStart:!0,enabled:!1,preload:!1,sampling_rate:10,error_sampling_rate:100,collect_fonts:!1,inline_images:!1,fix_stylesheets:!0,mask_all_inputs:!0,get mask_text_selector(){return e.mask_selector},set mask_text_selector(t){a(t)?e.mask_selector="".concat(t,",").concat(l):""===t||null===t?e.mask_selector=l:(0,u.R)(5,t)},get block_class(){return"nr-block"},get ignore_class(){return"nr-ignore"},get mask_text_class(){return"nr-mask"},get block_selector(){return e.block_selector},set block_selector(t){a(t)?e.block_selector+=",".concat(t):""!==t&&(0,u.R)(6,t)},get mask_input_options(){return e.mask_input_options},set mask_input_options(t){t&&"object"==typeof t?e.mask_input_options={...t,password:!0}:(0,u.R)(7,t)}},session_trace:{enabled:!0,autoStart:!0},soft_navigations:{enabled:!0,autoStart:!0},spa:{enabled:!0,autoStart:!0},ssl:void 0,user_actions:{enabled:!0,elementAttributes:["id","className","tagName","type"]}}})());var h=r(6154),p=r(9324);let g=0;const m={buildEnv:p.F3,distMethod:p.Xs,version:p.xv,originTime:h.WN},v={consented:!1},b={appMetadata:{},get consented(){return this.session?.state?.consent||v.consented},set consented(e){v.consented=e},customTransaction:void 0,denyList:void 0,disabled:!1,harvester:void 0,isolatedBacklog:!1,isRecording:!1,loaderType:void 0,maxBytes:3e4,obfuscator:void 0,onerror:void 0,ptid:void 0,releaseIds:{},session:void 0,timeKeeper:void 0,registeredEntities:[],jsAttributesMetadata:{bytes:0},get harvestCount(){return++g}},y=e=>{const t=(0,d.a)(e,b),r=Object.keys(m).reduce((e,t)=>(e[t]={value:m[t],writable:!1,configurable:!0,enumerable:!0},e),{});return Object.defineProperties(t,r)};var w=r(5701);const R=e=>{const t=e.startsWith("http");e+="/",r.p=t?e:"https://"+e};var x=r(7836),T=r(3241);const E={accountID:void 0,trustKey:void 0,agentID:void 0,licenseKey:void 0,applicationID:void 0,xpid:void 0},A=e=>(0,d.a)(e,E),S=new Set;function _(e,t={},r,s){let{init:a,info:c,loader_config:u,runtime:d={},exposed:l=!0}=t;if(!c){const e=(0,n.pV)();a=e.init,c=e.info,u=e.loader_config}e.init=f(a||{}),e.loader_config=A(u||{}),c.jsAttributes??={},h.bv&&(c.jsAttributes.isWorker=!0),e.info=(0,o.D)(c);const p=e.init,g=[c.beacon,c.errorBeacon];S.has(e.agentIdentifier)||(p.proxy.assets&&(R(p.proxy.assets),g.push(p.proxy.assets)),p.proxy.beacon&&g.push(p.proxy.beacon),e.beacons=[...g],function(e){const t=(0,n.pV)();Object.getOwnPropertyNames(i.W.prototype).forEach(r=>{const n=i.W.prototype[r];if("function"!=typeof n||"constructor"===n)return;let o=t[r];e[r]&&!1!==e.exposed&&"micro-agent"!==e.runtime?.loaderType&&(t[r]=(...t)=>{const n=e[r](...t);return o?o(...t):n})})}(e),(0,n.US)("activatedFeatures",w.B),e.runSoftNavOverSpa&&=!0===p.soft_navigations.enabled&&p.feature_flags.includes("soft_nav")),d.denyList=[...p.ajax.deny_list||[],...p.ajax.block_internal?g:[]],d.ptid=e.agentIdentifier,d.loaderType=r,e.runtime=y(d),S.has(e.agentIdentifier)||(e.ee=x.ee.get(e.agentIdentifier),e.exposed=l,(0,T.W)({agentIdentifier:e.agentIdentifier,drained:!!w.B?.[e.agentIdentifier],type:"lifecycle",name:"initialize",feature:void 0,data:e.config})),S.add(e.agentIdentifier)}},5270:(e,t,r)=>{"use strict";r.d(t,{Aw:()=>s,SR:()=>o,rF:()=>a});var n=r(384),i=r(7767);function o(e){return!!(0,n.dV)().o.MO&&(0,i.V)(e)&&!0===e?.session_trace.enabled}function s(e){return!0===e?.session_replay.preload&&o(e)}function a(e,t){try{if("string"==typeof t?.type){if("password"===t.type.toLowerCase())return"*".repeat(e?.length||0);if(void 0!==t?.dataset?.nrUnmask||t?.classList?.contains("nr-unmask"))return e}}catch(e){}return"string"==typeof e?e.replace(/[\S]/g,"*"):"*".repeat(e?.length||0)}},5289:(e,t,r)=>{"use strict";r.d(t,{GG:()=>o,Qr:()=>a,sB:()=>s});var n=r(3878);function i(){return"undefined"==typeof document||"complete"===document.readyState}function o(e,t){if(i())return e();(0,n.sp)("load",e,t)}function s(e){if(i())return e();(0,n.DD)("DOMContentLoaded",e)}function a(e){if(i())return e();(0,n.sp)("popstate",e)}},5607:(e,t,r)=>{"use strict";r.d(t,{W:()=>n});const n=(0,r(9566).bz)()},5701:(e,t,r)=>{"use strict";r.d(t,{B:()=>o,t:()=>s});var n=r(3241);const i=new Set,o={};function s(e,t){const r=t.agentIdentifier;o[r]??={},e&&"object"==typeof e&&(i.has(r)||(t.ee.emit("rumresp",[e]),o[r]=e,i.add(r),(0,n.W)({agentIdentifier:r,loaded:!0,drained:!0,type:"lifecycle",name:"load",feature:void 0,data:e})))}},6154:(e,t,r)=>{"use strict";r.d(t,{A4:()=>a,OF:()=>d,RI:()=>i,WN:()=>h,bv:()=>o,gm:()=>s,lR:()=>f,m:()=>u,mw:()=>c,sb:()=>l});var n=r(1863);const i="undefined"!=typeof window&&!!window.document,o="undefined"!=typeof WorkerGlobalScope&&("undefined"!=typeof self&&self instanceof WorkerGlobalScope&&self.navigator instanceof WorkerNavigator||"undefined"!=typeof globalThis&&globalThis instanceof WorkerGlobalScope&&globalThis.navigator instanceof WorkerNavigator),s=i?window:"undefined"!=typeof WorkerGlobalScope&&("undefined"!=typeof self&&self instanceof WorkerGlobalScope&&self||"undefined"!=typeof globalThis&&globalThis instanceof WorkerGlobalScope&&globalThis),a="complete"===s?.document?.readyState,c=Boolean("hidden"===s?.document?.visibilityState),u=""+s?.location,d=/iPad|iPhone|iPod/.test(s.navigator?.userAgent),l=d&&"undefined"==typeof SharedWorker,f=(()=>{const e=s.navigator?.userAgent?.match(/Firefox[/\s](\d+\.\d+)/);return Array.isArray(e)&&e.length>=2?+e[1]:0})(),h=Date.now()-(0,n.t)()},6344:(e,t,r)=>{"use strict";r.d(t,{BB:()=>d,Qb:()=>l,TZ:()=>i,Ug:()=>s,Vh:()=>o,_s:()=>a,bc:()=>u,yP:()=>c});var n=r(2614);const i=r(860).K7.sessionReplay,o="errorDuringReplay",s=.12,a={DomContentLoaded:0,Load:1,FullSnapshot:2,IncrementalSnapshot:3,Meta:4,Custom:5},c={[n.g.ERROR]:15e3,[n.g.FULL]:3e5,[n.g.OFF]:0},u={RESET:{message:"Session was reset",sm:"Reset"},IMPORT:{message:"Recorder failed to import",sm:"Import"},TOO_MANY:{message:"429: Too Many Requests",sm:"Too-Many"},TOO_BIG:{message:"Payload was too large",sm:"Too-Big"},CROSS_TAB:{message:"Session Entity was set to OFF on another tab",sm:"Cross-Tab"},ENTITLEMENTS:{message:"Session Replay is not allowed and will not be started",sm:"Entitlement"}},d=5e3,l={API:"api",RESUME:"resume",SWITCH_TO_FULL:"switchToFull",INITIALIZE:"initialize",PRELOAD:"preload"}},6389:(e,t,r)=>{"use strict";function n(e,t=500,r={}){const n=r?.leading||!1;let i;return(...r)=>{n&&void 0===i&&(e.apply(this,r),i=setTimeout(()=>{i=clearTimeout(i)},t)),n||(clearTimeout(i),i=setTimeout(()=>{e.apply(this,r)},t))}}function i(e){let t=!1;return(...r)=>{t||(t=!0,e.apply(this,r))}}r.d(t,{J:()=>i,s:()=>n})},6630:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.pageViewEvent},6774:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.jserrors},7295:(e,t,r)=>{"use strict";r.d(t,{Xv:()=>s,gX:()=>i,iW:()=>o});var n=[];function i(e){if(!e||o(e))return!1;if(0===n.length)return!0;for(var t=0;t<n.length;t++){var r=n[t];if("*"===r.hostname)return!1;if(a(r.hostname,e.hostname)&&c(r.pathname,e.pathname))return!1}return!0}function o(e){return void 0===e.hostname}function s(e){if(n=[],e&&e.length)for(var t=0;t<e.length;t++){let r=e[t];if(!r)continue;0===r.indexOf("http://")?r=r.substring(7):0===r.indexOf("https://")&&(r=r.substring(8));const i=r.indexOf("/");let o,s;i>0?(o=r.substring(0,i),s=r.substring(i)):(o=r,s="");let[a]=o.split(":");n.push({hostname:a,pathname:s})}}function a(e,t){return!(e.length>t.length)&&t.indexOf(e)===t.length-e.length}function c(e,t){return 0===e.indexOf("/")&&(e=e.substring(1)),0===t.indexOf("/")&&(t=t.substring(1)),""===e||e===t}},7378:(e,t,r)=>{"use strict";r.d(t,{$p:()=>x,BR:()=>b,Kp:()=>R,L3:()=>y,Lc:()=>c,NC:()=>o,SG:()=>d,TZ:()=>i,U6:()=>p,UT:()=>m,d3:()=>w,dT:()=>f,e5:()=>E,gx:()=>v,l9:()=>l,oW:()=>h,op:()=>g,rw:()=>u,tH:()=>A,uP:()=>a,wW:()=>T,xq:()=>s});var n=r(384);const i=r(860).K7.spa,o=["click","submit","keypress","keydown","keyup","change"],s=999,a="fn-start",c="fn-end",u="cb-start",d="api-ixn-",l="remaining",f="interaction",h="spaNode",p="jsonpNode",g="fetch-start",m="fetch-done",v="fetch-body-",b="jsonp-end",y=(0,n.dV)().o.ST,w="-start",R="-end",x="-body",T="cb"+R,E="jsTime",A="fetch"},7485:(e,t,r)=>{"use strict";r.d(t,{D:()=>i});var n=r(6154);function i(e){if(0===(e||"").indexOf("data:"))return{protocol:"data"};try{const t=new URL(e,location.href),r={port:t.port,hostname:t.hostname,pathname:t.pathname,search:t.search,protocol:t.protocol.slice(0,t.protocol.indexOf(":")),sameOrigin:t.protocol===n.gm?.location?.protocol&&t.host===n.gm?.location?.host};return r.port&&""!==r.port||("http:"===t.protocol&&(r.port="80"),"https:"===t.protocol&&(r.port="443")),r.pathname&&""!==r.pathname?r.pathname.startsWith("/")||(r.pathname="/".concat(r.pathname)):r.pathname="/",r}catch(e){return{}}}},7699:(e,t,r)=>{"use strict";r.d(t,{It:()=>o,KC:()=>a,No:()=>i,qh:()=>s});var n=r(860);const i=16e3,o=1e6,s="SESSION_ERROR",a={[n.K7.logging]:!0,[n.K7.genericEvents]:!1,[n.K7.jserrors]:!1,[n.K7.ajax]:!1}},7767:(e,t,r)=>{"use strict";r.d(t,{V:()=>i});var n=r(6154);const i=e=>n.RI&&!0===e?.privacy.cookies_enabled},7836:(e,t,r)=>{"use strict";r.d(t,{P:()=>a,ee:()=>c});var n=r(384),i=r(8990),o=r(2646),s=r(5607);const a="nr@context:".concat(s.W),c=function e(t,r){var n={},s={},d={},l=!1;try{l=16===r.length&&u.initializedAgents?.[r]?.runtime.isolatedBacklog}catch(e){}var f={on:p,addEventListener:p,removeEventListener:function(e,t){var r=n[e];if(!r)return;for(var i=0;i<r.length;i++)r[i]===t&&r.splice(i,1)},emit:function(e,r,n,i,o){!1!==o&&(o=!0);if(c.aborted&&!i)return;t&&o&&t.emit(e,r,n);var a=h(n);g(e).forEach(e=>{e.apply(a,r)});var u=v()[s[e]];u&&u.push([f,e,r,a]);return a},get:m,listeners:g,context:h,buffer:function(e,t){const r=v();if(t=t||"feature",f.aborted)return;Object.entries(e||{}).forEach(([e,n])=>{s[n]=t,t in r||(r[t]=[])})},abort:function(){f._aborted=!0,Object.keys(f.backlog).forEach(e=>{delete f.backlog[e]})},isBuffering:function(e){return!!v()[s[e]]},debugId:r,backlog:l?{}:t&&"object"==typeof t.backlog?t.backlog:{},isolatedBacklog:l};return Object.defineProperty(f,"aborted",{get:()=>{let e=f._aborted||!1;return e||(t&&(e=t.aborted),e)}}),f;function h(e){return e&&e instanceof o.y?e:e?(0,i.I)(e,a,()=>new o.y(a)):new o.y(a)}function p(e,t){n[e]=g(e).concat(t)}function g(e){return n[e]||[]}function m(t){return d[t]=d[t]||e(f,t)}function v(){return f.backlog}}(void 0,"globalEE"),u=(0,n.Zm)();u.ee||(u.ee=c)},8122:(e,t,r)=>{"use strict";r.d(t,{a:()=>i});var n=r(944);function i(e,t){try{if(!e||"object"!=typeof e)return(0,n.R)(3);if(!t||"object"!=typeof t)return(0,n.R)(4);const r=Object.create(Object.getPrototypeOf(t),Object.getOwnPropertyDescriptors(t)),o=0===Object.keys(r).length?e:r;for(let s in o)if(void 0!==e[s])try{if(null===e[s]){r[s]=null;continue}Array.isArray(e[s])&&Array.isArray(t[s])?r[s]=Array.from(new Set([...e[s],...t[s]])):"object"==typeof e[s]&&"object"==typeof t[s]?r[s]=i(e[s],t[s]):r[s]=e[s]}catch(e){r[s]||(0,n.R)(1,e)}return r}catch(e){(0,n.R)(2,e)}}},8139:(e,t,r)=>{"use strict";r.d(t,{u:()=>f});var n=r(7836),i=r(3434),o=r(8990),s=r(6154);const a={},c=s.gm.XMLHttpRequest,u="addEventListener",d="removeEventListener",l="nr@wrapped:".concat(n.P);function f(e){var t=function(e){return(e||n.ee).get("events")}(e);if(a[t.debugId]++)return t;a[t.debugId]=1;var r=(0,i.YM)(t,!0);function f(e){r.inPlace(e,[u,d],"-",p)}function p(e,t){return e[1]}return"getPrototypeOf"in Object&&(s.RI&&h(document,f),c&&h(c.prototype,f),h(s.gm,f)),t.on(u+"-start",function(e,t){var n=e[1];if(null!==n&&("function"==typeof n||"object"==typeof n)&&"newrelic"!==e[0]){var i=(0,o.I)(n,l,function(){var e={object:function(){if("function"!=typeof n.handleEvent)return;return n.handleEvent.apply(n,arguments)},function:n}[typeof n];return e?r(e,"fn-",null,e.name||"anonymous"):n});this.wrapped=e[1]=i}}),t.on(d+"-start",function(e){e[1]=this.wrapped||e[1]}),t}function h(e,t,...r){let n=e;for(;"object"==typeof n&&!Object.prototype.hasOwnProperty.call(n,u);)n=Object.getPrototypeOf(n);n&&t(n,...r)}},8154:(e,t,r)=>{"use strict";r.d(t,{z_:()=>o,XG:()=>a,TZ:()=>n,rs:()=>i,xV:()=>s});r(6154),r(9566),r(384);const n=r(860).K7.metrics,i="sm",o="cm",s="storeSupportabilityMetrics",a="storeEventMetrics"},8374:(e,t,r)=>{r.nc=(()=>{try{return document?.currentScript?.nonce}catch(e){}return""})()},8990:(e,t,r)=>{"use strict";r.d(t,{I:()=>i});var n=Object.prototype.hasOwnProperty;function i(e,t,r){if(n.call(e,t))return e[t];var i=r();if(Object.defineProperty&&Object.keys)try{return Object.defineProperty(e,t,{value:i,writable:!0,enumerable:!1}),i}catch(e){}return e[t]=i,i}},9300:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.ajax},9324:(e,t,r)=>{"use strict";r.d(t,{AJ:()=>s,F3:()=>i,Xs:()=>o,Yq:()=>a,xv:()=>n});const n="1.303.0",i="PROD",o="CDN",s="@newrelic/rrweb",a="1.0.1"},9566:(e,t,r)=>{"use strict";r.d(t,{LA:()=>a,ZF:()=>c,bz:()=>s,el:()=>u});var n=r(6154);const i="xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";function o(e,t){return e?15&e[t]:16*Math.random()|0}function s(){const e=n.gm?.crypto||n.gm?.msCrypto;let t,r=0;return e&&e.getRandomValues&&(t=e.getRandomValues(new Uint8Array(30))),i.split("").map(e=>"x"===e?o(t,r++).toString(16):"y"===e?(3&o()|8).toString(16):e).join("")}function a(e){const t=n.gm?.crypto||n.gm?.msCrypto;let r,i=0;t&&t.getRandomValues&&(r=t.getRandomValues(new Uint8Array(e)));const s=[];for(var a=0;a<e;a++)s.push(o(r,i++).toString(16));return s.join("")}function c(){return a(16)}function u(){return a(32)}},9908:(e,t,r)=>{"use strict";r.d(t,{d:()=>n,p:()=>i});var n=r(7836).ee.get("handle");function i(e,t,r,i,o){o?(o.buffer([e],i),o.emit(e,t,r)):(n.buffer([e],i),n.emit(e,t,r))}}},n={};function i(e){var t=n[e];if(void 0!==t)return t.exports;var o=n[e]={exports:{}};return r[e](o,o.exports,i),o.exports}i.m=r,i.d=(e,t)=>{for(var r in t)i.o(t,r)&&!i.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},i.f={},i.e=e=>Promise.all(Object.keys(i.f).reduce((t,r)=>(i.f[r](e,t),t),[])),i.u=e=>({212:"nr-spa-compressor",249:"nr-spa-recorder",478:"nr-spa"}[e]+"-1.303.0.min.js"),i.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),e={},t="NRBA-1.303.0.PROD:",i.l=(r,n,o,s)=>{if(e[r])e[r].push(n);else{var a,c;if(void 0!==o)for(var u=document.getElementsByTagName("script"),d=0;d<u.length;d++){var l=u[d];if(l.getAttribute("src")==r||l.getAttribute("data-webpack")==t+o){a=l;break}}if(!a){c=!0;var f={478:"sha512-Q1pLqcoiNmLHv0rtq3wFkJBA3kofBdRJl0ExDl0mTuAoCBd0qe/1J0XWrDlQKuNlUryL6aZfVkAMPLmoikWIoQ==",249:"sha512-695ZzudsxlMtHKnpDNvkMlJd3tdMtY03IQKVCw9SX12tjUC+f7Nrx5tnWO72Vg9RFf6DSY6wVmM3cEkRM12kkQ==",212:"sha512-18Gx1wIBsppcn0AnKFhwgw4IciNgFxiw3J74W393Ape+wtg4hlg7t6SBKsIE/Dk/tfl2yltgcgBFvYRs283AFg=="};(a=document.createElement("script")).charset="utf-8",i.nc&&a.setAttribute("nonce",i.nc),a.setAttribute("data-webpack",t+o),a.src=r,0!==a.src.indexOf(window.location.origin+"/")&&(a.crossOrigin="anonymous"),f[s]&&(a.integrity=f[s])}e[r]=[n];var h=(t,n)=>{a.onerror=a.onload=null,clearTimeout(p);var i=e[r];if(delete e[r],a.parentNode&&a.parentNode.removeChild(a),i&&i.forEach(e=>e(n)),t)return t(n)},p=setTimeout(h.bind(null,void 0,{type:"timeout",target:a}),12e4);a.onerror=h.bind(null,a.onerror),a.onload=h.bind(null,a.onload),c&&document.head.appendChild(a)}},i.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},i.p="https://js-agent.newrelic.com/",(()=>{var e={38:0,788:0};i.f.j=(t,r)=>{var n=i.o(e,t)?e[t]:void 0;if(0!==n)if(n)r.push(n[2]);else{var o=new Promise((r,i)=>n=e[t]=[r,i]);r.push(n[2]=o);var s=i.p+i.u(t),a=new Error;i.l(s,r=>{if(i.o(e,t)&&(0!==(n=e[t])&&(e[t]=void 0),n)){var o=r&&("load"===r.type?"missing":r.type),s=r&&r.target&&r.target.src;a.message="Loading chunk "+t+" failed.\n("+o+": "+s+")",a.name="ChunkLoadError",a.type=o,a.request=s,n[1](a)}},"chunk-"+t,t)}};var t=(t,r)=>{var n,o,[s,a,c]=r,u=0;if(s.some(t=>0!==e[t])){for(n in a)i.o(a,n)&&(i.m[n]=a[n]);if(c)c(i)}for(t&&t(r);u<s.length;u++)o=s[u],i.o(e,o)&&e[o]&&e[o][0](),e[o]=0},r=self["webpackChunk:NRBA-1.303.0.PROD"]=self["webpackChunk:NRBA-1.303.0.PROD"]||[];r.forEach(t.bind(null,0)),r.push=t.bind(null,r.push.bind(r))})(),(()=>{"use strict";i(8374);var e=i(9566),t=i(1741);class r extends t.W{agentIdentifier=(0,e.LA)(16)}var n=i(860);const o=Object.values(n.K7);var s=i(5205);var a=i(9908),c=i(1863),u=i(4261),d=i(3241),l=i(944),f=i(5701),h=i(8154);function p(e,t,i,o){const s=o||i;!s||s[e]&&s[e]!==r.prototype[e]||(s[e]=function(){(0,a.p)(h.xV,["API/"+e+"/called"],void 0,n.K7.metrics,i.ee),(0,d.W)({agentIdentifier:i.agentIdentifier,drained:!!f.B?.[i.agentIdentifier],type:"data",name:"api",feature:u.Pl+e,data:{}});try{return t.apply(this,arguments)}catch(e){(0,l.R)(23,e)}})}function g(e,t,r,n,i){const o=e.info;null===r?delete o.jsAttributes[t]:o.jsAttributes[t]=r,(i||null===r)&&(0,a.p)(u.Pl+n,[(0,c.t)(),t,r],void 0,"session",e.ee)}var m=i(1687),v=i(4234),b=i(5289),y=i(6154),w=i(5270),R=i(7767),x=i(6389),T=i(7699);class E extends v.W{constructor(e,t){super(e.agentIdentifier,t),this.agentRef=e,this.abortHandler=void 0,this.featAggregate=void 0,this.loadedSuccessfully=void 0,this.onAggregateImported=new Promise(e=>{this.loadedSuccessfully=e}),this.deferred=Promise.resolve(),!1===e.init[this.featureName].autoStart?this.deferred=new Promise((t,r)=>{this.ee.on("manual-start-all",(0,x.J)(()=>{(0,m.Ak)(e.agentIdentifier,this.featureName),t()}))}):(0,m.Ak)(e.agentIdentifier,t)}importAggregator(e,t,r={}){if(this.featAggregate)return;const n=async()=>{let n;await this.deferred;try{if((0,R.V)(e.init)){const{setupAgentSession:t}=await i.e(478).then(i.bind(i,8766));n=t(e)}}catch(e){(0,l.R)(20,e),this.ee.emit("internal-error",[e]),(0,a.p)(T.qh,[e],void 0,this.featureName,this.ee)}try{if(!this.#t(this.featureName,n,e.init))return(0,m.Ze)(this.agentIdentifier,this.featureName),void this.loadedSuccessfully(!1);const{Aggregate:i}=await t();this.featAggregate=new i(e,r),e.runtime.harvester.initializedAggregates.push(this.featAggregate),this.loadedSuccessfully(!0)}catch(e){(0,l.R)(34,e),this.abortHandler?.(),(0,m.Ze)(this.agentIdentifier,this.featureName,!0),this.loadedSuccessfully(!1),this.ee&&this.ee.abort()}};y.RI?(0,b.GG)(()=>n(),!0):n()}#t(e,t,r){if(this.blocked)return!1;switch(e){case n.K7.sessionReplay:return(0,w.SR)(r)&&!!t;case n.K7.sessionTrace:return!!t;default:return!0}}}var A=i(6630),S=i(2614);class _ extends E{static featureName=A.T;constructor(e){var t;super(e,A.T),this.setupInspectionEvents(e.agentIdentifier),t=e,p(u.Fw,function(e,r){"string"==typeof e&&("/"!==e.charAt(0)&&(e="/"+e),t.runtime.customTransaction=(r||"http://custom.transaction")+e,(0,a.p)(u.Pl+u.Fw,[(0,c.t)()],void 0,void 0,t.ee))},t),this.importAggregator(e,()=>i.e(478).then(i.bind(i,1983)))}setupInspectionEvents(e){const t=(t,r)=>{t&&(0,d.W)({agentIdentifier:e,timeStamp:t.timeStamp,loaded:"complete"===t.target.readyState,type:"window",name:r,data:t.target.location+""})};(0,b.sB)(e=>{t(e,"DOMContentLoaded")}),(0,b.GG)(e=>{t(e,"load")}),(0,b.Qr)(e=>{t(e,"navigate")}),this.ee.on(S.tS.UPDATE,(t,r)=>{(0,d.W)({agentIdentifier:e,type:"lifecycle",name:"session",data:r})})}}var O=i(384);var N=i(2843),I=i(3878),P=i(782);class j extends E{static featureName=P.T;constructor(e){super(e,P.T),y.RI&&((0,N.u)(()=>(0,a.p)("docHidden",[(0,c.t)()],void 0,P.T,this.ee),!0),(0,I.sp)("pagehide",()=>(0,a.p)("winPagehide",[(0,c.t)()],void 0,P.T,this.ee)),this.importAggregator(e,()=>i.e(478).then(i.bind(i,9917))))}}class k extends E{static featureName=h.TZ;constructor(e){super(e,h.TZ),y.RI&&document.addEventListener("securitypolicyviolation",e=>{(0,a.p)(h.xV,["Generic/CSPViolation/Detected"],void 0,this.featureName,this.ee)}),this.importAggregator(e,()=>i.e(478).then(i.bind(i,6555)))}}var C=i(6774),L=i(3304);class H{constructor(e,t,r,n,i){this.name="UncaughtError",this.message="string"==typeof e?e:(0,L.A)(e),this.sourceURL=t,this.line=r,this.column=n,this.__newrelic=i}}function M(e){return U(e)?e:new H(void 0!==e?.message?e.message:e,e?.filename||e?.sourceURL,e?.lineno||e?.line,e?.colno||e?.col,e?.__newrelic,e?.cause)}function K(e){const t="Unhandled Promise Rejection: ";if(!e?.reason)return;if(U(e.reason)){try{e.reason.message.startsWith(t)||(e.reason.message=t+e.reason.message)}catch(e){}return M(e.reason)}const r=M(e.reason);return(r.message||"").startsWith(t)||(r.message=t+r.message),r}function D(e){if(e.error instanceof SyntaxError&&!/:\d+$/.test(e.error.stack?.trim())){const t=new H(e.message,e.filename,e.lineno,e.colno,e.error.__newrelic,e.cause);return t.name=SyntaxError.name,t}return U(e.error)?e.error:M(e)}function U(e){return e instanceof Error&&!!e.stack}function F(e,t,r,i,o=(0,c.t)()){"string"==typeof e&&(e=new Error(e)),(0,a.p)("err",[e,o,!1,t,r.runtime.isRecording,void 0,i],void 0,n.K7.jserrors,r.ee),(0,a.p)("uaErr",[],void 0,n.K7.genericEvents,r.ee)}var W=i(4387),B=i(993),V=i(3785);function G(e,{customAttributes:t={},level:r=B.p_.INFO}={},n,i,o=(0,c.t)()){(0,V.R)(n.ee,e,t,r,i,o)}function z(e,t,r,i,o=(0,c.t)()){(0,a.p)(u.Pl+u.hG,[o,e,t,i],void 0,n.K7.genericEvents,r.ee)}function Z(e,t,r,i,o=(0,c.t)()){const{start:s,end:d,customAttributes:f}=t||{},h={customAttributes:f||{}};if("object"!=typeof h.customAttributes||"string"!=typeof e||0===e.length)return void(0,l.R)(57);const p=(e,t)=>null==e?t:"number"==typeof e?e:e instanceof PerformanceMark?e.startTime:Number.NaN;if(h.start=p(s,0),h.end=p(d,o),Number.isNaN(h.start)||Number.isNaN(h.end))(0,l.R)(57);else{if(h.duration=h.end-h.start,!(h.duration<0))return(0,a.p)(u.Pl+u.V1,[h,e,i],void 0,n.K7.genericEvents,r.ee),h;(0,l.R)(58)}}function q(e,t={},r,i,o=(0,c.t)()){(0,a.p)(u.Pl+u.fF,[o,e,t,i],void 0,n.K7.genericEvents,r.ee)}function X(e){p(u.eY,function(t){return Y(e,t)},e)}function Y(e,t,r){const i={};(0,l.R)(54,"newrelic.register"),t||={},t.eventSource="MicroFrontendBrowserAgent",t.licenseKey||=e.info.licenseKey,t.blocked=!1,t.parent=r||{};let o=()=>{};const s=e.runtime.registeredEntities,u=s.find(({metadata:{target:{id:e,name:r}}})=>e===t.id);if(u)return u.metadata.target.name!==t.name&&(u.metadata.target.name=t.name),u;const d=e=>{t.blocked=!0,o=e};e.init.api.allow_registered_children||d((0,x.J)(()=>(0,l.R)(55))),(0,W.c7)(t)||d((0,x.J)(()=>(0,l.R)(48,t))),(0,W.yo)(t.id)&&(0,W.yo)(t.name)||d((0,x.J)(()=>(0,l.R)(48,t)));const f={addPageAction:(r,n={})=>m(z,[r,{...i,...n},e],t),log:(r,n={})=>m(G,[r,{...n,customAttributes:{...i,...n.customAttributes||{}}},e],t),measure:(r,n={})=>m(Z,[r,{...n,customAttributes:{...i,...n.customAttributes||{}}},e],t),noticeError:(r,n={})=>m(F,[r,{...i,...n},e],t),register:(t={})=>m(Y,[e,t],f.metadata.target),recordCustomEvent:(r,n={})=>m(q,[r,{...i,...n},e],t),setApplicationVersion:e=>g("application.version",e),setCustomAttribute:(e,t)=>g(e,t),setUserId:e=>g("enduser.id",e),metadata:{customAttributes:i,target:t}},p=()=>(t.blocked&&o(),t.blocked);p()||s.push(f);const g=(e,t)=>{p()||(i[e]=t)},m=(t,r,i)=>{if(p())return;const o=(0,c.t)();(0,a.p)(h.xV,["API/register/".concat(t.name,"/called")],void 0,n.K7.metrics,e.ee);try{return e.init.api.duplicate_registered_data&&"register"!==t.name&&t(...r,void 0,o),t(...r,i,o)}catch(e){(0,l.R)(50,e)}};return f}class J extends E{static featureName=C.T;constructor(e){var t;super(e,C.T),t=e,p(u.o5,(e,r)=>F(e,r,t),t),function(e){p(u.bt,function(t){e.runtime.onerror=t},e)}(e),function(e){let t=0;p(u.k6,function(e,r){++t>10||(this.runtime.releaseIds[e.slice(-200)]=(""+r).slice(-200))},e)}(e),X(e);try{this.removeOnAbort=new AbortController}catch(e){}this.ee.on("internal-error",(t,r)=>{this.abortHandler&&(0,a.p)("ierr",[M(t),(0,c.t)(),!0,{},e.runtime.isRecording,r],void 0,this.featureName,this.ee)}),y.gm.addEventListener("unhandledrejection",t=>{this.abortHandler&&(0,a.p)("err",[K(t),(0,c.t)(),!1,{unhandledPromiseRejection:1},e.runtime.isRecording],void 0,this.featureName,this.ee)},(0,I.jT)(!1,this.removeOnAbort?.signal)),y.gm.addEventListener("error",t=>{this.abortHandler&&(0,a.p)("err",[D(t),(0,c.t)(),!1,{},e.runtime.isRecording],void 0,this.featureName,this.ee)},(0,I.jT)(!1,this.removeOnAbort?.signal)),this.abortHandler=this.#r,this.importAggregator(e,()=>i.e(478).then(i.bind(i,2176)))}#r(){this.removeOnAbort?.abort(),this.abortHandler=void 0}}var Q=i(8990);let ee=1;function te(e){const t=typeof e;return!e||"object"!==t&&"function"!==t?-1:e===y.gm?0:(0,Q.I)(e,"nr@id",function(){return ee++})}function re(e){if("string"==typeof e&&e.length)return e.length;if("object"==typeof e){if("undefined"!=typeof ArrayBuffer&&e instanceof ArrayBuffer&&e.byteLength)return e.byteLength;if("undefined"!=typeof Blob&&e instanceof Blob&&e.size)return e.size;if(!("undefined"!=typeof FormData&&e instanceof FormData))try{return(0,L.A)(e).length}catch(e){return}}}var ne=i(8139),ie=i(7836),oe=i(3434);const se={},ae=["open","send"];function ce(e){var t=e||ie.ee;const r=function(e){return(e||ie.ee).get("xhr")}(t);if(void 0===y.gm.XMLHttpRequest)return r;if(se[r.debugId]++)return r;se[r.debugId]=1,(0,ne.u)(t);var n=(0,oe.YM)(r),i=y.gm.XMLHttpRequest,o=y.gm.MutationObserver,s=y.gm.Promise,a=y.gm.setInterval,c="readystatechange",u=["onload","onerror","onabort","onloadstart","onloadend","onprogress","ontimeout"],d=[],f=y.gm.XMLHttpRequest=function(e){const t=new i(e),o=r.context(t);try{r.emit("new-xhr",[t],o),t.addEventListener(c,(s=o,function(){var e=this;e.readyState>3&&!s.resolved&&(s.resolved=!0,r.emit("xhr-resolved",[],e)),n.inPlace(e,u,"fn-",b)}),(0,I.jT)(!1))}catch(e){(0,l.R)(15,e);try{r.emit("internal-error",[e])}catch(e){}}var s;return t};function h(e,t){n.inPlace(t,["onreadystatechange"],"fn-",b)}if(function(e,t){for(var r in e)t[r]=e[r]}(i,f),f.prototype=i.prototype,n.inPlace(f.prototype,ae,"-xhr-",b),r.on("send-xhr-start",function(e,t){h(e,t),function(e){d.push(e),o&&(p?p.then(v):a?a(v):(g=-g,m.data=g))}(t)}),r.on("open-xhr-start",h),o){var p=s&&s.resolve();if(!a&&!s){var g=1,m=document.createTextNode(g);new o(v).observe(m,{characterData:!0})}}else t.on("fn-end",function(e){e[0]&&e[0].type===c||v()});function v(){for(var e=0;e<d.length;e++)h(0,d[e]);d.length&&(d=[])}function b(e,t){return t}return r}var ue="fetch-",de=ue+"body-",le=["arrayBuffer","blob","json","text","formData"],fe=y.gm.Request,he=y.gm.Response,pe="prototype";const ge={};function me(e){const t=function(e){return(e||ie.ee).get("fetch")}(e);if(!(fe&&he&&y.gm.fetch))return t;if(ge[t.debugId]++)return t;function r(e,r,n){var i=e[r];"function"==typeof i&&(e[r]=function(){var e,r=[...arguments],o={};t.emit(n+"before-start",[r],o),o[ie.P]&&o[ie.P].dt&&(e=o[ie.P].dt);var s=i.apply(this,r);return t.emit(n+"start",[r,e],s),s.then(function(e){return t.emit(n+"end",[null,e],s),e},function(e){throw t.emit(n+"end",[e],s),e})})}return ge[t.debugId]=1,le.forEach(e=>{r(fe[pe],e,de),r(he[pe],e,de)}),r(y.gm,"fetch",ue),t.on(ue+"end",function(e,r){var n=this;if(r){var i=r.headers.get("content-length");null!==i&&(n.rxSize=i),t.emit(ue+"done",[null,r],n)}else t.emit(ue+"done",[e],n)}),t}var ve=i(7485);class be{constructor(e){this.agentRef=e}generateTracePayload(t){const r=this.agentRef.loader_config;if(!this.shouldGenerateTrace(t)||!r)return null;var n=(r.accountID||"").toString()||null,i=(r.agentID||"").toString()||null,o=(r.trustKey||"").toString()||null;if(!n||!i)return null;var s=(0,e.ZF)(),a=(0,e.el)(),c=Date.now(),u={spanId:s,traceId:a,timestamp:c};return(t.sameOrigin||this.isAllowedOrigin(t)&&this.useTraceContextHeadersForCors())&&(u.traceContextParentHeader=this.generateTraceContextParentHeader(s,a),u.traceContextStateHeader=this.generateTraceContextStateHeader(s,c,n,i,o)),(t.sameOrigin&&!this.excludeNewrelicHeader()||!t.sameOrigin&&this.isAllowedOrigin(t)&&this.useNewrelicHeaderForCors())&&(u.newrelicHeader=this.generateTraceHeader(s,a,c,n,i,o)),u}generateTraceContextParentHeader(e,t){return"00-"+t+"-"+e+"-01"}generateTraceContextStateHeader(e,t,r,n,i){return i+"@nr=0-1-"+r+"-"+n+"-"+e+"----"+t}generateTraceHeader(e,t,r,n,i,o){if(!("function"==typeof y.gm?.btoa))return null;var s={v:[0,1],d:{ty:"Browser",ac:n,ap:i,id:e,tr:t,ti:r}};return o&&n!==o&&(s.d.tk=o),btoa((0,L.A)(s))}shouldGenerateTrace(e){return this.agentRef.init?.distributed_tracing?.enabled&&this.isAllowedOrigin(e)}isAllowedOrigin(e){var t=!1;const r=this.agentRef.init?.distributed_tracing;if(e.sameOrigin)t=!0;else if(r?.allowed_origins instanceof Array)for(var n=0;n<r.allowed_origins.length;n++){var i=(0,ve.D)(r.allowed_origins[n]);if(e.hostname===i.hostname&&e.protocol===i.protocol&&e.port===i.port){t=!0;break}}return t}excludeNewrelicHeader(){var e=this.agentRef.init?.distributed_tracing;return!!e&&!!e.exclude_newrelic_header}useNewrelicHeaderForCors(){var e=this.agentRef.init?.distributed_tracing;return!!e&&!1!==e.cors_use_newrelic_header}useTraceContextHeadersForCors(){var e=this.agentRef.init?.distributed_tracing;return!!e&&!!e.cors_use_tracecontext_headers}}var ye=i(9300),we=i(7295);function Re(e){return"string"==typeof e?e:e instanceof(0,O.dV)().o.REQ?e.url:y.gm?.URL&&e instanceof URL?e.href:void 0}var xe=["load","error","abort","timeout"],Te=xe.length,Ee=(0,O.dV)().o.REQ,Ae=(0,O.dV)().o.XHR;const Se="X-NewRelic-App-Data";class _e extends E{static featureName=ye.T;constructor(e){super(e,ye.T),this.dt=new be(e),this.handler=(e,t,r,n)=>(0,a.p)(e,t,r,n,this.ee);try{const e={xmlhttprequest:"xhr",fetch:"fetch",beacon:"beacon"};y.gm?.performance?.getEntriesByType("resource").forEach(t=>{if(t.initiatorType in e&&0!==t.responseStatus){const r={status:t.responseStatus},i={rxSize:t.transferSize,duration:Math.floor(t.duration),cbTime:0};Oe(r,t.name),this.handler("xhr",[r,i,t.startTime,t.responseEnd,e[t.initiatorType]],void 0,n.K7.ajax)}})}catch(e){}me(this.ee),ce(this.ee),function(e,t,r,i){function o(e){var t=this;t.totalCbs=0,t.called=0,t.cbTime=0,t.end=E,t.ended=!1,t.xhrGuids={},t.lastSize=null,t.loadCaptureCalled=!1,t.params=this.params||{},t.metrics=this.metrics||{},t.latestLongtaskEnd=0,e.addEventListener("load",function(r){A(t,e)},(0,I.jT)(!1)),y.lR||e.addEventListener("progress",function(e){t.lastSize=e.loaded},(0,I.jT)(!1))}function s(e){this.params={method:e[0]},Oe(this,e[1]),this.metrics={}}function u(t,r){e.loader_config.xpid&&this.sameOrigin&&r.setRequestHeader("X-NewRelic-ID",e.loader_config.xpid);var n=i.generateTracePayload(this.parsedOrigin);if(n){var o=!1;n.newrelicHeader&&(r.setRequestHeader("newrelic",n.newrelicHeader),o=!0),n.traceContextParentHeader&&(r.setRequestHeader("traceparent",n.traceContextParentHeader),n.traceContextStateHeader&&r.setRequestHeader("tracestate",n.traceContextStateHeader),o=!0),o&&(this.dt=n)}}function d(e,r){var n=this.metrics,i=e[0],o=this;if(n&&i){var s=re(i);s&&(n.txSize=s)}this.startTime=(0,c.t)(),this.body=i,this.listener=function(e){try{"abort"!==e.type||o.loadCaptureCalled||(o.params.aborted=!0),("load"!==e.type||o.called===o.totalCbs&&(o.onloadCalled||"function"!=typeof r.onload)&&"function"==typeof o.end)&&o.end(r)}catch(e){try{t.emit("internal-error",[e])}catch(e){}}};for(var a=0;a<Te;a++)r.addEventListener(xe[a],this.listener,(0,I.jT)(!1))}function l(e,t,r){this.cbTime+=e,t?this.onloadCalled=!0:this.called+=1,this.called!==this.totalCbs||!this.onloadCalled&&"function"==typeof r.onload||"function"!=typeof this.end||this.end(r)}function f(e,t){var r=""+te(e)+!!t;this.xhrGuids&&!this.xhrGuids[r]&&(this.xhrGuids[r]=!0,this.totalCbs+=1)}function p(e,t){var r=""+te(e)+!!t;this.xhrGuids&&this.xhrGuids[r]&&(delete this.xhrGuids[r],this.totalCbs-=1)}function g(){this.endTime=(0,c.t)()}function m(e,r){r instanceof Ae&&"load"===e[0]&&t.emit("xhr-load-added",[e[1],e[2]],r)}function v(e,r){r instanceof Ae&&"load"===e[0]&&t.emit("xhr-load-removed",[e[1],e[2]],r)}function b(e,t,r){t instanceof Ae&&("onload"===r&&(this.onload=!0),("load"===(e[0]&&e[0].type)||this.onload)&&(this.xhrCbStart=(0,c.t)()))}function w(e,r){this.xhrCbStart&&t.emit("xhr-cb-time",[(0,c.t)()-this.xhrCbStart,this.onload,r],r)}function R(e){var t,r=e[1]||{};if("string"==typeof e[0]?0===(t=e[0]).length&&y.RI&&(t=""+y.gm.location.href):e[0]&&e[0].url?t=e[0].url:y.gm?.URL&&e[0]&&e[0]instanceof URL?t=e[0].href:"function"==typeof e[0].toString&&(t=e[0].toString()),"string"==typeof t&&0!==t.length){t&&(this.parsedOrigin=(0,ve.D)(t),this.sameOrigin=this.parsedOrigin.sameOrigin);var n=i.generateTracePayload(this.parsedOrigin);if(n&&(n.newrelicHeader||n.traceContextParentHeader))if(e[0]&&e[0].headers)a(e[0].headers,n)&&(this.dt=n);else{var o={};for(var s in r)o[s]=r[s];o.headers=new Headers(r.headers||{}),a(o.headers,n)&&(this.dt=n),e.length>1?e[1]=o:e.push(o)}}function a(e,t){var r=!1;return t.newrelicHeader&&(e.set("newrelic",t.newrelicHeader),r=!0),t.traceContextParentHeader&&(e.set("traceparent",t.traceContextParentHeader),t.traceContextStateHeader&&e.set("tracestate",t.traceContextStateHeader),r=!0),r}}function x(e,t){this.params={},this.metrics={},this.startTime=(0,c.t)(),this.dt=t,e.length>=1&&(this.target=e[0]),e.length>=2&&(this.opts=e[1]);var r=this.opts||{},n=this.target;Oe(this,Re(n));var i=(""+(n&&n instanceof Ee&&n.method||r.method||"GET")).toUpperCase();this.params.method=i,this.body=r.body,this.txSize=re(r.body)||0}function T(e,t){if(this.endTime=(0,c.t)(),this.params||(this.params={}),(0,we.iW)(this.params))return;let i;this.params.status=t?t.status:0,"string"==typeof this.rxSize&&this.rxSize.length>0&&(i=+this.rxSize);const o={txSize:this.txSize,rxSize:i,duration:(0,c.t)()-this.startTime};r("xhr",[this.params,o,this.startTime,this.endTime,"fetch"],this,n.K7.ajax)}function E(e){const t=this.params,i=this.metrics;if(!this.ended){this.ended=!0;for(let t=0;t<Te;t++)e.removeEventListener(xe[t],this.listener,!1);t.aborted||(0,we.iW)(t)||(i.duration=(0,c.t)()-this.startTime,this.loadCaptureCalled||4!==e.readyState?null==t.status&&(t.status=0):A(this,e),i.cbTime=this.cbTime,r("xhr",[t,i,this.startTime,this.endTime,"xhr"],this,n.K7.ajax))}}function A(e,r){e.params.status=r.status;var i=function(e,t){var r=e.responseType;return"json"===r&&null!==t?t:"arraybuffer"===r||"blob"===r||"json"===r?re(e.response):"text"===r||""===r||void 0===r?re(e.responseText):void 0}(r,e.lastSize);if(i&&(e.metrics.rxSize=i),e.sameOrigin&&r.getAllResponseHeaders().indexOf(Se)>=0){var o=r.getResponseHeader(Se);o&&((0,a.p)(h.rs,["Ajax/CrossApplicationTracing/Header/Seen"],void 0,n.K7.metrics,t),e.params.cat=o.split(", ").pop())}e.loadCaptureCalled=!0}t.on("new-xhr",o),t.on("open-xhr-start",s),t.on("open-xhr-end",u),t.on("send-xhr-start",d),t.on("xhr-cb-time",l),t.on("xhr-load-added",f),t.on("xhr-load-removed",p),t.on("xhr-resolved",g),t.on("addEventListener-end",m),t.on("removeEventListener-end",v),t.on("fn-end",w),t.on("fetch-before-start",R),t.on("fetch-start",x),t.on("fn-start",b),t.on("fetch-done",T)}(e,this.ee,this.handler,this.dt),this.importAggregator(e,()=>i.e(478).then(i.bind(i,3845)))}}function Oe(e,t){var r=(0,ve.D)(t),n=e.params||e;n.hostname=r.hostname,n.port=r.port,n.protocol=r.protocol,n.host=r.hostname+":"+r.port,n.pathname=r.pathname,e.parsedOrigin=r,e.sameOrigin=r.sameOrigin}const Ne={},Ie=["pushState","replaceState"];function Pe(e){const t=function(e){return(e||ie.ee).get("history")}(e);return!y.RI||Ne[t.debugId]++||(Ne[t.debugId]=1,(0,oe.YM)(t).inPlace(window.history,Ie,"-")),t}var je=i(3738);function ke(e){p(u.BL,function(t=Date.now()){const r=t-y.WN;r<0&&(0,l.R)(62,t),(0,a.p)(h.XG,[u.BL,{time:r}],void 0,n.K7.metrics,e.ee),e.addToTrace({name:u.BL,start:t,origin:"nr"}),(0,a.p)(u.Pl+u.hG,[r,u.BL],void 0,n.K7.genericEvents,e.ee)},e)}const{He:Ce,bD:Le,d3:He,Kp:Me,TZ:Ke,Lc:De,uP:Ue,Rz:Fe}=je;class We extends E{static featureName=Ke;constructor(e){var t;super(e,Ke),t=e,p(u.U2,function(e){if(!(e&&"object"==typeof e&&e.name&&e.start))return;const r={n:e.name,s:e.start-y.WN,e:(e.end||e.start)-y.WN,o:e.origin||"",t:"api"};r.s<0||r.e<0||r.e<r.s?(0,l.R)(61,{start:r.s,end:r.e}):(0,a.p)("bstApi",[r],void 0,n.K7.sessionTrace,t.ee)},t),ke(e);if(!(0,R.V)(e.init))return void this.deregisterDrain();const r=this.ee;let o;Pe(r),this.eventsEE=(0,ne.u)(r),this.eventsEE.on(Ue,function(e,t){this.bstStart=(0,c.t)()}),this.eventsEE.on(De,function(e,t){(0,a.p)("bst",[e[0],t,this.bstStart,(0,c.t)()],void 0,n.K7.sessionTrace,r)}),r.on(Fe+He,function(e){this.time=(0,c.t)(),this.startPath=location.pathname+location.hash}),r.on(Fe+Me,function(e){(0,a.p)("bstHist",[location.pathname+location.hash,this.startPath,this.time],void 0,n.K7.sessionTrace,r)});try{o=new PerformanceObserver(e=>{const t=e.getEntries();(0,a.p)(Ce,[t],void 0,n.K7.sessionTrace,r)}),o.observe({type:Le,buffered:!0})}catch(e){}this.importAggregator(e,()=>i.e(478).then(i.bind(i,6974)),{resourceObserver:o})}}var Be=i(6344);class Ve extends E{static featureName=Be.TZ;#n;recorder;constructor(e){var t;let r;super(e,Be.TZ),t=e,p(u.CH,function(){(0,a.p)(u.CH,[],void 0,n.K7.sessionReplay,t.ee)},t),function(e){p(u.Tb,function(){(0,a.p)(u.Tb,[],void 0,n.K7.sessionReplay,e.ee)},e)}(e);try{r=JSON.parse(localStorage.getItem("".concat(S.H3,"_").concat(S.uh)))}catch(e){}(0,w.SR)(e.init)&&this.ee.on(u.CH,()=>this.#i()),this.#o(r)&&this.importRecorder().then(e=>{e.startRecording(Be.Qb.PRELOAD,r?.sessionReplayMode)}),this.importAggregator(this.agentRef,()=>i.e(478).then(i.bind(i,6167)),this),this.ee.on("err",e=>{this.blocked||this.agentRef.runtime.isRecording&&(this.errorNoticed=!0,(0,a.p)(Be.Vh,[e],void 0,this.featureName,this.ee))})}#o(e){return e&&(e.sessionReplayMode===S.g.FULL||e.sessionReplayMode===S.g.ERROR)||(0,w.Aw)(this.agentRef.init)}importRecorder(){return this.recorder?Promise.resolve(this.recorder):(this.#n??=Promise.all([i.e(478),i.e(249)]).then(i.bind(i,4866)).then(({Recorder:e})=>(this.recorder=new e(this),this.recorder)).catch(e=>{throw this.ee.emit("internal-error",[e]),this.blocked=!0,e}),this.#n)}#i(){this.blocked||(this.featAggregate?this.featAggregate.mode!==S.g.FULL&&this.featAggregate.initializeRecording(S.g.FULL,!0,Be.Qb.API):this.importRecorder().then(()=>{this.recorder.startRecording(Be.Qb.API,S.g.FULL)}))}}var Ge=i(3962);function ze(e){const t=e.ee.get("tracer");function r(){}p(u.dT,function(e){return(new r).get("object"==typeof e?e:{})},e);const i=r.prototype={createTracer:function(r,i){var o={},s=this,d="function"==typeof i;return(0,a.p)(h.xV,["API/createTracer/called"],void 0,n.K7.metrics,e.ee),e.runSoftNavOverSpa||(0,a.p)(u.hw+"tracer",[(0,c.t)(),r,o],s,n.K7.spa,e.ee),function(){if(t.emit((d?"":"no-")+"fn-start",[(0,c.t)(),s,d],o),d)try{return i.apply(this,arguments)}catch(e){const r="string"==typeof e?new Error(e):e;throw t.emit("fn-err",[arguments,this,r],o),r}finally{t.emit("fn-end",[(0,c.t)()],o)}}}};["actionText","setName","setAttribute","save","ignore","onEnd","getContext","end","get"].forEach(t=>{p.apply(this,[t,function(){return(0,a.p)(u.hw+t,[(0,c.t)(),...arguments],this,e.runSoftNavOverSpa?n.K7.softNav:n.K7.spa,e.ee),this},e,i])}),p(u.PA,function(){e.runSoftNavOverSpa?(0,a.p)(u.hw+"routeName",[performance.now(),...arguments],void 0,n.K7.softNav,e.ee):(0,a.p)(u.Pl+"routeName",[(0,c.t)(),...arguments],this,n.K7.spa,e.ee)},e)}class Ze extends E{static featureName=Ge.TZ;constructor(e){if(super(e,Ge.TZ),ze(e),!y.RI||!(0,O.dV)().o.MO)return;const t=Pe(this.ee);try{this.removeOnAbort=new AbortController}catch(e){}Ge.tC.forEach(e=>{(0,I.sp)(e,e=>{s(e)},!0,this.removeOnAbort?.signal)});const r=()=>(0,a.p)("newURL",[(0,c.t)(),""+window.location],void 0,this.featureName,this.ee);t.on("pushState-end",r),t.on("replaceState-end",r),(0,I.sp)(Ge.OV,e=>{s(e),(0,a.p)("newURL",[e.timeStamp,""+window.location],void 0,this.featureName,this.ee)},!0,this.removeOnAbort?.signal);let n=!1;const o=new((0,O.dV)().o.MO)((e,t)=>{n||(n=!0,requestAnimationFrame(()=>{(0,a.p)("newDom",[(0,c.t)()],void 0,this.featureName,this.ee),n=!1}))}),s=(0,x.s)(e=>{(0,a.p)("newUIEvent",[e],void 0,this.featureName,this.ee),o.observe(document.body,{attributes:!0,childList:!0,subtree:!0,characterData:!0})},100,{leading:!0});this.abortHandler=function(){this.removeOnAbort?.abort(),o.disconnect(),this.abortHandler=void 0},this.importAggregator(e,()=>i.e(478).then(i.bind(i,4393)),{domObserver:o})}}var qe=i(7378);const Xe={},Ye=["appendChild","insertBefore","replaceChild"];function Je(e){const t=function(e){return(e||ie.ee).get("jsonp")}(e);if(!y.RI||Xe[t.debugId])return t;Xe[t.debugId]=!0;var r=(0,oe.YM)(t),n=/[?&](?:callback|cb)=([^&#]+)/,i=/(.*)\.([^.]+)/,o=/^(\w+)(\.|$)(.*)$/;function s(e,t){if(!e)return t;const r=e.match(o),n=r[1];return s(r[3],t[n])}return r.inPlace(Node.prototype,Ye,"dom-"),t.on("dom-start",function(e){!function(e){if(!e||"string"!=typeof e.nodeName||"script"!==e.nodeName.toLowerCase())return;if("function"!=typeof e.addEventListener)return;var o=(a=e.src,c=a.match(n),c?c[1]:null);var a,c;if(!o)return;var u=function(e){var t=e.match(i);if(t&&t.length>=3)return{key:t[2],parent:s(t[1],window)};return{key:e,parent:window}}(o);if("function"!=typeof u.parent[u.key])return;var d={};function l(){t.emit("jsonp-end",[],d),e.removeEventListener("load",l,(0,I.jT)(!1)),e.removeEventListener("error",f,(0,I.jT)(!1))}function f(){t.emit("jsonp-error",[],d),t.emit("jsonp-end",[],d),e.removeEventListener("load",l,(0,I.jT)(!1)),e.removeEventListener("error",f,(0,I.jT)(!1))}r.inPlace(u.parent,[u.key],"cb-",d),e.addEventListener("load",l,(0,I.jT)(!1)),e.addEventListener("error",f,(0,I.jT)(!1)),t.emit("new-jsonp",[e.src],d)}(e[0])}),t}const $e={};function Qe(e){const t=function(e){return(e||ie.ee).get("promise")}(e);if($e[t.debugId])return t;$e[t.debugId]=!0;var r=t.context,n=(0,oe.YM)(t),i=y.gm.Promise;return i&&function(){function e(r){var o=t.context(),s=n(r,"executor-",o,null,!1);const a=Reflect.construct(i,[s],e);return t.context(a).getCtx=function(){return o},a}y.gm.Promise=e,Object.defineProperty(e,"name",{value:"Promise"}),e.toString=function(){return i.toString()},Object.setPrototypeOf(e,i),["all","race"].forEach(function(r){const n=i[r];e[r]=function(e){let i=!1;[...e||[]].forEach(e=>{this.resolve(e).then(s("all"===r),s(!1))});const o=n.apply(this,arguments);return o;function s(e){return function(){t.emit("propagate",[null,!i],o,!1,!1),i=i||!e}}}}),["resolve","reject"].forEach(function(r){const n=i[r];e[r]=function(e){const r=n.apply(this,arguments);return e!==r&&t.emit("propagate",[e,!0],r,!1,!1),r}}),e.prototype=i.prototype;const o=i.prototype.then;i.prototype.then=function(...e){var i=this,s=r(i);s.promise=i,e[0]=n(e[0],"cb-",s,null,!1),e[1]=n(e[1],"cb-",s,null,!1);const a=o.apply(this,e);return s.nextPromise=a,t.emit("propagate",[i,!0],a,!1,!1),a},i.prototype.then[oe.Jt]=o,t.on("executor-start",function(e){e[0]=n(e[0],"resolve-",this,null,!1),e[1]=n(e[1],"resolve-",this,null,!1)}),t.on("executor-err",function(e,t,r){e[1](r)}),t.on("cb-end",function(e,r,n){t.emit("propagate",[n,!0],this.nextPromise,!1,!1)}),t.on("propagate",function(e,r,n){if(!this.getCtx||r){const r=this,n=e instanceof Promise?t.context(e):null;let i;this.getCtx=function(){return i||(i=n&&n!==r?"function"==typeof n.getCtx?n.getCtx():n:r,i)}}})}(),t}const et={},tt="setTimeout",rt="setInterval",nt="clearTimeout",it="-start",ot=[tt,"setImmediate",rt,nt,"clearImmediate"];function st(e){const t=function(e){return(e||ie.ee).get("timer")}(e);if(et[t.debugId]++)return t;et[t.debugId]=1;var r=(0,oe.YM)(t);return r.inPlace(y.gm,ot.slice(0,2),tt+"-"),r.inPlace(y.gm,ot.slice(2,3),rt+"-"),r.inPlace(y.gm,ot.slice(3),nt+"-"),t.on(rt+it,function(e,t,n){e[0]=r(e[0],"fn-",null,n)}),t.on(tt+it,function(e,t,n){this.method=n,this.timerDuration=isNaN(e[1])?0:+e[1],e[0]=r(e[0],"fn-",this,n)}),t}const at={};function ct(e){const t=function(e){return(e||ie.ee).get("mutation")}(e);if(!y.RI||at[t.debugId])return t;at[t.debugId]=!0;var r=(0,oe.YM)(t),n=y.gm.MutationObserver;return n&&(window.MutationObserver=function(e){return this instanceof n?new n(r(e,"fn-")):n.apply(this,arguments)},MutationObserver.prototype=n.prototype),t}const{TZ:ut,d3:dt,Kp:lt,$p:ft,wW:ht,e5:pt,tH:gt,uP:mt,rw:vt,Lc:bt}=qe;class yt extends E{static featureName=ut;constructor(e){if(super(e,ut),ze(e),!y.RI)return;try{this.removeOnAbort=new AbortController}catch(e){}let t,r=0;const n=this.ee.get("tracer"),o=Je(this.ee),s=Qe(this.ee),u=st(this.ee),d=ce(this.ee),l=this.ee.get("events"),f=me(this.ee),h=Pe(this.ee),p=ct(this.ee);function g(e,t){h.emit("newURL",[""+window.location,t])}function m(){r++,t=window.location.hash,this[mt]=(0,c.t)()}function v(){r--,window.location.hash!==t&&g(0,!0);var e=(0,c.t)();this[pt]=~~this[pt]+e-this[mt],this[bt]=e}function b(e,t){e.on(t,function(){this[t]=(0,c.t)()})}this.ee.on(mt,m),s.on(vt,m),o.on(vt,m),this.ee.on(bt,v),s.on(ht,v),o.on(ht,v),this.ee.on("fn-err",(...t)=>{t[2]?.__newrelic?.[e.agentIdentifier]||(0,a.p)("function-err",[...t],void 0,this.featureName,this.ee)}),this.ee.buffer([mt,bt,"xhr-resolved"],this.featureName),l.buffer([mt],this.featureName),u.buffer(["setTimeout"+lt,"clearTimeout"+dt,mt],this.featureName),d.buffer([mt,"new-xhr","send-xhr"+dt],this.featureName),f.buffer([gt+dt,gt+"-done",gt+ft+dt,gt+ft+lt],this.featureName),h.buffer(["newURL"],this.featureName),p.buffer([mt],this.featureName),s.buffer(["propagate",vt,ht,"executor-err","resolve"+dt],this.featureName),n.buffer([mt,"no-"+mt],this.featureName),o.buffer(["new-jsonp","cb-start","jsonp-error","jsonp-end"],this.featureName),b(f,gt+dt),b(f,gt+"-done"),b(o,"new-jsonp"),b(o,"jsonp-end"),b(o,"cb-start"),h.on("pushState-end",g),h.on("replaceState-end",g),window.addEventListener("hashchange",g,(0,I.jT)(!0,this.removeOnAbort?.signal)),window.addEventListener("load",g,(0,I.jT)(!0,this.removeOnAbort?.signal)),window.addEventListener("popstate",function(){g(0,r>1)},(0,I.jT)(!0,this.removeOnAbort?.signal)),this.abortHandler=this.#r,this.importAggregator(e,()=>i.e(478).then(i.bind(i,5592)))}#r(){this.removeOnAbort?.abort(),this.abortHandler=void 0}}var wt=i(3333);class Rt extends E{static featureName=wt.TZ;constructor(e){super(e,wt.TZ);const t=[e.init.page_action.enabled,e.init.performance.capture_marks,e.init.performance.capture_measures,e.init.user_actions.enabled,e.init.performance.resources.enabled];var r;r=e,p(u.hG,(e,t)=>z(e,t,r),r),function(e){p(u.fF,(t,r)=>q(t,r,e),e)}(e),ke(e),X(e),function(e){p(u.V1,(t,r)=>Z(t,r,e),e)}(e);const o=e.init.feature_flags.includes("user_frustrations");let s;if(y.RI&&o&&(me(this.ee),ce(this.ee),s=Pe(this.ee)),y.RI){if(e.init.user_actions.enabled&&(wt.Zp.forEach(e=>(0,I.sp)(e,e=>(0,a.p)("ua",[e],void 0,this.featureName,this.ee),!0)),wt.qN.forEach(e=>{const t=(0,x.s)(e=>{(0,a.p)("ua",[e],void 0,this.featureName,this.ee)},500,{leading:!0});(0,I.sp)(e,t)}),o)){function c(t){const r=(0,ve.D)(t);return e.beacons.includes(r.hostname+":"+r.port)}function d(){s.emit("navChange")}y.gm.addEventListener("error",()=>{(0,a.p)("uaErr",[],void 0,n.K7.genericEvents,this.ee)},(0,I.jT)(!1,this.removeOnAbort?.signal)),this.ee.on("open-xhr-start",(e,t)=>{c(e[1])||t.addEventListener("readystatechange",()=>{2===t.readyState&&(0,a.p)("uaXhr",[],void 0,n.K7.genericEvents,this.ee)})}),this.ee.on("fetch-start",e=>{e.length>=1&&!c(Re(e[0]))&&(0,a.p)("uaXhr",[],void 0,n.K7.genericEvents,this.ee)}),s.on("pushState-end",d),s.on("replaceState-end",d),window.addEventListener("hashchange",d,(0,I.jT)(!0,this.removeOnAbort?.signal)),window.addEventListener("popstate",d,(0,I.jT)(!0,this.removeOnAbort?.signal))}if(e.init.performance.resources.enabled&&y.gm.PerformanceObserver?.supportedEntryTypes.includes("resource")){new PerformanceObserver(e=>{e.getEntries().forEach(e=>{(0,a.p)("browserPerformance.resource",[e],void 0,this.featureName,this.ee)})}).observe({type:"resource",buffered:!0})}}try{this.removeOnAbort=new AbortController}catch(l){}this.abortHandler=()=>{this.removeOnAbort?.abort(),this.abortHandler=void 0},t.some(e=>e)?this.importAggregator(e,()=>i.e(478).then(i.bind(i,8019))):this.deregisterDrain()}}var xt=i(2646);const Tt=new Map;function Et(e,t,r,n){if("object"!=typeof t||!t||"string"!=typeof r||!r||"function"!=typeof t[r])return(0,l.R)(29);const i=function(e){return(e||ie.ee).get("logger")}(e),o=(0,oe.YM)(i),s=new xt.y(ie.P);s.level=n.level,s.customAttributes=n.customAttributes;const a=t[r]?.[oe.Jt]||t[r];return Tt.set(a,s),o.inPlace(t,[r],"wrap-logger-",()=>Tt.get(a)),i}var At=i(1910);class St extends E{static featureName=B.TZ;constructor(e){var t;super(e,B.TZ),t=e,p(u.$9,(e,r)=>G(e,r,t),t),function(e){p(u.Wb,(t,r,{customAttributes:n={},level:i=B.p_.INFO}={})=>{Et(e.ee,t,r,{customAttributes:n,level:i})},e)}(e),X(e);const r=this.ee;["log","error","warn","info","debug","trace"].forEach(e=>{(0,At.i)(y.gm.console[e]),Et(r,y.gm.console,e,{level:"log"===e?"info":e})}),this.ee.on("wrap-logger-end",function([e]){const{level:t,customAttributes:n}=this;(0,V.R)(r,e,n,t)}),this.importAggregator(e,()=>i.e(478).then(i.bind(i,5288)))}}new class extends r{constructor(e){var t;(super(),y.gm)?(this.features={},(0,O.bQ)(this.agentIdentifier,this),this.desiredFeatures=new Set(e.features||[]),this.desiredFeatures.add(_),this.runSoftNavOverSpa=[...this.desiredFeatures].some(e=>e.featureName===n.K7.softNav),(0,s.j)(this,e,e.loaderType||"agent"),t=this,p(u.cD,function(e,r,n=!1){if("string"==typeof e){if(["string","number","boolean"].includes(typeof r)||null===r)return g(t,e,r,u.cD,n);(0,l.R)(40,typeof r)}else(0,l.R)(39,typeof e)},t),function(e){p(u.Dl,function(t){if("string"==typeof t||null===t)return g(e,"enduser.id",t,u.Dl,!0);(0,l.R)(41,typeof t)},e)}(this),function(e){p(u.nb,function(t){if("string"==typeof t||null===t)return g(e,"application.version",t,u.nb,!1);(0,l.R)(42,typeof t)},e)}(this),function(e){p(u.d3,function(){e.ee.emit("manual-start-all")},e)}(this),function(e){p(u.Pv,function(t=!0){if("boolean"==typeof t){if((0,a.p)(u.Pl+u.Pv,[t],void 0,"session",e.ee),e.runtime.consented=t,t){const t=e.features.page_view_event;t.onAggregateImported.then(e=>{const r=t.featAggregate;e&&!r.sentRum&&r.sendRum()})}}else(0,l.R)(65,typeof t)},e)}(this),this.run()):(0,l.R)(21)}get config(){return{info:this.info,init:this.init,loader_config:this.loader_config,runtime:this.runtime}}get api(){return this}run(){try{const e=function(e){const t={};return o.forEach(r=>{t[r]=!!e[r]?.enabled}),t}(this.init),t=[...this.desiredFeatures];t.sort((e,t)=>n.P3[e.featureName]-n.P3[t.featureName]),t.forEach(t=>{if(!e[t.featureName]&&t.featureName!==n.K7.pageViewEvent)return;if(this.runSoftNavOverSpa&&t.featureName===n.K7.spa)return;if(!this.runSoftNavOverSpa&&t.featureName===n.K7.softNav)return;const r=function(e){switch(e){case n.K7.ajax:return[n.K7.jserrors];case n.K7.sessionTrace:return[n.K7.ajax,n.K7.pageViewEvent];case n.K7.sessionReplay:return[n.K7.sessionTrace];case n.K7.pageViewTiming:return[n.K7.pageViewEvent];default:return[]}}(t.featureName).filter(e=>!(e in this.features));r.length>0&&(0,l.R)(36,{targetFeature:t.featureName,missingDependencies:r}),this.features[t.featureName]=new t(this)})}catch(e){(0,l.R)(22,e);for(const e in this.features)this.features[e].abortHandler?.();const t=(0,O.Zm)();delete t.initializedAgents[this.agentIdentifier]?.features,delete this.sharedAggregator;return t.ee.get(this.agentIdentifier).abort(),!1}}}({features:[_e,_,j,We,Ve,k,J,Rt,St,Ze,yt],loaderType:"spa"})})()})();</script>
	<!-- <meta name="format-detection" content="telephone=no"> -->
	<!--<meta name="viewport" content="width=device-width" />-->
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<meta name="description" content="The libraries of the Massachusetts Institute of Technology - Search, Visit, Research, Explore" />
	<title>About | MIT Libraries</title>
	<meta property="og:title" content="About | MIT Libraries"/>
<meta property="og:type" content="website" />
<meta property="og:image" content="https://libraries.mit.edu/app/themes/mitlib-parent/images/mit-libraries-logo-black-yellow-1200-1200.png"/>
<meta property="og:image:type" content="image/png" />
<meta property="og:image:width" content="1200" />
<meta property="og:image:height" content="1200" />
<meta property="og:image:alt" content="MIT Libraries logo" />
<meta property="og:description" content="Saving the world, bit by bit. Our vision? A world where more people have access to knowledge and more voices are heard. Where tools and solutions can be networked, shared, and &#8220;hacked.&#8221; Where knowledge not only provides answers, but empowers and inspires. We think libraries can help build this world. Let&#8217;s get started. Discover our mission, vision, and values Read the Future of Libraries Task Force Report Envisioning Hayden Library The Libraries are pursuing a renovation of Hayden that reflects our vision for the future of libraries. Learn more Furthering MIT’s mission The final recommendations from the Open Access Task [&hellip;]" />
<meta property="og:url" content="https://libraries.mit.edu/about7/">
	<link rel="profile" href="https://gmpg.org/xfn/11" />
	<link rel="pingback" href="https://libraries.mit.edu/wp/xmlrpc.php" />
	<link rel="icon" href="https://cdn.libraries.mit.edu/files/branding/favicons/favicon.ico" sizes="32x32">
	<link rel="icon" href="https://cdn.libraries.mit.edu/files/branding/favicons/favicon.svg" type="image/svg+xml">
	<link rel="apple-touch-icon" href="https://cdn.libraries.mit.edu/files/branding/favicons/apple-touch-icon.png"><!-- 180×180 -->
	<link rel="manifest" href="https://cdn.libraries.mit.edu/files/branding/favicons/manifest.json">
	<meta name='robots' content='max-image-preview:large' />
	<style>img:is([sizes="auto" i], [sizes^="auto," i]) { contain-intrinsic-size: 3000px 1500px }</style>
	<link rel='dns-prefetch' href='//libraries.mit.edu' />
<link rel='dns-prefetch' href='//maxcdn.bootstrapcdn.com' />
<link rel='dns-prefetch' href='//use.typekit.net' />
<script type="text/javascript">
/* <![CDATA[ */
window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/16.0.1\/72x72\/","ext":".png","svgUrl":"https:\/\/s.w.org\/images\/core\/emoji\/16.0.1\/svg\/","svgExt":".svg","source":{"concatemoji":"https:\/\/libraries.mit.edu\/wp\/wp-includes\/js\/wp-emoji-release.min.js?ver=6.8.2"}};
/*! This file is auto-generated */
!function(s,n){var o,i,e;function c(e){try{var t={supportTests:e,timestamp:(new Date).valueOf()};sessionStorage.setItem(o,JSON.stringify(t))}catch(e){}}function p(e,t,n){e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(t,0,0);var t=new Uint32Array(e.getImageData(0,0,e.canvas.width,e.canvas.height).data),a=(e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(n,0,0),new Uint32Array(e.getImageData(0,0,e.canvas.width,e.canvas.height).data));return t.every(function(e,t){return e===a[t]})}function u(e,t){e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(t,0,0);for(var n=e.getImageData(16,16,1,1),a=0;a<n.data.length;a++)if(0!==n.data[a])return!1;return!0}function f(e,t,n,a){switch(t){case"flag":return n(e,"\ud83c\udff3\ufe0f\u200d\u26a7\ufe0f","\ud83c\udff3\ufe0f\u200b\u26a7\ufe0f")?!1:!n(e,"\ud83c\udde8\ud83c\uddf6","\ud83c\udde8\u200b\ud83c\uddf6")&&!n(e,"\ud83c\udff4\udb40\udc67\udb40\udc62\udb40\udc65\udb40\udc6e\udb40\udc67\udb40\udc7f","\ud83c\udff4\u200b\udb40\udc67\u200b\udb40\udc62\u200b\udb40\udc65\u200b\udb40\udc6e\u200b\udb40\udc67\u200b\udb40\udc7f");case"emoji":return!a(e,"\ud83e\udedf")}return!1}function g(e,t,n,a){var r="undefined"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope?new OffscreenCanvas(300,150):s.createElement("canvas"),o=r.getContext("2d",{willReadFrequently:!0}),i=(o.textBaseline="top",o.font="600 32px Arial",{});return e.forEach(function(e){i[e]=t(o,e,n,a)}),i}function t(e){var t=s.createElement("script");t.src=e,t.defer=!0,s.head.appendChild(t)}"undefined"!=typeof Promise&&(o="wpEmojiSettingsSupports",i=["flag","emoji"],n.supports={everything:!0,everythingExceptFlag:!0},e=new Promise(function(e){s.addEventListener("DOMContentLoaded",e,{once:!0})}),new Promise(function(t){var n=function(){try{var e=JSON.parse(sessionStorage.getItem(o));if("object"==typeof e&&"number"==typeof e.timestamp&&(new Date).valueOf()<e.timestamp+604800&&"object"==typeof e.supportTests)return e.supportTests}catch(e){}return null}();if(!n){if("undefined"!=typeof Worker&&"undefined"!=typeof OffscreenCanvas&&"undefined"!=typeof URL&&URL.createObjectURL&&"undefined"!=typeof Blob)try{var e="postMessage("+g.toString()+"("+[JSON.stringify(i),f.toString(),p.toString(),u.toString()].join(",")+"));",a=new Blob([e],{type:"text/javascript"}),r=new Worker(URL.createObjectURL(a),{name:"wpTestEmojiSupports"});return void(r.onmessage=function(e){c(n=e.data),r.terminate(),t(n)})}catch(e){}c(n=g(i,f,p,u))}t(n)}).then(function(e){for(var t in e)n.supports[t]=e[t],n.supports.everything=n.supports.everything&&n.supports[t],"flag"!==t&&(n.supports.everythingExceptFlag=n.supports.everythingExceptFlag&&n.supports[t]);n.supports.everythingExceptFlag=n.supports.everythingExceptFlag&&!n.supports.flag,n.DOMReady=!1,n.readyCallback=function(){n.DOMReady=!0}}).then(function(){return e}).then(function(){var e;n.supports.everything||(n.readyCallback(),(e=n.source||{}).concatemoji?t(e.concatemoji):e.wpemoji&&e.twemoji&&(t(e.twemoji),t(e.wpemoji)))}))}((window,document),window._wpemojiSettings);
/* ]]> */
</script>
<style id='wp-emoji-styles-inline-css' type='text/css'>

	img.wp-smiley, img.emoji {
		display: inline !important;
		border: none !important;
		box-shadow: none !important;
		height: 1em !important;
		width: 1em !important;
		margin: 0 0.07em !important;
		vertical-align: -0.1em !important;
		background: none !important;
		padding: 0 !important;
	}
</style>
<link rel='stylesheet' id='wp-block-library-css' href='https://libraries.mit.edu/wp/wp-includes/css/dist/block-library/style.min.css?ver=6.8.2' type='text/css' media='all' />
<style id='classic-theme-styles-inline-css' type='text/css'>
/*! This file is auto-generated */
.wp-block-button__link{color:#fff;background-color:#32373c;border-radius:9999px;box-shadow:none;text-decoration:none;padding:calc(.667em + 2px) calc(1.333em + 2px);font-size:1.125em}.wp-block-file__button{background:#32373c;color:#fff;text-decoration:none}
</style>
<style id='global-styles-inline-css' type='text/css'>
:root{--wp--preset--aspect-ratio--square: 1;--wp--preset--aspect-ratio--4-3: 4/3;--wp--preset--aspect-ratio--3-4: 3/4;--wp--preset--aspect-ratio--3-2: 3/2;--wp--preset--aspect-ratio--2-3: 2/3;--wp--preset--aspect-ratio--16-9: 16/9;--wp--preset--aspect-ratio--9-16: 9/16;--wp--preset--color--black: #000000;--wp--preset--color--cyan-bluish-gray: #abb8c3;--wp--preset--color--white: #ffffff;--wp--preset--color--pale-pink: #f78da7;--wp--preset--color--vivid-red: #cf2e2e;--wp--preset--color--luminous-vivid-orange: #ff6900;--wp--preset--color--luminous-vivid-amber: #fcb900;--wp--preset--color--light-green-cyan: #7bdcb5;--wp--preset--color--vivid-green-cyan: #00d084;--wp--preset--color--pale-cyan-blue: #8ed1fc;--wp--preset--color--vivid-cyan-blue: #0693e3;--wp--preset--color--vivid-purple: #9b51e0;--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple: linear-gradient(135deg,rgba(6,147,227,1) 0%,rgb(155,81,224) 100%);--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan: linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%);--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange: linear-gradient(135deg,rgba(252,185,0,1) 0%,rgba(255,105,0,1) 100%);--wp--preset--gradient--luminous-vivid-orange-to-vivid-red: linear-gradient(135deg,rgba(255,105,0,1) 0%,rgb(207,46,46) 100%);--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray: linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%);--wp--preset--gradient--cool-to-warm-spectrum: linear-gradient(135deg,rgb(74,234,220) 0%,rgb(151,120,209) 20%,rgb(207,42,186) 40%,rgb(238,44,130) 60%,rgb(251,105,98) 80%,rgb(254,248,76) 100%);--wp--preset--gradient--blush-light-purple: linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%);--wp--preset--gradient--blush-bordeaux: linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%);--wp--preset--gradient--luminous-dusk: linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%);--wp--preset--gradient--pale-ocean: linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%);--wp--preset--gradient--electric-grass: linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%);--wp--preset--gradient--midnight: linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%);--wp--preset--font-size--small: 13px;--wp--preset--font-size--medium: 20px;--wp--preset--font-size--large: 36px;--wp--preset--font-size--x-large: 42px;--wp--preset--spacing--20: 0.44rem;--wp--preset--spacing--30: 0.67rem;--wp--preset--spacing--40: 1rem;--wp--preset--spacing--50: 1.5rem;--wp--preset--spacing--60: 2.25rem;--wp--preset--spacing--70: 3.38rem;--wp--preset--spacing--80: 5.06rem;--wp--preset--shadow--natural: 6px 6px 9px rgba(0, 0, 0, 0.2);--wp--preset--shadow--deep: 12px 12px 50px rgba(0, 0, 0, 0.4);--wp--preset--shadow--sharp: 6px 6px 0px rgba(0, 0, 0, 0.2);--wp--preset--shadow--outlined: 6px 6px 0px -3px rgba(255, 255, 255, 1), 6px 6px rgba(0, 0, 0, 1);--wp--preset--shadow--crisp: 6px 6px 0px rgba(0, 0, 0, 1);}:where(.is-layout-flex){gap: 0.5em;}:where(.is-layout-grid){gap: 0.5em;}body .is-layout-flex{display: flex;}.is-layout-flex{flex-wrap: wrap;align-items: center;}.is-layout-flex > :is(*, div){margin: 0;}body .is-layout-grid{display: grid;}.is-layout-grid > :is(*, div){margin: 0;}:where(.wp-block-columns.is-layout-flex){gap: 2em;}:where(.wp-block-columns.is-layout-grid){gap: 2em;}:where(.wp-block-post-template.is-layout-flex){gap: 1.25em;}:where(.wp-block-post-template.is-layout-grid){gap: 1.25em;}.has-black-color{color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-color{color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-color{color: var(--wp--preset--color--white) !important;}.has-pale-pink-color{color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-color{color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-color{color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-color{color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-color{color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-color{color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-color{color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-color{color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-color{color: var(--wp--preset--color--vivid-purple) !important;}.has-black-background-color{background-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-background-color{background-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-background-color{background-color: var(--wp--preset--color--white) !important;}.has-pale-pink-background-color{background-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-background-color{background-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-background-color{background-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-background-color{background-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-background-color{background-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-background-color{background-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-background-color{background-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-background-color{background-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-background-color{background-color: var(--wp--preset--color--vivid-purple) !important;}.has-black-border-color{border-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-border-color{border-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-border-color{border-color: var(--wp--preset--color--white) !important;}.has-pale-pink-border-color{border-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-border-color{border-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-border-color{border-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-border-color{border-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-border-color{border-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-border-color{border-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-border-color{border-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-border-color{border-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-border-color{border-color: var(--wp--preset--color--vivid-purple) !important;}.has-vivid-cyan-blue-to-vivid-purple-gradient-background{background: var(--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple) !important;}.has-light-green-cyan-to-vivid-green-cyan-gradient-background{background: var(--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan) !important;}.has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange) !important;}.has-luminous-vivid-orange-to-vivid-red-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-orange-to-vivid-red) !important;}.has-very-light-gray-to-cyan-bluish-gray-gradient-background{background: var(--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray) !important;}.has-cool-to-warm-spectrum-gradient-background{background: var(--wp--preset--gradient--cool-to-warm-spectrum) !important;}.has-blush-light-purple-gradient-background{background: var(--wp--preset--gradient--blush-light-purple) !important;}.has-blush-bordeaux-gradient-background{background: var(--wp--preset--gradient--blush-bordeaux) !important;}.has-luminous-dusk-gradient-background{background: var(--wp--preset--gradient--luminous-dusk) !important;}.has-pale-ocean-gradient-background{background: var(--wp--preset--gradient--pale-ocean) !important;}.has-electric-grass-gradient-background{background: var(--wp--preset--gradient--electric-grass) !important;}.has-midnight-gradient-background{background: var(--wp--preset--gradient--midnight) !important;}.has-small-font-size{font-size: var(--wp--preset--font-size--small) !important;}.has-medium-font-size{font-size: var(--wp--preset--font-size--medium) !important;}.has-large-font-size{font-size: var(--wp--preset--font-size--large) !important;}.has-x-large-font-size{font-size: var(--wp--preset--font-size--x-large) !important;}
:where(.wp-block-post-template.is-layout-flex){gap: 1.25em;}:where(.wp-block-post-template.is-layout-grid){gap: 1.25em;}
:where(.wp-block-columns.is-layout-flex){gap: 2em;}:where(.wp-block-columns.is-layout-grid){gap: 2em;}
:root :where(.wp-block-pullquote){font-size: 1.5em;line-height: 1.6;}
</style>
<link rel='stylesheet' id='contact-form-7-css' href='https://libraries.mit.edu/app/plugins/contact-form-7/includes/css/styles.css?ver=6.1' type='text/css' media='all' />
<style id='contact-form-7-inline-css' type='text/css'>
.wpcf7 .wpcf7-recaptcha iframe {margin-bottom: 0;}.wpcf7 .wpcf7-recaptcha[data-align="center"] > div {margin: 0 auto;}.wpcf7 .wpcf7-recaptcha[data-align="right"] > div {margin: 0 0 0 auto;}
</style>
<link rel='stylesheet' id='sn-fontAwesome-css-css' href='//maxcdn.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css?ver=1.1' type='text/css' media='all' />
<link rel='stylesheet' id='sn-animate-css-css' href='https://libraries.mit.edu/app/plugins/dynamic-menu-manager/duogeek/inc/animate.css?ver=1.1' type='text/css' media='all' />
<link rel='stylesheet' id='dg-grid-css-css' href='https://libraries.mit.edu/app/plugins/dynamic-menu-manager/duogeek/inc/dg-grid.css?ver=1.1' type='text/css' media='all' />
<link rel='stylesheet' id='parent-styles-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/style.css?ver=0.8' type='text/css' media='all' />
<link rel='stylesheet' id='parent-global-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/css/build/global.css?ver=0.8' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='parent-ie-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/css/ie.css?ver=20121010' type='text/css' media='all' />
<![endif]-->
<link rel='stylesheet' id='adobe-fonts-css' href='//use.typekit.net/ixd2vgq.css?ver=0.8' type='text/css' media='all' />
<link rel='stylesheet' id='parent-forms-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/css/build/forms.css?ver=0.8' type='text/css' media='all' />
<link rel='stylesheet' id='cf7cf-style-css' href='https://libraries.mit.edu/app/plugins/cf7-conditional-fields/style.css?ver=2.2.3' type='text/css' media='all' />
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/libs/modernizr.min.js?ver=2.8.3" id="modernizr-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/jquery.min.js?ver=1.11.1-local" id="jquery-js"></script>
<link rel="https://api.w.org/" href="https://libraries.mit.edu/wp-json/" /><link rel="alternate" title="JSON" type="application/json" href="https://libraries.mit.edu/wp-json/wp/v2/pages/140" /><link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://libraries.mit.edu/wp/xmlrpc.php?rsd" />
<meta name="generator" content="WordPress 6.8.2" />
<link rel="canonical" href="https://libraries.mit.edu/about7/" />
<link rel='shortlink' href='https://libraries.mit.edu/?p=140' />
<link rel="alternate" title="oEmbed (JSON)" type="application/json+oembed" href="https://libraries.mit.edu/wp-json/oembed/1.0/embed?url=https%3A%2F%2Flibraries.mit.edu%2Fabout7%2F" />
<link rel="alternate" title="oEmbed (XML)" type="text/xml+oembed" href="https://libraries.mit.edu/wp-json/oembed/1.0/embed?url=https%3A%2F%2Flibraries.mit.edu%2Fabout7%2F&#038;format=xml" />

	<!-- Matomo Tag Manager -->
<script>
  var _mtm = window._mtm = window._mtm || [];
  _mtm.push({'mtm.startTime': (new Date().getTime()), 'event': 'mtm.Start'});
  (function() {
    var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
    g.async=true; g.src='https://matomo.libraries.mit.edu/js/container_oFWMSb3g.js'; s.parentNode.insertBefore(g,s);
  })();
</script>
<!-- End Matomo Tag Manager -->		<style type="text/css" id="wp-custom-css">
			/* special temporary styling for branded about page */
body.page-id-140 {
  background: #fff;
  color: #000;
}

body.page-id-140 .content {
  margin: 0;
  font-family: 'NHaasGroteskTxt', 'Helvetica Neue', 'Helvetica', 'Arial', sans-serif !important;
  line-height: 1.2;
}

body.page-id-140 .breadcrumbs--better {
  background-color: #555; 
  color: #eee;
}
body.page-id-140 .breadcrumbs--better a {
    color: #eee;
}

body.page-id-140 .main-content { 
  background: #fff url('/images/network-graphic/logo10.png') no-repeat right top;
  color: #000;
  padding-left: 0; 
  padding-right: 0;
  margin-bottom: 0;
}

body.page-id-140 .layout-band {
  padding: 2% 15px 1% 15px;
}

body.page-id-140 .ttl {
  font-family: 'NHaasGroteskDisp', 'Helvetica Neue', 'Helvetica', 'Arial', sans-serif !important; 
	font-weight: 600;
}
body.page-id-140 .main-content p {
  line-height: 1.1;
}

body.page-id-140 .main-content .list-unbulleted li {
  list-style: none;
  margin-left: 0;
}

body.page-id-140 .main-content .cta-link {
  transition: background-color ease-in-out .3s;
  display: inline-block;
  padding: 10px;  
  color: #000;
  font-size: 20px;
  font-weight: 600;
  text-decoration: underline;
}

body.page-id-140 .main-content .cta-link:hover {
  background-color: #d300cc;
  color: #fff;
}

body.page-id-140 .wrap-intro {
  padding: 4% 15px;
  color: #000;
}

body.page-id-140 .wrap-intro .ttl {
  font-size: 36px;
  font-weight: 600;
  line-height: .92;
  margin-bottom: .3em;
}

body.page-id-140 .wrap-intro .pull {
  font-size: 20px;
  line-height: 1.2;
}

body.page-id-140 .wrap-we-are {
  margin-top: 1rem;
}

body.page-id-140 .card { 
  transition: background-color ease-in-out .3s;
  background: #fff;
  color: #000;
  margin: 15px;
  padding-top: 5px;
  line-height: 0;
}

body.page-id-140 .card:hover {
  background-color: #0000FF;
  background-image: none;
  color: #fff;
}

body.page-id-140 .card:hover a {
  color: #fff !important;
}

body.page-id-140 .card .c-image {
  width: 100%;
  background-color: #000;
}

body.page-id-140 .card .c-content {
  padding: 10px 3%;
  font-size: 14px;
} 

body.page-id-140 .card .c-ttl1 {
  font-size: 20px;
  font-weight: 600;
  line-height: .92;
  margin: 0;
}

body.page-id-140 .card .c-ttl2 {
  margin-top: .2em;
  font-size: 14px;
  line-height: 1.2;
  font-weight: 400;
}

body.page-id-140 .wrap-fol {
  padding: 2% 15px 3% 15px;
  color: #000;
  font-size: 14px;
}

body.page-id-140 .wrap-fol .ttl {
  font-size: 36px;
  font-weight: 600;
  line-height: .92;
}

body.page-id-140 .wrap-fol .vision-item strong {
  display: block;
  margin: 1em 0 .2em 0;
  font-size: 20px;
  line-height: .92;
}

body.page-id-140 .wrap-fol .cta-link {
  margin-top: .5em;
}

body.page-id-140 .list-social {
  display: flex;
  justify-content: space-between;
}

body.page-id-140 .list-social a {
  flex: 1 1 auto;
  padding: 20px;  
  background-color: #fff;
  font-size: 28px;
  color: #234;  
  text-align: center;
}

body.page-id-140 .list-social a:hover {
  background-color: #00C800;
  color: #000;
}

body.page-id-140 .list-pipe {
  text-align: center;
}
body.page-id-140 .list-pipe li {
  list-style-type: none;
  display: inline-block;  
  margin: 0;  
  padding-right: 10px;
}
body.page-id-140 .list-pipe li:after  {
  content: "|";
  padding-left: 10px;
}

body.page-id-140 .list-pipe li:last-child:after  {
content: "";
}

@media only screen and (min-width: 768px) {

}

@media only screen and (min-width: 480px) {

  body.page-id-140 .wrap-case-studies, 
  body.page-id-140 .wrap-linkblocks {
    display: flex;
  } 
    
  body.page-id-140 .card {
    flex: 1 1 auto; 
    width: 30%; 
    align-items: stretch;
    margin: 15px 0 15px 15px;    
  }

  body.page-id-140 .card:last-child {
    margin-right: 15px;
  }
}


/* CREOS page styles */
body.page-id-27945 .title-page, 
body.page-id-27945 h2.subtitle {
	  font-family: 'NHaasGroteskTxt', 'Helvetica Neue', 'Khula', 'Helvetica', sans-serif !important;

}
body.page-id-27945 .title-page h1 {
	font-size: 110px;
	font-weight: 600;
	line-height: .8;
	margin-top: .2em;
}

body.page-id-27945 h2.subtitle {
	font-size: 24px;
	font-weight: 600;
	margin-bottom: .8em;
}
/* widget utility classes */
.sidebar .no-top-border {
	border-top: none;
}

.sidebar .hide-title .widget-title { 
	display: none;
}

.sidebar .callout.widget {
	background: #e4e4e4 ;
	border-top: 2px solid #c63 ;
	padding-left: 20px ;
	padding-right: 20px ;
		padding-top: 15px ;
		padding-bottom: 15px ;
		margin-bottom: 20px;
}		</style>
			<script>
		todayDate="";
	</script>
</head>

<body class="wp-singular page-template page-template-templates page-template-page page-template-templatespage-php page page-id-140 page-parent wp-theme-mitlib-parent page-about7 full-width single-author">
	<div id="skip"><a href="#content">Skip to Main Content</a></div>
	<div class="wrap-page">
		<header class="header-main flex-container flex-end">
							<nav>
	<button class="menu--toggle"><!-- Mobile Hamburger icon -->
		<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="18.909px" height="13.091px" viewBox="2.182 6.545 18.909 13.091" enable-background="new 2.182 6.545 18.909 13.091" xml:space="preserve"><path d="M2.909,6.545h17.454c0.197,0,0.367,0.072,0.512,0.216c0.145,0.144,0.216,0.314,0.216,0.511s-0.071,0.367-0.216,0.511
		c-0.145,0.144-0.314,0.216-0.512,0.216H2.909c-0.197,0-0.367-0.072-0.511-0.216C2.254,7.639,2.182,7.469,2.182,7.272
		s0.072-0.367,0.216-0.511C2.542,6.617,2.712,6.545,2.909,6.545z M20.363,13.818H2.909c-0.197,0-0.367-0.072-0.511-0.216
		s-0.216-0.314-0.216-0.511c0-0.196,0.072-0.367,0.216-0.511s0.314-0.216,0.511-0.216h17.454c0.197,0,0.367,0.072,0.512,0.216
		s0.216,0.314,0.216,0.511c0,0.197-0.071,0.367-0.216,0.511S20.561,13.818,20.363,13.818z M20.363,19.636H2.909
		c-0.197,0-0.367-0.071-0.511-0.216s-0.216-0.314-0.216-0.511s0.072-0.367,0.216-0.511c0.144-0.145,0.314-0.217,0.511-0.217h17.454
		c0.197,0,0.367,0.072,0.512,0.217c0.145,0.144,0.216,0.314,0.216,0.511s-0.071,0.366-0.216,0.511S20.561,19.636,20.363,19.636z"/>
		</svg>
	</button><!-- end hamburger icon -->
</nav>

<!-- Menu shown on mobile screens, when the hamburger icon is tapped. -->
<nav id="nav-mobile" class="nav-main hidden-non-mobile" aria-hidden="true">
	<ul>
		<li><a href="/search" class="no-underline mobile-nav-link hide-mobile-nav-link">Search</a></li>
		<li><a href="/hours" class="no-underline mobile-nav-link hide-mobile-nav-link">Hours & locations</a></li>
		<li><a href="/borrow" class="no-underline mobile-nav-link hide-mobile-nav-link">Borrow & request</a></li>
		<li><a href="/research-support" class="no-underline mobile-nav-link hide-mobile-nav-link">Research support</a></li>
		<li><a href="/about" class="no-underline mobile-nav-link hide-mobile-nav-link">About</a></li>
	</ul>
</nav>
						
<h1 class="name-site group nav-logo">
	<a href="/" class="logo-mit-lib">
		<svg xmlns="http://www.w3.org/2000/svg" viewBox="5 -3 210 95"><title>MIT Libraries logo</title><path d="M8.12,9H20l4.35,15.65c.17.57.36,1.31.58,2.22s.44,1.81.67,2.68.53,2.12.8,3.25h.1c.23-1.13.48-2.22.75-3.25.2-.87.42-1.76.65-2.67s.43-1.65.6-2.22L32.92,9h12V44.75h-8.1V22.66c0-.93,0-1.95.1-3.05h-.1c-.27,1-.5,2-.7,2.85s-.38,1.61-.53,2.22l-.42,1.58-5.1,18.49h-7.3L17.67,26.3c-.1-.33-.25-.87-.45-1.6s-.38-1.48-.55-2.25-.42-1.82-.67-2.85h-.1v3c0,.8,0,1.6.08,2.4a8.53,8.53,0,0,1,0,1.75v18H8V9Zm40,0H57V44.75H48.12Zm22.1,7.45H59.82V9H89.57v7.45H79.07v28.3H70.22ZM8.12,50H17V78.25H33.64v7.5H8.12Zm28.7,0H45v6.6H36.82Zm0,10.15H45v25.6H36.82Zm27,26.4a9.82,9.82,0,0,1-4.55-1,7.9,7.9,0,0,1-3.2-3H56v3.2H48.2V50h8.15V63h.15a9.45,9.45,0,0,1,2.9-2.55,8.62,8.62,0,0,1,4.37-1,9.86,9.86,0,0,1,4.53,1,10,10,0,0,1,3.45,2.85A13.51,13.51,0,0,1,74,67.6a17.89,17.89,0,0,1,.7,5.4,19.45,19.45,0,0,1-.78,5.72A12.53,12.53,0,0,1,71.72,83a9.48,9.48,0,0,1-3.45,2.67A10.63,10.63,0,0,1,63.82,86.55Zm-2.3-6.45a4.14,4.14,0,0,0,3.67-1.92,9.45,9.45,0,0,0,1.28-5.27,9.74,9.74,0,0,0-1.28-5.3,4.2,4.2,0,0,0-3.77-2,4.43,4.43,0,0,0-4,2.1A9.7,9.7,0,0,0,56.12,73a8.49,8.49,0,0,0,1.45,5.17,4.69,4.69,0,0,0,4,2Zm15.11-20h7.8v4h.15a9.56,9.56,0,0,1,3-3.35,7.29,7.29,0,0,1,4-1,4.57,4.57,0,0,1,1.6.2v7H93a7.34,7.34,0,0,0-6,1.27q-2.16,1.78-2.16,6v11.5H76.63Zm26,26.3a12.1,12.1,0,0,1-3.53-.5,7.55,7.55,0,0,1-2.77-1.5A7,7,0,0,1,94.48,82a8.09,8.09,0,0,1-.66-3.4,7.29,7.29,0,0,1,.78-3.52,6.74,6.74,0,0,1,2.12-2.35,10.79,10.79,0,0,1,3.1-1.43,27,27,0,0,1,3.77-.75,24.35,24.35,0,0,0,5-1A1.93,1.93,0,0,0,110,67.7a2.56,2.56,0,0,0-.83-2,3.91,3.91,0,0,0-2.67-.7,4.41,4.41,0,0,0-3,.85,3.66,3.66,0,0,0-1.2,2.45H94.8a8.52,8.52,0,0,1,.8-3.4,8.14,8.14,0,0,1,2.17-2.8,10.65,10.65,0,0,1,3.58-1.9,16.29,16.29,0,0,1,5-.7,19.72,19.72,0,0,1,4.9.52,9.7,9.7,0,0,1,3.4,1.58,7.31,7.31,0,0,1,2.45,3,10.5,10.5,0,0,1,.8,4.25v12.9a13.08,13.08,0,0,0,.17,2.42,1.8,1.8,0,0,0,.73,1.23v.35h-7.9a3.53,3.53,0,0,1-.5-1.12,14.56,14.56,0,0,1-.35-1.72h0a8.4,8.4,0,0,1-2.73,2.54,10,10,0,0,1-4.68,1Zm2.6-5.2a5.46,5.46,0,0,0,3.68-1.2,4.27,4.27,0,0,0,1.42-3.35v-3a11.5,11.5,0,0,1-1.87.73c-.72.22-1.5.43-2.34.62a10.36,10.36,0,0,0-3.4,1.27,2.48,2.48,0,0,0-1,2.17,2.43,2.43,0,0,0,1,2.2,4.53,4.53,0,0,0,2.5.55h0Zm15.87-21h7.77v4H129a9.56,9.56,0,0,1,3-3.35,7.29,7.29,0,0,1,4-1,4.57,4.57,0,0,1,1.6.2v7h-.2a7.34,7.34,0,0,0-6,1.27c-1.49,1.22-2.24,3.22-2.23,6V85.75H121V60.15ZM140,50.1h8.13v6.6H140Zm0,10.15h8.13v25.5H140ZM164,86.6a15,15,0,0,1-5.7-1,12.07,12.07,0,0,1-4.3-2.85,12.84,12.84,0,0,1-2.7-4.33,15.07,15.07,0,0,1-1-5.4,14.74,14.74,0,0,1,1-5.33,12.72,12.72,0,0,1,2.7-4.3,12.58,12.58,0,0,1,4.13-2.94,14.62,14.62,0,0,1,10.28-.17,12.29,12.29,0,0,1,3.83,2.35A12.7,12.7,0,0,1,175.65,68a20.83,20.83,0,0,1,1.08,7.13H158.32a7.53,7.53,0,0,0,1.8,4.1,5.14,5.14,0,0,0,4,1.5,4.84,4.84,0,0,0,2.65-.68,4.28,4.28,0,0,0,1.6-1.87h8a9.47,9.47,0,0,1-1.5,3.33,10.85,10.85,0,0,1-2.8,2.73A12.06,12.06,0,0,1,168.49,86a15.31,15.31,0,0,1-4.52.5Zm4.5-16.3a6,6,0,0,0-1.5-3.65,4.37,4.37,0,0,0-3.3-1.35,4.64,4.64,0,0,0-3.6,1.35,7,7,0,0,0-1.65,3.65Zm21.9,16.35q-5.66,0-9-2.42a8.34,8.34,0,0,1-3.52-6.78h7.7A4.15,4.15,0,0,0,187,80.3a5.06,5.06,0,0,0,3.25,1,5.61,5.61,0,0,0,2.92-.65,2.08,2.08,0,0,0,1.08-1.9,1.82,1.82,0,0,0-.55-1.37,4.08,4.08,0,0,0-1.45-.85,11.46,11.46,0,0,0-2.08-.5c-.78-.11-1.59-.25-2.42-.42q-1.65-.3-3.3-.72a10,10,0,0,1-3-1.28,6.41,6.41,0,0,1-2.12-2.27,7.47,7.47,0,0,1-.8-3.68,7.21,7.21,0,0,1,.87-3.55,7.61,7.61,0,0,1,2.35-2.66,11.15,11.15,0,0,1,3.53-1.55,17.18,17.18,0,0,1,4.28-.52c3.63,0,6.42.73,8.35,2.2a8,8,0,0,1,3.2,6h-7.5a3,3,0,0,0-1.33-2.37,5.48,5.48,0,0,0-2.78-.62,5,5,0,0,0-2.52.58A1.9,1.9,0,0,0,186,67a1.34,1.34,0,0,0,.5,1.1,4.27,4.27,0,0,0,1.35.67,13.55,13.55,0,0,0,2,.48l2.33.4c1.13.2,2.27.44,3.42.73a10.5,10.5,0,0,1,3.17,1.32,7,7,0,0,1,2.3,2.42,7.84,7.84,0,0,1,.9,4,7.35,7.35,0,0,1-3.32,6.38,11.84,11.84,0,0,1-3.7,1.6,18.75,18.75,0,0,1-4.66.5Z" style="fill:#fff;" /></svg>
		<span class="sr">MIT Libraries</span>
	</a><!-- End MIT Libraries Logo -->
</h1><!-- End H1.name-site -->
							
<!-- Menu shown on non-mobile screens -->
<nav class="nav-main hidden-mobile" aria-label="Primary">
	<ul class="nav-main-list flex-container">
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-searchmenu-title" href="#" class="no-underline search-link main-nav-link menu-control">Search</a>
			</h2>
			<div aria-labelledby="main-nav-searchmenu-title" id="main-nav-searchmenu" class="links-sub flex-container group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Start here</h3>
					<ul class="list-unbulleted">
						<li><a href="/search">Search tools home</a></li>
						<li><a href="/search-collections">Search Our Collections <span class="about">Books, articles, and more</span></a></li>
						<li><a href="/worldcat">WorldCat<span class="about">Books &amp; more worldwide</span></a></li>
						<li><a href="https://libguides.mit.edu/az.php">Databases A-Z<span class="about">JSTOR, PubMed, Web of Science, etc.</span></a></li>
						<li><a href="/search-reserves">Course reserves</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">Also try</h3>
					<ul class="list-unbulleted">
						<li><a href="/google-scholar-tips">Google Scholar for MIT <span class="about">Change settings to get better access</span></a></li>
						<li><a href="/dspace">DSpace@MIT <span class="about">MIT research</span></a></li>
						<li><a href="/dome">Dome <span class="about">MIT-digitized images, maps, etc.</span></a></li>
						<li><a href="/site-search">Site search</a></li>
					</ul>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-hoursmenu-title" href="#" class="no-underline main-nav-link menu-control">Hours &amp; locations</a>
			</h2>
			<div aria-labelledby="main-nav-hoursmenu-title" id="main-nav-hoursmenu" class="links-sub flex-container group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Locations</h3>
					<ul class="list-unbulleted">
						<li><a href="/hours">Hours and locations home</a></li>
						<li><a href="/barker">Barker Library</a></li>
						<li><a href="/dewey">Dewey Library</a></li>
						<li><a href="/hayden">Hayden Library</a></li>
						<li><a href="/rotch">Rotch Library</a></li>
						<li><a href="/distinctive-collections">Distinctive Collections</a></li>
						<li><a href="/music">Lewis Music Library</a></li>
						<li><a href="/lsa">Library Storage Annex</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">Using the Libraries</h3>
					<ul class="list-unbulleted">
						<li><a href="/locations">Map of locations</a></li>
						<li><a href="/study">Study spaces</a></li>
						<li><a href="/disabilities">Persons with disabilities</a></li>
						<li><a href="/copying">Scan &amp; print</a></li>
						<li><a href="/exhibits">Exhibits &amp; galleries</a></li>
						<li><a href="/visitors">Visitors</a></li>
						<li><a href="/use-policies">Library use policy</a></li>
					</ul>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-borrowmenu-title" href="#" class="no-underline main-nav-link menu-control">Borrow &amp; request</a>
			</h2>
			<div aria-labelledby="main-nav-borrowmenu-title" id="main-nav-borrowmenu" class="links-sub flex-container group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Renew, request, suggest</h3>
					<ul class="list-unbulleted">
						<li><a href="/borrow">Borrow &amp; request home</a></li>
						<li><a href="/accounts">Accounts overview <span class="about">Your Account, ILLiad, Aeon, etc.</span></a></li>
						<li><a href="/search-collections">Search Our Collections <span class="about">Request items owned by MIT</span></a></li>
						<li><a href="/worldcat">WorldCat <span class="about">Request items not owned by MIT</span></a></li>
						<li><a href="/illiad">ILLiad <span class="about">Track your Interlibrary Borrowing requests</span></a></li>
						<li><a href="/suggest-purchase">Suggest a purchase</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">More information</h3>
					<ul class="list-unbulleted">
						<li><a href="/reserves">Course reserves</a></li>
						<li><a href="/borrow-direct">Borrow Direct <span class="about">Request items from Harvard, Yale, etc.</span></a></li>
						<li><a href="/otherlibraries">Visit non-MIT libraries <span class="about">Harvard, Borrow Direct, etc.</span></a></li>
					</ul>
				</div>
			</div>
		</li>
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-researchmenu-title" href="#" class="no-underline main-nav-link menu-control">Research support</a>
			</h2>
			<div aria-labelledby="main-nav-researchmenu-title" id="main-nav-researchmenu" class="links-sub flex-container push group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Help &amp; useful tools</h3>
					<ul class="list-unbulleted">
						<li><a href="/research-support">Research support home</a></li>
						<li><a href="/ask">Ask us <span class="about">Email, chat, call, drop by</span></a></li>
						<li><a href="/experts">Research guides &amp; expert librarians <span class="about">For every research interest</span></a></li>
						<li><a href="/authenticate">Authenticate to online resources <span class="about">Tips &amp; tricks</span></a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">Publishing &amp; content management</h3>
					<ul class="list-unbulleted">
						<li><a href="/references">Citation &amp; writing tools <span class="about">Mendeley, Zotero, &amp; Overleaf</span></a></li>
						<li><a href="/citing">Citing sources <span class="about">Avoid plagiarism, format references, etc.</span></a></li>
						<li><a href="/data-services">Data services <span class="about">GIS, data management, statistical support</span></a></li>
						<li><a href="/scholarly">Scholarly communications <span class="about">Open access, copyright, &amp; publishing</span></a></li>
						<li><a href="/apis">APIs for scholarly resources</a></li>
					</ul>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-aboutmenu-title" href="#" class="no-underline main-nav-link menu-control">About</a>
			</h2>
			<div aria-labelledby="main-nav-aboutmenu-title" id="main-nav-aboutmenu" class="links-sub flex-container push group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">About the Libraries</h3>
					<ul class="list-unbulleted">
						<li><a href="/about/">About us home</a></li>
						<li><a href="/contact">Contact us</a></li>
						<li><a href="/jobs">Jobs</a></li>
						<li><a href="/giving">Giving to the MIT Libraries</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">News, events, &amp; exhibits</h3>
					<a href="/events">Classes &amp; events</a>
					<a href="/news">News</a>
					<a href="/exhibits">Exhibits &amp; galleries</a>
					<a href="/news/in-the-media">In the media</a>
					<a href="/mit-reads/">MIT Reads</a>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end small chat push">
			<h2 class="main-nav-header">
				<a id="main-nav-askusmenu-title" href="#" class="no-underline main-nav-link menu-control"><svg version="1.1" xmlns="http://www.w3.org/2000/svg" x="0px" y="0px" width="16.593px" height="16px" viewBox="0 0 16.593 16" enable-background="new 0 0 16.593 16" xml:space="preserve"><path d="M16.593 6.278c0 1.074-0.074 2.148-0.241 3.185 -0.204 1.353-1.722 2.574-3.055 2.722 -1.353 0.131-2.686 0.204-4.02 0.223L5.74 15.833C5.63 15.944 5.481 16 5.334 16c-0.094 0-0.167-0.019-0.241-0.037C4.871 15.87 4.74 15.647 4.74 15.407V12.37c-0.481-0.036-0.963-0.055-1.443-0.111 -1.334-0.148-2.853-1.443-3.074-2.796C0.074 8.426 0 7.352 0 6.296c0-1.092 0.074-2.185 0.223-3.24 0.222-1.352 1.74-2.648 3.074-2.797C4.963 0.093 6.63 0 8.297 0s3.333 0.093 5 0.259c1.333 0.149 2.851 1.445 3.055 2.797C16.519 4.111 16.593 5.204 16.593 6.278"/></svg><span>Ask Us</span></a>
			</h2>
			<div aria-labelledby="main-nav-askusmenu-title" id="main-nav-askusmenu" class="links-sub push">
				<div class="wrap-button-chat">
					<div id='libchat_be2c654b63dd43f31c56295ee5d78d88'></div>
				</div>
				<a class="more" href="/ask">More ways to ask us</a>
			</div>
		</li>
		<li class="link-primary flex-end small">
			<h2 class="main-nav-header">
				<a href="/accounts" class="no-underline main-nav-link account-link">
					<svg version="1.1" xmlns="http://www.w3.org/2000/svg" x="0" y="0" width="15.4" height="16" viewBox="0 0 15.4 16" enable-background="new 0 0 15.445 16" xml:space="preserve"><path d="M13.4 15.7C12.2 15.9 10.4 16 7.7 16c-5.4 0-7.3-0.6-7.3-0.6 -0.3-0.1-0.4-0.4-0.4-0.7 0.3-1.6 1.2-2.5 2.5-3.3 0.3-0.2 0.8-0.4 1.2-0.6 0.8-0.3 1.8-0.7 2-1.3C5.8 9.2 5.7 8.6 5.2 7.9c-1.4-2.3-1.7-4.3-0.8-5.9C5.1 0.7 6.4 0 7.7 0c1.4 0 2.6 0.7 3.3 2 0.9 1.6 0.7 3.6-0.8 5.9C9.8 8.6 9.6 9.2 9.8 9.6c0.2 0.6 1.2 1 2 1.3 0.4 0.2 0.9 0.4 1.2 0.6 1.2 0.8 2.1 1.6 2.5 3.3 0.1 0.3-0.1 0.6-0.4 0.7C15 15.4 14.5 15.6 13.4 15.7"/></svg><span>Account</span>
				</a>
			</h2>
		</li>
	</ul>
</nav>
						<a class="link-logo-mit" href="http://www.mit.edu"><img src="https://cdn.libraries.mit.edu/files/branding/local/mit_logo_std_rgb_white.svg" height="32" alt="MIT logo" >
			</a><!-- End MIT Logo -->
							
<a href="/search" class="link-site-search hidden-non-mobile">
	<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="12" height="16" viewBox="0 0 12 12" class="icon-search"><path d="M7.273 0.727q1.187 0 2.19 0.585t1.588 1.588 0.585 2.19-0.585 2.19-1.588 1.588-2.19 0.585q-1.278 0-2.33-0.676l-3.284 3.301q-0.295 0.284-0.688 0.284-0.403 0-0.688-0.284t-0.284-0.688 0.284-0.688l3.301-3.284q-0.676-1.051-0.676-2.33 0-1.188 0.585-2.19t1.588-1.588 2.19-0.585zM7.273 8q0.591 0 1.128-0.23t0.929-0.622 0.622-0.929 0.23-1.128-0.23-1.128-0.622-0.929-0.929-0.622-1.128-0.23-1.128 0.23-0.929 0.622-0.622 0.929-0.23 1.128 0.23 1.128 0.622 0.929 0.929 0.622 1.128 0.23z"></path></svg>
	<span class="bottom">Search</span>
</a><!-- End /search -->

<a href="/accounts" class="link-account hidden-non-mobile">
	<svg version="1.1" xmlns="http://www.w3.org/2000/svg" x="0" y="0" width="15.4" height="16" viewBox="0 0 15.4 16" enable-background="new 0 0 15.445 16" xml:space="preserve" class="icon-account"><path d="M13.4 15.7C12.2 15.9 10.4 16 7.7 16c-5.4 0-7.3-0.6-7.3-0.6 -0.3-0.1-0.4-0.4-0.4-0.7 0.3-1.6 1.2-2.5 2.5-3.3 0.3-0.2 0.8-0.4 1.2-0.6 0.8-0.3 1.8-0.7 2-1.3C5.8 9.2 5.7 8.6 5.2 7.9c-1.4-2.3-1.7-4.3-0.8-5.9C5.1 0.7 6.4 0 7.7 0c1.4 0 2.6 0.7 3.3 2 0.9 1.6 0.7 3.6-0.8 5.9C9.8 8.6 9.6 9.2 9.8 9.6c0.2 0.6 1.2 1 2 1.3 0.4 0.2 0.9 0.4 1.2 0.6 1.2 0.8 2.1 1.6 2.5 3.3 0.1 0.3-0.1 0.6-0.4 0.7C15 15.4 14.5 15.6 13.4 15.7"/></svg>
	<span class="bottom">Account</span>
</a><!-- End /barton-account -->

<a href="/contact" class="link-contact hidden-non-mobile">
	<i class="fa fa-book" aria-hidden="true"></i>
	<span class="bottom">Contact</span>
</a><!-- End /contact -->
					</header>


	<div class="breadcrumbs--better hidden-phone group" role="navigation" aria-label="breadcrumbs">
	<span><a href="/">Libraries home</a></span>
	About<span></span></div>


	<div id="stage" class="inner" role="main">

		
		<div id="content" class="content">

							

<div class="main-content content-main">
	<div class="entry-content">
		<div class="entry-page-title">
				</div>
		<div class="wrap-intro layout-band">
<h2 class="ttl">Saving the world, bit by bit.</h2>
<p class="pull">Our vision? A world where more people have access to knowledge and more voices are heard. Where tools and solutions can be networked, shared, and &#8220;hacked.&#8221; Where knowledge not only provides answers, but empowers and inspires. We think libraries can help build this world. Let&#8217;s get started.</p>
<div class="wrap-we-are">
<ul class="list-unbulleted">
<li><a class="cta-link" href="/about/organization/">Discover our mission, vision, and values</a></li>
<li><a class="cta-link" href="https://www.pubpub.org/pub/future-of-libraries">Read the Future of Libraries Task Force Report</a></li>
</ul>
</div>
</div>
<div class="wrap-case-studies">
<div class="card card1">
<div class="c-image"><a href="/future-spaces/"><img decoding="async" src="http://libraries.mit.edu/app/uploads/2018/12/hayden-night-about.jpg" alt="Hayden Library exterior at night" /></a></div>
<div class="c-content">
<h3 class="c-ttl1 ttl">Envisioning Hayden Library</h3>
<p class="c-ttl2">The Libraries are pursuing a renovation of Hayden that reflects our vision for the future of libraries.</p>
<p><a class="c-cta" href="/future-spaces/">Learn more</a></p>
</div>
</div>
<div class="card card2">
<div class="c-image"><a href="http://news.mit.edu/2019/open-access-task-force-releases-draft-recommendations-0318"><img decoding="async" src="http://libraries.mit.edu/app/uploads/2019/03/lobby-7-crop.jpg" alt="MIT's Lobby 7 - a central location on campus" /></a></div>
<div class="c-content">
<h3 class="c-ttl1 ttl">Furthering MIT’s mission</h3>
<p class="c-ttl2">The final recommendations from the Open Access Task Force urge the open sharing of MIT publications, data, software, and more.</p>
<p><a class="c-cta" href="http://news.mit.edu/2019/open-access-task-force-releases-final-recommendations-1017">Learn more</a>
</div>
</div>
<div class="card card3">
<div class="c-image"><a href="/creos/"><img decoding="async" src="http://libraries.mit.edu/app/uploads/2019/06/CREOS-about.jpg" alt="Grand Challenges Summit" /></a></div>
<div class="c-content">
<h3 class="c-ttl1 ttl">Get to know CREOS</h3>
<p class="c-ttl2">The Center for Research on Equitable and Open Scholarship (CREOS) investigates how disparate communities can participate in scholarship with minimal bias or barriers.</p>
<p><a class="c-cta" href="/creos/">Learn more</a></p>
</div>
</div>
</div>
<div class="wrap-fol layout-band">
<h2 class="ttl">Our vision</h2>
<p>Here&#8217;s how we plan to contribute to a world with enduring, abundant, equitable, and meaningful access to information:</p>
<p class="vision-item vision-item1"><strong>Help you get your hands dirty with information</strong> We think a library can be more than a conveyor of information; it&#8217;s an all-discipline maker space where you can create new knowledge.</p>
<p class="vision-item vision-item2"><strong>Enable new forms of scholarship, teaching, and learning</strong> People want to interact with content in more active, innovative, and connected ways. We&#8217;ll build a global platform open to anyone who wants to build tools or use collections in novel ways &#8211; whether by humans, algorithms, or machines.</p>
<p class="vision-item vision-item3"><strong>Share the research of MIT</strong> To further its mission of building a better world, we will make the Institute&#8217;s distinct body of knowledge more open, equitable, accessible, and durable.</p>
<p class="vision-item vision-item4"><strong>Engage in research to tackle the big questions</strong> MIT is where research is applied to the toughest problems. The world needs new, better models and systems for information exchange. It&#8217;s up to us, and our partners around the world, to invent them.</p>
<p><a class="cta-link" href="https://www.pubpub.org/pub/future-of-libraries">Want to know more? Read the Future of Libraries Task Force Report</a><br />
<a class="cta-link" href="/about/organization/#strategic-priorities">Want to know how we plan to make it happen? Read our Strategic priorities</a></p>
</div>
<div class="wrap-linkblocks">
<div class="card card1">
<div class="c-image"><a href="/jobs"><img decoding="async" src="http://libraries.mit.edu/app/uploads/2018/01/desk-square.jpg" alt="Person visiting the Institute Archives" /></a></div>
<div class="c-content">
<h3 class="c-ttl1 ttl">Help build the future</h3>
<p class="c-ttl2"><a href="/jobs">View our current job openings</a></p>
</div>
</div>
<div class="card card2">
<div class="c-image"><a href="/giving"><img decoding="async" src="http://libraries.mit.edu/app/uploads/2018/01/hayden-square.jpg" alt="Hayden Library at dusk" /></a></div>
<div class="c-content">
<h3 class="c-ttl1 ttl">Support our mission</h3>
<p class="c-ttl2"><a href="/giving">Give to the Libraries</a></p>
</div>
</div>
<div class="card card3">
<div class="c-image"><a href="/news/in-the-media/"><img decoding="async" src="http://libraries.mit.edu/app/uploads/2018/01/columns-square.jpg" alt="Barker Library columns" /></a></div>
<div class="c-content">
<h3 class="c-ttl1 ttl">In the media</h3>
<p class="c-ttl2"><a href="/news/in-the-media/">Read the stories capturing attention</a></p>
</div>
</div>
</div>
<div class="wrap-social">
<div class="list-social list-unbulleted"><a title="MIT Libraries on Twitter" href="https://twitter.com/mitlibraries"><i class="fa fa-twitter" aria-hidden="true"></i><span class="sr">MIT Libraries on Twitter</span></a> <a title="MIT Libraries on Facebook" href="/facebook"><i class="fa fa-facebook" aria-hidden="true"></i><span class="sr">MIT Libraries on Facebook</span></a> <a title="MIT Libraries on Instagram" href="https://instagram.com/mitlibraries/"><i class="fa fa-instagram" aria-hidden="true"></i><span class="sr">MIT Libraries on Instagram</span></a> <a title="MIT Libraries on YouTube" href="https://www.youtube.com/user/MITLibraries"><i class="fa fa-youtube" aria-hidden="true"></i><span class="sr">MIT Libraries on YouTube</span></a> <a title="MIT Libraries Email Newsletter" href="/news/subscribe/"><i class="fa fa-envelope-o" aria-hidden="true"></i><span class="sr">MIT Libraries Email Newsletter</span></a></div>
</div>
<div class="layout-band">
<ul class="list-pipe">
<li><a href="mailto:brighamf@mit.edu">Media inquiries</a></li>
<li><a href="/about/organization/">About our organization</a></li>
<li><a href="/jobs">Jobs</a></li>
<li><a href="https://libraries.mit.edu/news/libraries-unveil/26777/">About our new identity</a></li>
</ul>
</div>
	</div>
</div>
			
			
		</div><!-- end div#content -->

	</div><!-- end div#stage -->


	<footer>

		<div class="footer-main flex-container">
	<div class="links-all flex-container">
		<div class="flex-item">
			<h4><a href="/search">Search</a></h4>
			<a href="/search-collections" class="link-sub">Search Our Collections</a>
			<a href="/worldcat" class="link-sub">WorldCat</a>
			<a href="https://libguides.mit.edu/az.php" class="link-sub">Databases A-Z</a>
			<a href="/search-reserves" class="link-sub">Course reserves</a>
			<a href="/site-search" class="link-sub">Site search</a>
			<a href="/search" class="link-sub">More search options</a>
		</div>
		<div class="flex-item">
			<h4><a href="/hours">Hours &amp; locations</a></h4>
			<a href="/hours" class="link-sub">Hours</a>
			<a href="/locations" class="link-sub">Map of locations</a>
			<a href="/study" class="link-sub">Study spaces</a>
			<a href="/exhibits" class="link-sub">Exhibits &amp; galleries</a>
		</div>
		<div class="flex-item">
			<h4><a href="/borrow">Borrow &amp; request</a></h4>
			<a href="/accounts" class="link-sub">Accounts overview</a>
			<a href="/reserves" class="link-sub">Course reserves</a>
			<a href="/otherlibraries" class="link-sub">Visit non-MIT libraries</a>
			<a href="/borrow" class="link-sub">More borrow &amp; request options</a>
		</div>
		<div class="flex-item">
			<h4><a href="/research-support">Research support</a></h4>
			<a href="/ask" class="link-sub">Ask us</a>
			<a href="/experts" class="link-sub">Research guides &amp; expert librarians</a>
			<a href="/scholarly" class="link-sub">Scholarly communications</a>
			<a href="/references" class="link-sub">Citation &amp; writing software</a>
			<a href="/research-support" class="link-sub">More research support options</a>
		</div>
		<div class="flex-item">
			<h4><a href="/about">About us</a></h4>
			<span class="link-sub"><a href="/contact">Contact us</a> | <a href="/follow">Follow us</a></span>
			<span class="link-sub"><a href="/news">News</a></span>
			<span class="link-sub"><a href="/events">Classes &amp; events</a></span>
			<span class="link-sub"><a href="/use-policies">Use policy</a></span>
			<span class="link-sub"><a href="/giving">Giving</a></span>
			<span class="link-sub"><a href="/about">More about us</a></span>
		</div>
	</div><!-- end div.links-all -->

	<div class="identity flex-container">
		<a href="/" class="logo-mit-lib"><img src="https://cdn.libraries.mit.edu/files/branding/local/mitlib-wordmark.svg" alt="MIT Libraries logo"></a><!-- End MIT Libraries Logo -->

		<div class="links-primary flex-container">
			<span><a href="https://libraries.mit.edu/privacy" class="link-sub">Privacy</a></span>
			<span><a href="https://libraries.mit.edu/permissions" class="link-sub">Permissions</a></span>
			<span><a href="https://libraries.mit.edu/accessibility" class="link-sub">Accessibility</a></span>
			<span><a href="https://libraries.mit.edu/contact" class="link-sub">Contact us</a></span>
		</div><!-- End div.links-primary -->

	</div><!-- End div.identity -->
</div>

		<div class="footer-info-institute">
			<a class="link-logo-mit" href="https://www.mit.edu">
				<img src="https://cdn.libraries.mit.edu/files/branding/local/mit_lockup_std-three-line_rgb_white.svg" alt="MIT" width="152">
			</a>

			<div class="license">Content created by the MIT Libraries, <a href="https://creativecommons.org/licenses/by-nc/4.0/">CC BY-NC</a> unless otherwise noted. <a href="https://libraries.mit.edu/research-support/notices/copyright-notify/">Notify us about copyright concerns</a>.</div>
		</div><!-- End div.footer-info-institure -->
	</footer>

</div><!-- End div.wrap-page -->

<script type="speculationrules">
{"prefetch":[{"source":"document","where":{"and":[{"href_matches":"\/*"},{"not":{"href_matches":["\/wp\/wp-*.php","\/wp\/wp-admin\/*","\/app\/uploads\/*","\/app\/*","\/app\/plugins\/*","\/app\/themes\/mitlib-parent\/*","\/*\\?(.+)"]}},{"not":{"selector_matches":"a[rel~=\"nofollow\"]"}},{"not":{"selector_matches":".no-prefetch, .no-prefetch a"}}]},"eagerness":"conservative"}]}
</script>
            <script type="text/javascript">
                jQuery(function($) {
                    function equalHeight(group) {
                        tallest = 0;
                        group.each(function() {
                            thisHeight = $(this).height();
                            if(thisHeight > tallest) {
                                tallest = thisHeight;
                            }
                        });
                        group.height(tallest);
                    }

                    equalHeight($(".dg-grid-shortcode .dg_grid-shortcode-col"));

                    $(window).resize(function() {
                        equalHeight($(".dg-grid-shortcode .dg_grid-shortcode-col"));
                    });
                });
            </script>
            <script type="text/javascript" src="https://libraries.mit.edu/wp/wp-includes/js/dist/hooks.min.js?ver=4d63a3d491d11ffd8ac6" id="wp-hooks-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/wp/wp-includes/js/dist/i18n.min.js?ver=5e580eb46a90c2b997e6" id="wp-i18n-js"></script>
<script type="text/javascript" id="wp-i18n-js-after">
/* <![CDATA[ */
wp.i18n.setLocaleData( { 'text direction\u0004ltr': [ 'ltr' ] } );
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/contact-form-7/includes/swv/js/index.js?ver=6.1" id="swv-js"></script>
<script type="text/javascript" id="contact-form-7-js-before">
/* <![CDATA[ */
var wpcf7 = {
    "api": {
        "root": "https:\/\/libraries.mit.edu\/wp-json\/",
        "namespace": "contact-form-7\/v1"
    }
};
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/contact-form-7/includes/js/index.js?ver=6.1" id="contact-form-7-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/dev.js?ver=0.8" id="dev-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/libchat.js?ver=0.8" id="libchat-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/menu.toggle.js?ver=0.8" id="menu-toggle-js"></script>
<script type="text/javascript" id="parent-production-js-before">
/* <![CDATA[ */
const THEME_ROOT = "https://libraries.mit.edu/app/themes/mitlib-parent";
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/alerts.js?ver=0.8" id="parent-production-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/core.js?ver=0.8" id="parent-interior-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/page-links-to/dist/new-tab.js?ver=3.3.7" id="page-links-to-js"></script>
<script type="text/javascript" id="wpcf7cf-scripts-js-extra">
/* <![CDATA[ */
var wpcf7cf_global_settings = {"ajaxurl":"https:\/\/libraries.mit.edu\/wp\/wp-admin\/admin-ajax.php"};
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/cf7-conditional-fields/js/scripts.js?ver=2.2.3" id="wpcf7cf-scripts-js"></script>
<script type="text/javascript">window.NREUM||(NREUM={});NREUM.info={"beacon":"bam.nr-data.net","licenseKey":"NRJS-03682cc69c1c5a39583","applicationID":"578343319","transactionName":"NQdVMkoCWUBYURENWAxNdgVMClhdFkIEA1I=","queueTime":0,"applicationTime":288,"atts":"GUBWRAIYSk4=","errorBeacon":"bam.nr-data.net","agent":""}</script></body>
</html>
", "response_headers": {"accept-ranges": ["bytes"], "age": ["406550"], "cache-control": ["public, max-age=604800"], "content-length": ["121192"], "content-type": ["text/html; charset=UTF-8"], "date": ["Tue, 09 Dec 2025 14:24:53 GMT"], "link": ["; rel=\"https://api.w.org/\", ; rel=\"alternate\"; title=\"JSON\"; type=\"application/json\", ; rel=shortlink"], "permissions-policy": ["geolocation=(), microphone=(), camera=()"], "referrer-policy": ["no-referrer-when-downgrade"], "server": ["nginx"], "strict-transport-security": ["max-age=300"], "vary": ["Accept-Encoding, Cookie"], "via": ["1.1 varnish"], "x-cache": ["HIT"], "x-cache-hits": ["1"], "x-content-type-options": ["nosniff"], "x-frame-options": ["SAMEORIGIN"], "x-pantheon-styx-hostname": ["styx-fe3-b-5df8569779-lfsfb"], "x-served-by": ["cache-chi-kigq8000172-CHI"], "x-styx-req-id": ["416c60bc-d158-11f0-bd91-c6a1c2f971b5"], "x-timer": ["S1765290293.170547,VS0,VE4"], "x-orig-content-encoding": ["gzip"]}} +{"url": "https://libraries.mit.edu/research-support/", "status": "active", "cdx_warc_filename": "rec-595f2ddb3156-mitlibwebsite-20251209142415718-4.warc.gz", "cdx_title": "Research support | MIT Libraries", "cdx_offset": "1972108", "cdx_length": "37641", "html_base64": "<!DOCTYPE html>
<!--[if lte IE 9]><html class="no-js lte-ie9" lang="en"><![endif]-->
<!--[if !(IE 8) | !(IE 9) ]><!-->
<html lang="en-US" class="no-js">
<!--<![endif]-->
<head>
	<meta charset="UTF-8" /><script type="text/javascript">(window.NREUM||(NREUM={})).init={privacy:{cookies_enabled:true},ajax:{deny_list:["bam.nr-data.net"]},feature_flags:["soft_nav"],distributed_tracing:{enabled:true}};(window.NREUM||(NREUM={})).loader_config={agentID:"594398788",accountID:"3844800",trustKey:"66686",xpid:"Vw4DVV5TCBAFU1lRAwIEV10=",licenseKey:"NRJS-03682cc69c1c5a39583",applicationID:"578343319",browserID:"594398788"};;/*! For license information please see nr-loader-spa-1.303.0.min.js.LICENSE.txt */
(()=>{var e,t,r={384:(e,t,r)=>{"use strict";r.d(t,{NT:()=>s,US:()=>d,Zm:()=>a,bQ:()=>u,dV:()=>c,pV:()=>l});var n=r(6154),i=r(1863),o=r(1910);const s={beacon:"bam.nr-data.net",errorBeacon:"bam.nr-data.net"};function a(){return n.gm.NREUM||(n.gm.NREUM={}),void 0===n.gm.newrelic&&(n.gm.newrelic=n.gm.NREUM),n.gm.NREUM}function c(){let e=a();return e.o||(e.o={ST:n.gm.setTimeout,SI:n.gm.setImmediate||n.gm.setInterval,CT:n.gm.clearTimeout,XHR:n.gm.XMLHttpRequest,REQ:n.gm.Request,EV:n.gm.Event,PR:n.gm.Promise,MO:n.gm.MutationObserver,FETCH:n.gm.fetch,WS:n.gm.WebSocket},(0,o.i)(...Object.values(e.o))),e}function u(e,t){let r=a();r.initializedAgents??={},t.initializedAt={ms:(0,i.t)(),date:new Date},r.initializedAgents[e]=t}function d(e,t){a()[e]=t}function l(){return function(){let e=a();const t=e.info||{};e.info={beacon:s.beacon,errorBeacon:s.errorBeacon,...t}}(),function(){let e=a();const t=e.init||{};e.init={...t}}(),c(),function(){let e=a();const t=e.loader_config||{};e.loader_config={...t}}(),a()}},782:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.pageViewTiming},860:(e,t,r)=>{"use strict";r.d(t,{$J:()=>d,K7:()=>c,P3:()=>u,XX:()=>i,Yy:()=>a,df:()=>o,qY:()=>n,v4:()=>s});const n="events",i="jserrors",o="browser/blobs",s="rum",a="browser/logs",c={ajax:"ajax",genericEvents:"generic_events",jserrors:i,logging:"logging",metrics:"metrics",pageAction:"page_action",pageViewEvent:"page_view_event",pageViewTiming:"page_view_timing",sessionReplay:"session_replay",sessionTrace:"session_trace",softNav:"soft_navigations",spa:"spa"},u={[c.pageViewEvent]:1,[c.pageViewTiming]:2,[c.metrics]:3,[c.jserrors]:4,[c.spa]:5,[c.ajax]:6,[c.sessionTrace]:7,[c.softNav]:8,[c.sessionReplay]:9,[c.logging]:10,[c.genericEvents]:11},d={[c.pageViewEvent]:s,[c.pageViewTiming]:n,[c.ajax]:n,[c.spa]:n,[c.softNav]:n,[c.metrics]:i,[c.jserrors]:i,[c.sessionTrace]:o,[c.sessionReplay]:o,[c.logging]:a,[c.genericEvents]:"ins"}},944:(e,t,r)=>{"use strict";r.d(t,{R:()=>i});var n=r(3241);function i(e,t){"function"==typeof console.debug&&(console.debug("New Relic Warning: https://github.com/newrelic/newrelic-browser-agent/blob/main/docs/warning-codes.md#".concat(e),t),(0,n.W)({agentIdentifier:null,drained:null,type:"data",name:"warn",feature:"warn",data:{code:e,secondary:t}}))}},993:(e,t,r)=>{"use strict";r.d(t,{A$:()=>o,ET:()=>s,TZ:()=>a,p_:()=>i});var n=r(860);const i={ERROR:"ERROR",WARN:"WARN",INFO:"INFO",DEBUG:"DEBUG",TRACE:"TRACE"},o={OFF:0,ERROR:1,WARN:2,INFO:3,DEBUG:4,TRACE:5},s="log",a=n.K7.logging},1687:(e,t,r)=>{"use strict";r.d(t,{Ak:()=>u,Ze:()=>f,x3:()=>d});var n=r(3241),i=r(7836),o=r(3606),s=r(860),a=r(2646);const c={};function u(e,t){const r={staged:!1,priority:s.P3[t]||0};l(e),c[e].get(t)||c[e].set(t,r)}function d(e,t){e&&c[e]&&(c[e].get(t)&&c[e].delete(t),p(e,t,!1),c[e].size&&h(e))}function l(e){if(!e)throw new Error("agentIdentifier required");c[e]||(c[e]=new Map)}function f(e="",t="feature",r=!1){if(l(e),!e||!c[e].get(t)||r)return p(e,t);c[e].get(t).staged=!0,h(e)}function h(e){const t=Array.from(c[e]);t.every(([e,t])=>t.staged)&&(t.sort((e,t)=>e[1].priority-t[1].priority),t.forEach(([t])=>{c[e].delete(t),p(e,t)}))}function p(e,t,r=!0){const s=e?i.ee.get(e):i.ee,c=o.i.handlers;if(!s.aborted&&s.backlog&&c){if((0,n.W)({agentIdentifier:e,type:"lifecycle",name:"drain",feature:t}),r){const e=s.backlog[t],r=c[t];if(r){for(let t=0;e&&t<e.length;++t)g(e[t],r);Object.entries(r).forEach(([e,t])=>{Object.values(t||{}).forEach(t=>{t[0]?.on&&t[0]?.context()instanceof a.y&&t[0].on(e,t[1])})})}}s.isolatedBacklog||delete c[t],s.backlog[t]=null,s.emit("drain-"+t,[])}}function g(e,t){var r=e[1];Object.values(t[r]||{}).forEach(t=>{var r=e[0];if(t[0]===r){var n=t[1],i=e[3],o=e[2];n.apply(i,o)}})}},1741:(e,t,r)=>{"use strict";r.d(t,{W:()=>o});var n=r(944),i=r(4261);class o{#e(e,...t){if(this[e]!==o.prototype[e])return this[e](...t);(0,n.R)(35,e)}addPageAction(e,t){return this.#e(i.hG,e,t)}register(e){return this.#e(i.eY,e)}recordCustomEvent(e,t){return this.#e(i.fF,e,t)}setPageViewName(e,t){return this.#e(i.Fw,e,t)}setCustomAttribute(e,t,r){return this.#e(i.cD,e,t,r)}noticeError(e,t){return this.#e(i.o5,e,t)}setUserId(e){return this.#e(i.Dl,e)}setApplicationVersion(e){return this.#e(i.nb,e)}setErrorHandler(e){return this.#e(i.bt,e)}addRelease(e,t){return this.#e(i.k6,e,t)}log(e,t){return this.#e(i.$9,e,t)}start(){return this.#e(i.d3)}finished(e){return this.#e(i.BL,e)}recordReplay(){return this.#e(i.CH)}pauseReplay(){return this.#e(i.Tb)}addToTrace(e){return this.#e(i.U2,e)}setCurrentRouteName(e){return this.#e(i.PA,e)}interaction(e){return this.#e(i.dT,e)}wrapLogger(e,t,r){return this.#e(i.Wb,e,t,r)}measure(e,t){return this.#e(i.V1,e,t)}consent(e){return this.#e(i.Pv,e)}}},1863:(e,t,r)=>{"use strict";function n(){return Math.floor(performance.now())}r.d(t,{t:()=>n})},1910:(e,t,r)=>{"use strict";r.d(t,{i:()=>o});var n=r(944);const i=new Map;function o(...e){return e.every(e=>{if(i.has(e))return i.get(e);const t="function"==typeof e&&e.toString().includes("[native code]");return t||(0,n.R)(64,e?.name||e?.toString()),i.set(e,t),t})}},2555:(e,t,r)=>{"use strict";r.d(t,{D:()=>a,f:()=>s});var n=r(384),i=r(8122);const o={beacon:n.NT.beacon,errorBeacon:n.NT.errorBeacon,licenseKey:void 0,applicationID:void 0,sa:void 0,queueTime:void 0,applicationTime:void 0,ttGuid:void 0,user:void 0,account:void 0,product:void 0,extra:void 0,jsAttributes:{},userAttributes:void 0,atts:void 0,transactionName:void 0,tNamePlain:void 0};function s(e){try{return!!e.licenseKey&&!!e.errorBeacon&&!!e.applicationID}catch(e){return!1}}const a=e=>(0,i.a)(e,o)},2614:(e,t,r)=>{"use strict";r.d(t,{BB:()=>s,H3:()=>n,g:()=>u,iL:()=>c,tS:()=>a,uh:()=>i,wk:()=>o});const n="NRBA",i="SESSION",o=144e5,s=18e5,a={STARTED:"session-started",PAUSE:"session-pause",RESET:"session-reset",RESUME:"session-resume",UPDATE:"session-update"},c={SAME_TAB:"same-tab",CROSS_TAB:"cross-tab"},u={OFF:0,FULL:1,ERROR:2}},2646:(e,t,r)=>{"use strict";r.d(t,{y:()=>n});class n{constructor(e){this.contextId=e}}},2843:(e,t,r)=>{"use strict";r.d(t,{u:()=>i});var n=r(3878);function i(e,t=!1,r,i){(0,n.DD)("visibilitychange",function(){if(t)return void("hidden"===document.visibilityState&&e());e(document.visibilityState)},r,i)}},3241:(e,t,r)=>{"use strict";r.d(t,{W:()=>o});var n=r(6154);const i="newrelic";function o(e={}){try{n.gm.dispatchEvent(new CustomEvent(i,{detail:e}))}catch(e){}}},3304:(e,t,r)=>{"use strict";r.d(t,{A:()=>o});var n=r(7836);const i=()=>{const e=new WeakSet;return(t,r)=>{if("object"==typeof r&&null!==r){if(e.has(r))return;e.add(r)}return r}};function o(e){try{return JSON.stringify(e,i())??""}catch(e){try{n.ee.emit("internal-error",[e])}catch(e){}return""}}},3333:(e,t,r)=>{"use strict";r.d(t,{$v:()=>d,TZ:()=>n,Xh:()=>c,Zp:()=>i,kd:()=>u,mq:()=>a,nf:()=>s,qN:()=>o});const n=r(860).K7.genericEvents,i=["auxclick","click","copy","keydown","paste","scrollend"],o=["focus","blur"],s=4,a=1e3,c=2e3,u=["PageAction","UserAction","BrowserPerformance"],d={RESOURCES:"experimental.resources",REGISTER:"register"}},3434:(e,t,r)=>{"use strict";r.d(t,{Jt:()=>o,YM:()=>u});var n=r(7836),i=r(5607);const o="nr@original:".concat(i.W),s=50;var a=Object.prototype.hasOwnProperty,c=!1;function u(e,t){return e||(e=n.ee),r.inPlace=function(e,t,n,i,o){n||(n="");const s="-"===n.charAt(0);for(let a=0;a<t.length;a++){const c=t[a],u=e[c];l(u)||(e[c]=r(u,s?c+n:n,i,c,o))}},r.flag=o,r;function r(t,r,n,c,u){return l(t)?t:(r||(r=""),nrWrapper[o]=t,function(e,t,r){if(Object.defineProperty&&Object.keys)try{return Object.keys(e).forEach(function(r){Object.defineProperty(t,r,{get:function(){return e[r]},set:function(t){return e[r]=t,t}})}),t}catch(e){d([e],r)}for(var n in e)a.call(e,n)&&(t[n]=e[n])}(t,nrWrapper,e),nrWrapper);function nrWrapper(){var o,a,l,f;let h;try{a=this,o=[...arguments],l="function"==typeof n?n(o,a):n||{}}catch(t){d([t,"",[o,a,c],l],e)}i(r+"start",[o,a,c],l,u);const p=performance.now();let g;try{return f=t.apply(a,o),g=performance.now(),f}catch(e){throw g=performance.now(),i(r+"err",[o,a,e],l,u),h=e,h}finally{const e=g-p,t={start:p,end:g,duration:e,isLongTask:e>=s,methodName:c,thrownError:h};t.isLongTask&&i("long-task",[t,a],l,u),i(r+"end",[o,a,f],l,u)}}}function i(r,n,i,o){if(!c||t){var s=c;c=!0;try{e.emit(r,n,i,t,o)}catch(t){d([t,r,n,i],e)}c=s}}}function d(e,t){t||(t=n.ee);try{t.emit("internal-error",e)}catch(e){}}function l(e){return!(e&&"function"==typeof e&&e.apply&&!e[o])}},3606:(e,t,r)=>{"use strict";r.d(t,{i:()=>o});var n=r(9908);o.on=s;var i=o.handlers={};function o(e,t,r,o){s(o||n.d,i,e,t,r)}function s(e,t,r,i,o){o||(o="feature"),e||(e=n.d);var s=t[o]=t[o]||{};(s[r]=s[r]||[]).push([e,i])}},3738:(e,t,r)=>{"use strict";r.d(t,{He:()=>i,Kp:()=>a,Lc:()=>u,Rz:()=>d,TZ:()=>n,bD:()=>o,d3:()=>s,jx:()=>l,sl:()=>f,uP:()=>c});const n=r(860).K7.sessionTrace,i="bstResource",o="resource",s="-start",a="-end",c="fn"+s,u="fn"+a,d="pushState",l=1e3,f=3e4},3785:(e,t,r)=>{"use strict";r.d(t,{R:()=>c,b:()=>u});var n=r(9908),i=r(1863),o=r(860),s=r(8154),a=r(993);function c(e,t,r={},c=a.p_.INFO,u,d=(0,i.t)()){(0,n.p)(s.xV,["API/logging/".concat(c.toLowerCase(),"/called")],void 0,o.K7.metrics,e),(0,n.p)(a.ET,[d,t,r,c,u],void 0,o.K7.logging,e)}function u(e){return"string"==typeof e&&Object.values(a.p_).some(t=>t===e.toUpperCase().trim())}},3878:(e,t,r)=>{"use strict";function n(e,t){return{capture:e,passive:!1,signal:t}}function i(e,t,r=!1,i){window.addEventListener(e,t,n(r,i))}function o(e,t,r=!1,i){document.addEventListener(e,t,n(r,i))}r.d(t,{DD:()=>o,jT:()=>n,sp:()=>i})},3962:(e,t,r)=>{"use strict";r.d(t,{AM:()=>s,O2:()=>l,OV:()=>o,Qu:()=>f,TZ:()=>c,ih:()=>h,pP:()=>a,t1:()=>d,tC:()=>i,wD:()=>u});var n=r(860);const i=["click","keydown","submit"],o="popstate",s="api",a="initialPageLoad",c=n.K7.softNav,u=5e3,d=500,l={INITIAL_PAGE_LOAD:"",ROUTE_CHANGE:1,UNSPECIFIED:2},f={INTERACTION:1,AJAX:2,CUSTOM_END:3,CUSTOM_TRACER:4},h={IP:"in progress",PF:"pending finish",FIN:"finished",CAN:"cancelled"}},4234:(e,t,r)=>{"use strict";r.d(t,{W:()=>o});var n=r(7836),i=r(1687);class o{constructor(e,t){this.agentIdentifier=e,this.ee=n.ee.get(e),this.featureName=t,this.blocked=!1}deregisterDrain(){(0,i.x3)(this.agentIdentifier,this.featureName)}}},4261:(e,t,r)=>{"use strict";r.d(t,{$9:()=>d,BL:()=>c,CH:()=>p,Dl:()=>R,Fw:()=>w,PA:()=>v,Pl:()=>n,Pv:()=>A,Tb:()=>f,U2:()=>s,V1:()=>E,Wb:()=>T,bt:()=>y,cD:()=>b,d3:()=>x,dT:()=>u,eY:()=>g,fF:()=>h,hG:()=>o,hw:()=>i,k6:()=>a,nb:()=>m,o5:()=>l});const n="api-",i=n+"ixn-",o="addPageAction",s="addToTrace",a="addRelease",c="finished",u="interaction",d="log",l="noticeError",f="pauseReplay",h="recordCustomEvent",p="recordReplay",g="register",m="setApplicationVersion",v="setCurrentRouteName",b="setCustomAttribute",y="setErrorHandler",w="setPageViewName",R="setUserId",x="start",T="wrapLogger",E="measure",A="consent"},4387:(e,t,r)=>{"use strict";function n(e={}){return!(!e.id||!e.name)}function i(e){return"string"==typeof e&&e.trim().length<501||"number"==typeof e}function o(e,t){if(2!==t?.harvestEndpointVersion)return{};const r=t.agentRef.runtime.appMetadata.agents[0].entityGuid;return n(e)?{"mfe.id":e.id,"mfe.name":e.name,eventSource:e.eventSource,"parent.id":e.parent?.id||r}:{"entity.guid":r,appId:t.agentRef.info.applicationID}}r.d(t,{Ux:()=>o,c7:()=>n,yo:()=>i})},5205:(e,t,r)=>{"use strict";r.d(t,{j:()=>_});var n=r(384),i=r(1741);var o=r(2555),s=r(3333);const a=e=>{if(!e||"string"!=typeof e)return!1;try{document.createDocumentFragment().querySelector(e)}catch{return!1}return!0};var c=r(2614),u=r(944),d=r(8122);const l="[data-nr-mask]",f=e=>(0,d.a)(e,(()=>{const e={feature_flags:[],experimental:{allow_registered_children:!1,resources:!1},mask_selector:"*",block_selector:"[data-nr-block]",mask_input_options:{color:!1,date:!1,"datetime-local":!1,email:!1,month:!1,number:!1,range:!1,search:!1,tel:!1,text:!1,time:!1,url:!1,week:!1,textarea:!1,select:!1,password:!0}};return{ajax:{deny_list:void 0,block_internal:!0,enabled:!0,autoStart:!0},api:{get allow_registered_children(){return e.feature_flags.includes(s.$v.REGISTER)||e.experimental.allow_registered_children},set allow_registered_children(t){e.experimental.allow_registered_children=t},duplicate_registered_data:!1},browser_consent_mode:{enabled:!1},distributed_tracing:{enabled:void 0,exclude_newrelic_header:void 0,cors_use_newrelic_header:void 0,cors_use_tracecontext_headers:void 0,allowed_origins:void 0},get feature_flags(){return e.feature_flags},set feature_flags(t){e.feature_flags=t},generic_events:{enabled:!0,autoStart:!0},harvest:{interval:30},jserrors:{enabled:!0,autoStart:!0},logging:{enabled:!0,autoStart:!0},metrics:{enabled:!0,autoStart:!0},obfuscate:void 0,page_action:{enabled:!0},page_view_event:{enabled:!0,autoStart:!0},page_view_timing:{enabled:!0,autoStart:!0},performance:{capture_marks:!1,capture_measures:!1,capture_detail:!0,resources:{get enabled(){return e.feature_flags.includes(s.$v.RESOURCES)||e.experimental.resources},set enabled(t){e.experimental.resources=t},asset_types:[],first_party_domains:[],ignore_newrelic:!0}},privacy:{cookies_enabled:!0},proxy:{assets:void 0,beacon:void 0},session:{expiresMs:c.wk,inactiveMs:c.BB},session_replay:{autoStart:!0,enabled:!1,preload:!1,sampling_rate:10,error_sampling_rate:100,collect_fonts:!1,inline_images:!1,fix_stylesheets:!0,mask_all_inputs:!0,get mask_text_selector(){return e.mask_selector},set mask_text_selector(t){a(t)?e.mask_selector="".concat(t,",").concat(l):""===t||null===t?e.mask_selector=l:(0,u.R)(5,t)},get block_class(){return"nr-block"},get ignore_class(){return"nr-ignore"},get mask_text_class(){return"nr-mask"},get block_selector(){return e.block_selector},set block_selector(t){a(t)?e.block_selector+=",".concat(t):""!==t&&(0,u.R)(6,t)},get mask_input_options(){return e.mask_input_options},set mask_input_options(t){t&&"object"==typeof t?e.mask_input_options={...t,password:!0}:(0,u.R)(7,t)}},session_trace:{enabled:!0,autoStart:!0},soft_navigations:{enabled:!0,autoStart:!0},spa:{enabled:!0,autoStart:!0},ssl:void 0,user_actions:{enabled:!0,elementAttributes:["id","className","tagName","type"]}}})());var h=r(6154),p=r(9324);let g=0;const m={buildEnv:p.F3,distMethod:p.Xs,version:p.xv,originTime:h.WN},v={consented:!1},b={appMetadata:{},get consented(){return this.session?.state?.consent||v.consented},set consented(e){v.consented=e},customTransaction:void 0,denyList:void 0,disabled:!1,harvester:void 0,isolatedBacklog:!1,isRecording:!1,loaderType:void 0,maxBytes:3e4,obfuscator:void 0,onerror:void 0,ptid:void 0,releaseIds:{},session:void 0,timeKeeper:void 0,registeredEntities:[],jsAttributesMetadata:{bytes:0},get harvestCount(){return++g}},y=e=>{const t=(0,d.a)(e,b),r=Object.keys(m).reduce((e,t)=>(e[t]={value:m[t],writable:!1,configurable:!0,enumerable:!0},e),{});return Object.defineProperties(t,r)};var w=r(5701);const R=e=>{const t=e.startsWith("http");e+="/",r.p=t?e:"https://"+e};var x=r(7836),T=r(3241);const E={accountID:void 0,trustKey:void 0,agentID:void 0,licenseKey:void 0,applicationID:void 0,xpid:void 0},A=e=>(0,d.a)(e,E),S=new Set;function _(e,t={},r,s){let{init:a,info:c,loader_config:u,runtime:d={},exposed:l=!0}=t;if(!c){const e=(0,n.pV)();a=e.init,c=e.info,u=e.loader_config}e.init=f(a||{}),e.loader_config=A(u||{}),c.jsAttributes??={},h.bv&&(c.jsAttributes.isWorker=!0),e.info=(0,o.D)(c);const p=e.init,g=[c.beacon,c.errorBeacon];S.has(e.agentIdentifier)||(p.proxy.assets&&(R(p.proxy.assets),g.push(p.proxy.assets)),p.proxy.beacon&&g.push(p.proxy.beacon),e.beacons=[...g],function(e){const t=(0,n.pV)();Object.getOwnPropertyNames(i.W.prototype).forEach(r=>{const n=i.W.prototype[r];if("function"!=typeof n||"constructor"===n)return;let o=t[r];e[r]&&!1!==e.exposed&&"micro-agent"!==e.runtime?.loaderType&&(t[r]=(...t)=>{const n=e[r](...t);return o?o(...t):n})})}(e),(0,n.US)("activatedFeatures",w.B),e.runSoftNavOverSpa&&=!0===p.soft_navigations.enabled&&p.feature_flags.includes("soft_nav")),d.denyList=[...p.ajax.deny_list||[],...p.ajax.block_internal?g:[]],d.ptid=e.agentIdentifier,d.loaderType=r,e.runtime=y(d),S.has(e.agentIdentifier)||(e.ee=x.ee.get(e.agentIdentifier),e.exposed=l,(0,T.W)({agentIdentifier:e.agentIdentifier,drained:!!w.B?.[e.agentIdentifier],type:"lifecycle",name:"initialize",feature:void 0,data:e.config})),S.add(e.agentIdentifier)}},5270:(e,t,r)=>{"use strict";r.d(t,{Aw:()=>s,SR:()=>o,rF:()=>a});var n=r(384),i=r(7767);function o(e){return!!(0,n.dV)().o.MO&&(0,i.V)(e)&&!0===e?.session_trace.enabled}function s(e){return!0===e?.session_replay.preload&&o(e)}function a(e,t){try{if("string"==typeof t?.type){if("password"===t.type.toLowerCase())return"*".repeat(e?.length||0);if(void 0!==t?.dataset?.nrUnmask||t?.classList?.contains("nr-unmask"))return e}}catch(e){}return"string"==typeof e?e.replace(/[\S]/g,"*"):"*".repeat(e?.length||0)}},5289:(e,t,r)=>{"use strict";r.d(t,{GG:()=>o,Qr:()=>a,sB:()=>s});var n=r(3878);function i(){return"undefined"==typeof document||"complete"===document.readyState}function o(e,t){if(i())return e();(0,n.sp)("load",e,t)}function s(e){if(i())return e();(0,n.DD)("DOMContentLoaded",e)}function a(e){if(i())return e();(0,n.sp)("popstate",e)}},5607:(e,t,r)=>{"use strict";r.d(t,{W:()=>n});const n=(0,r(9566).bz)()},5701:(e,t,r)=>{"use strict";r.d(t,{B:()=>o,t:()=>s});var n=r(3241);const i=new Set,o={};function s(e,t){const r=t.agentIdentifier;o[r]??={},e&&"object"==typeof e&&(i.has(r)||(t.ee.emit("rumresp",[e]),o[r]=e,i.add(r),(0,n.W)({agentIdentifier:r,loaded:!0,drained:!0,type:"lifecycle",name:"load",feature:void 0,data:e})))}},6154:(e,t,r)=>{"use strict";r.d(t,{A4:()=>a,OF:()=>d,RI:()=>i,WN:()=>h,bv:()=>o,gm:()=>s,lR:()=>f,m:()=>u,mw:()=>c,sb:()=>l});var n=r(1863);const i="undefined"!=typeof window&&!!window.document,o="undefined"!=typeof WorkerGlobalScope&&("undefined"!=typeof self&&self instanceof WorkerGlobalScope&&self.navigator instanceof WorkerNavigator||"undefined"!=typeof globalThis&&globalThis instanceof WorkerGlobalScope&&globalThis.navigator instanceof WorkerNavigator),s=i?window:"undefined"!=typeof WorkerGlobalScope&&("undefined"!=typeof self&&self instanceof WorkerGlobalScope&&self||"undefined"!=typeof globalThis&&globalThis instanceof WorkerGlobalScope&&globalThis),a="complete"===s?.document?.readyState,c=Boolean("hidden"===s?.document?.visibilityState),u=""+s?.location,d=/iPad|iPhone|iPod/.test(s.navigator?.userAgent),l=d&&"undefined"==typeof SharedWorker,f=(()=>{const e=s.navigator?.userAgent?.match(/Firefox[/\s](\d+\.\d+)/);return Array.isArray(e)&&e.length>=2?+e[1]:0})(),h=Date.now()-(0,n.t)()},6344:(e,t,r)=>{"use strict";r.d(t,{BB:()=>d,Qb:()=>l,TZ:()=>i,Ug:()=>s,Vh:()=>o,_s:()=>a,bc:()=>u,yP:()=>c});var n=r(2614);const i=r(860).K7.sessionReplay,o="errorDuringReplay",s=.12,a={DomContentLoaded:0,Load:1,FullSnapshot:2,IncrementalSnapshot:3,Meta:4,Custom:5},c={[n.g.ERROR]:15e3,[n.g.FULL]:3e5,[n.g.OFF]:0},u={RESET:{message:"Session was reset",sm:"Reset"},IMPORT:{message:"Recorder failed to import",sm:"Import"},TOO_MANY:{message:"429: Too Many Requests",sm:"Too-Many"},TOO_BIG:{message:"Payload was too large",sm:"Too-Big"},CROSS_TAB:{message:"Session Entity was set to OFF on another tab",sm:"Cross-Tab"},ENTITLEMENTS:{message:"Session Replay is not allowed and will not be started",sm:"Entitlement"}},d=5e3,l={API:"api",RESUME:"resume",SWITCH_TO_FULL:"switchToFull",INITIALIZE:"initialize",PRELOAD:"preload"}},6389:(e,t,r)=>{"use strict";function n(e,t=500,r={}){const n=r?.leading||!1;let i;return(...r)=>{n&&void 0===i&&(e.apply(this,r),i=setTimeout(()=>{i=clearTimeout(i)},t)),n||(clearTimeout(i),i=setTimeout(()=>{e.apply(this,r)},t))}}function i(e){let t=!1;return(...r)=>{t||(t=!0,e.apply(this,r))}}r.d(t,{J:()=>i,s:()=>n})},6630:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.pageViewEvent},6774:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.jserrors},7295:(e,t,r)=>{"use strict";r.d(t,{Xv:()=>s,gX:()=>i,iW:()=>o});var n=[];function i(e){if(!e||o(e))return!1;if(0===n.length)return!0;for(var t=0;t<n.length;t++){var r=n[t];if("*"===r.hostname)return!1;if(a(r.hostname,e.hostname)&&c(r.pathname,e.pathname))return!1}return!0}function o(e){return void 0===e.hostname}function s(e){if(n=[],e&&e.length)for(var t=0;t<e.length;t++){let r=e[t];if(!r)continue;0===r.indexOf("http://")?r=r.substring(7):0===r.indexOf("https://")&&(r=r.substring(8));const i=r.indexOf("/");let o,s;i>0?(o=r.substring(0,i),s=r.substring(i)):(o=r,s="");let[a]=o.split(":");n.push({hostname:a,pathname:s})}}function a(e,t){return!(e.length>t.length)&&t.indexOf(e)===t.length-e.length}function c(e,t){return 0===e.indexOf("/")&&(e=e.substring(1)),0===t.indexOf("/")&&(t=t.substring(1)),""===e||e===t}},7378:(e,t,r)=>{"use strict";r.d(t,{$p:()=>x,BR:()=>b,Kp:()=>R,L3:()=>y,Lc:()=>c,NC:()=>o,SG:()=>d,TZ:()=>i,U6:()=>p,UT:()=>m,d3:()=>w,dT:()=>f,e5:()=>E,gx:()=>v,l9:()=>l,oW:()=>h,op:()=>g,rw:()=>u,tH:()=>A,uP:()=>a,wW:()=>T,xq:()=>s});var n=r(384);const i=r(860).K7.spa,o=["click","submit","keypress","keydown","keyup","change"],s=999,a="fn-start",c="fn-end",u="cb-start",d="api-ixn-",l="remaining",f="interaction",h="spaNode",p="jsonpNode",g="fetch-start",m="fetch-done",v="fetch-body-",b="jsonp-end",y=(0,n.dV)().o.ST,w="-start",R="-end",x="-body",T="cb"+R,E="jsTime",A="fetch"},7485:(e,t,r)=>{"use strict";r.d(t,{D:()=>i});var n=r(6154);function i(e){if(0===(e||"").indexOf("data:"))return{protocol:"data"};try{const t=new URL(e,location.href),r={port:t.port,hostname:t.hostname,pathname:t.pathname,search:t.search,protocol:t.protocol.slice(0,t.protocol.indexOf(":")),sameOrigin:t.protocol===n.gm?.location?.protocol&&t.host===n.gm?.location?.host};return r.port&&""!==r.port||("http:"===t.protocol&&(r.port="80"),"https:"===t.protocol&&(r.port="443")),r.pathname&&""!==r.pathname?r.pathname.startsWith("/")||(r.pathname="/".concat(r.pathname)):r.pathname="/",r}catch(e){return{}}}},7699:(e,t,r)=>{"use strict";r.d(t,{It:()=>o,KC:()=>a,No:()=>i,qh:()=>s});var n=r(860);const i=16e3,o=1e6,s="SESSION_ERROR",a={[n.K7.logging]:!0,[n.K7.genericEvents]:!1,[n.K7.jserrors]:!1,[n.K7.ajax]:!1}},7767:(e,t,r)=>{"use strict";r.d(t,{V:()=>i});var n=r(6154);const i=e=>n.RI&&!0===e?.privacy.cookies_enabled},7836:(e,t,r)=>{"use strict";r.d(t,{P:()=>a,ee:()=>c});var n=r(384),i=r(8990),o=r(2646),s=r(5607);const a="nr@context:".concat(s.W),c=function e(t,r){var n={},s={},d={},l=!1;try{l=16===r.length&&u.initializedAgents?.[r]?.runtime.isolatedBacklog}catch(e){}var f={on:p,addEventListener:p,removeEventListener:function(e,t){var r=n[e];if(!r)return;for(var i=0;i<r.length;i++)r[i]===t&&r.splice(i,1)},emit:function(e,r,n,i,o){!1!==o&&(o=!0);if(c.aborted&&!i)return;t&&o&&t.emit(e,r,n);var a=h(n);g(e).forEach(e=>{e.apply(a,r)});var u=v()[s[e]];u&&u.push([f,e,r,a]);return a},get:m,listeners:g,context:h,buffer:function(e,t){const r=v();if(t=t||"feature",f.aborted)return;Object.entries(e||{}).forEach(([e,n])=>{s[n]=t,t in r||(r[t]=[])})},abort:function(){f._aborted=!0,Object.keys(f.backlog).forEach(e=>{delete f.backlog[e]})},isBuffering:function(e){return!!v()[s[e]]},debugId:r,backlog:l?{}:t&&"object"==typeof t.backlog?t.backlog:{},isolatedBacklog:l};return Object.defineProperty(f,"aborted",{get:()=>{let e=f._aborted||!1;return e||(t&&(e=t.aborted),e)}}),f;function h(e){return e&&e instanceof o.y?e:e?(0,i.I)(e,a,()=>new o.y(a)):new o.y(a)}function p(e,t){n[e]=g(e).concat(t)}function g(e){return n[e]||[]}function m(t){return d[t]=d[t]||e(f,t)}function v(){return f.backlog}}(void 0,"globalEE"),u=(0,n.Zm)();u.ee||(u.ee=c)},8122:(e,t,r)=>{"use strict";r.d(t,{a:()=>i});var n=r(944);function i(e,t){try{if(!e||"object"!=typeof e)return(0,n.R)(3);if(!t||"object"!=typeof t)return(0,n.R)(4);const r=Object.create(Object.getPrototypeOf(t),Object.getOwnPropertyDescriptors(t)),o=0===Object.keys(r).length?e:r;for(let s in o)if(void 0!==e[s])try{if(null===e[s]){r[s]=null;continue}Array.isArray(e[s])&&Array.isArray(t[s])?r[s]=Array.from(new Set([...e[s],...t[s]])):"object"==typeof e[s]&&"object"==typeof t[s]?r[s]=i(e[s],t[s]):r[s]=e[s]}catch(e){r[s]||(0,n.R)(1,e)}return r}catch(e){(0,n.R)(2,e)}}},8139:(e,t,r)=>{"use strict";r.d(t,{u:()=>f});var n=r(7836),i=r(3434),o=r(8990),s=r(6154);const a={},c=s.gm.XMLHttpRequest,u="addEventListener",d="removeEventListener",l="nr@wrapped:".concat(n.P);function f(e){var t=function(e){return(e||n.ee).get("events")}(e);if(a[t.debugId]++)return t;a[t.debugId]=1;var r=(0,i.YM)(t,!0);function f(e){r.inPlace(e,[u,d],"-",p)}function p(e,t){return e[1]}return"getPrototypeOf"in Object&&(s.RI&&h(document,f),c&&h(c.prototype,f),h(s.gm,f)),t.on(u+"-start",function(e,t){var n=e[1];if(null!==n&&("function"==typeof n||"object"==typeof n)&&"newrelic"!==e[0]){var i=(0,o.I)(n,l,function(){var e={object:function(){if("function"!=typeof n.handleEvent)return;return n.handleEvent.apply(n,arguments)},function:n}[typeof n];return e?r(e,"fn-",null,e.name||"anonymous"):n});this.wrapped=e[1]=i}}),t.on(d+"-start",function(e){e[1]=this.wrapped||e[1]}),t}function h(e,t,...r){let n=e;for(;"object"==typeof n&&!Object.prototype.hasOwnProperty.call(n,u);)n=Object.getPrototypeOf(n);n&&t(n,...r)}},8154:(e,t,r)=>{"use strict";r.d(t,{z_:()=>o,XG:()=>a,TZ:()=>n,rs:()=>i,xV:()=>s});r(6154),r(9566),r(384);const n=r(860).K7.metrics,i="sm",o="cm",s="storeSupportabilityMetrics",a="storeEventMetrics"},8374:(e,t,r)=>{r.nc=(()=>{try{return document?.currentScript?.nonce}catch(e){}return""})()},8990:(e,t,r)=>{"use strict";r.d(t,{I:()=>i});var n=Object.prototype.hasOwnProperty;function i(e,t,r){if(n.call(e,t))return e[t];var i=r();if(Object.defineProperty&&Object.keys)try{return Object.defineProperty(e,t,{value:i,writable:!0,enumerable:!1}),i}catch(e){}return e[t]=i,i}},9300:(e,t,r)=>{"use strict";r.d(t,{T:()=>n});const n=r(860).K7.ajax},9324:(e,t,r)=>{"use strict";r.d(t,{AJ:()=>s,F3:()=>i,Xs:()=>o,Yq:()=>a,xv:()=>n});const n="1.303.0",i="PROD",o="CDN",s="@newrelic/rrweb",a="1.0.1"},9566:(e,t,r)=>{"use strict";r.d(t,{LA:()=>a,ZF:()=>c,bz:()=>s,el:()=>u});var n=r(6154);const i="xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";function o(e,t){return e?15&e[t]:16*Math.random()|0}function s(){const e=n.gm?.crypto||n.gm?.msCrypto;let t,r=0;return e&&e.getRandomValues&&(t=e.getRandomValues(new Uint8Array(30))),i.split("").map(e=>"x"===e?o(t,r++).toString(16):"y"===e?(3&o()|8).toString(16):e).join("")}function a(e){const t=n.gm?.crypto||n.gm?.msCrypto;let r,i=0;t&&t.getRandomValues&&(r=t.getRandomValues(new Uint8Array(e)));const s=[];for(var a=0;a<e;a++)s.push(o(r,i++).toString(16));return s.join("")}function c(){return a(16)}function u(){return a(32)}},9908:(e,t,r)=>{"use strict";r.d(t,{d:()=>n,p:()=>i});var n=r(7836).ee.get("handle");function i(e,t,r,i,o){o?(o.buffer([e],i),o.emit(e,t,r)):(n.buffer([e],i),n.emit(e,t,r))}}},n={};function i(e){var t=n[e];if(void 0!==t)return t.exports;var o=n[e]={exports:{}};return r[e](o,o.exports,i),o.exports}i.m=r,i.d=(e,t)=>{for(var r in t)i.o(t,r)&&!i.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},i.f={},i.e=e=>Promise.all(Object.keys(i.f).reduce((t,r)=>(i.f[r](e,t),t),[])),i.u=e=>({212:"nr-spa-compressor",249:"nr-spa-recorder",478:"nr-spa"}[e]+"-1.303.0.min.js"),i.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),e={},t="NRBA-1.303.0.PROD:",i.l=(r,n,o,s)=>{if(e[r])e[r].push(n);else{var a,c;if(void 0!==o)for(var u=document.getElementsByTagName("script"),d=0;d<u.length;d++){var l=u[d];if(l.getAttribute("src")==r||l.getAttribute("data-webpack")==t+o){a=l;break}}if(!a){c=!0;var f={478:"sha512-Q1pLqcoiNmLHv0rtq3wFkJBA3kofBdRJl0ExDl0mTuAoCBd0qe/1J0XWrDlQKuNlUryL6aZfVkAMPLmoikWIoQ==",249:"sha512-695ZzudsxlMtHKnpDNvkMlJd3tdMtY03IQKVCw9SX12tjUC+f7Nrx5tnWO72Vg9RFf6DSY6wVmM3cEkRM12kkQ==",212:"sha512-18Gx1wIBsppcn0AnKFhwgw4IciNgFxiw3J74W393Ape+wtg4hlg7t6SBKsIE/Dk/tfl2yltgcgBFvYRs283AFg=="};(a=document.createElement("script")).charset="utf-8",i.nc&&a.setAttribute("nonce",i.nc),a.setAttribute("data-webpack",t+o),a.src=r,0!==a.src.indexOf(window.location.origin+"/")&&(a.crossOrigin="anonymous"),f[s]&&(a.integrity=f[s])}e[r]=[n];var h=(t,n)=>{a.onerror=a.onload=null,clearTimeout(p);var i=e[r];if(delete e[r],a.parentNode&&a.parentNode.removeChild(a),i&&i.forEach(e=>e(n)),t)return t(n)},p=setTimeout(h.bind(null,void 0,{type:"timeout",target:a}),12e4);a.onerror=h.bind(null,a.onerror),a.onload=h.bind(null,a.onload),c&&document.head.appendChild(a)}},i.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},i.p="https://js-agent.newrelic.com/",(()=>{var e={38:0,788:0};i.f.j=(t,r)=>{var n=i.o(e,t)?e[t]:void 0;if(0!==n)if(n)r.push(n[2]);else{var o=new Promise((r,i)=>n=e[t]=[r,i]);r.push(n[2]=o);var s=i.p+i.u(t),a=new Error;i.l(s,r=>{if(i.o(e,t)&&(0!==(n=e[t])&&(e[t]=void 0),n)){var o=r&&("load"===r.type?"missing":r.type),s=r&&r.target&&r.target.src;a.message="Loading chunk "+t+" failed.\n("+o+": "+s+")",a.name="ChunkLoadError",a.type=o,a.request=s,n[1](a)}},"chunk-"+t,t)}};var t=(t,r)=>{var n,o,[s,a,c]=r,u=0;if(s.some(t=>0!==e[t])){for(n in a)i.o(a,n)&&(i.m[n]=a[n]);if(c)c(i)}for(t&&t(r);u<s.length;u++)o=s[u],i.o(e,o)&&e[o]&&e[o][0](),e[o]=0},r=self["webpackChunk:NRBA-1.303.0.PROD"]=self["webpackChunk:NRBA-1.303.0.PROD"]||[];r.forEach(t.bind(null,0)),r.push=t.bind(null,r.push.bind(r))})(),(()=>{"use strict";i(8374);var e=i(9566),t=i(1741);class r extends t.W{agentIdentifier=(0,e.LA)(16)}var n=i(860);const o=Object.values(n.K7);var s=i(5205);var a=i(9908),c=i(1863),u=i(4261),d=i(3241),l=i(944),f=i(5701),h=i(8154);function p(e,t,i,o){const s=o||i;!s||s[e]&&s[e]!==r.prototype[e]||(s[e]=function(){(0,a.p)(h.xV,["API/"+e+"/called"],void 0,n.K7.metrics,i.ee),(0,d.W)({agentIdentifier:i.agentIdentifier,drained:!!f.B?.[i.agentIdentifier],type:"data",name:"api",feature:u.Pl+e,data:{}});try{return t.apply(this,arguments)}catch(e){(0,l.R)(23,e)}})}function g(e,t,r,n,i){const o=e.info;null===r?delete o.jsAttributes[t]:o.jsAttributes[t]=r,(i||null===r)&&(0,a.p)(u.Pl+n,[(0,c.t)(),t,r],void 0,"session",e.ee)}var m=i(1687),v=i(4234),b=i(5289),y=i(6154),w=i(5270),R=i(7767),x=i(6389),T=i(7699);class E extends v.W{constructor(e,t){super(e.agentIdentifier,t),this.agentRef=e,this.abortHandler=void 0,this.featAggregate=void 0,this.loadedSuccessfully=void 0,this.onAggregateImported=new Promise(e=>{this.loadedSuccessfully=e}),this.deferred=Promise.resolve(),!1===e.init[this.featureName].autoStart?this.deferred=new Promise((t,r)=>{this.ee.on("manual-start-all",(0,x.J)(()=>{(0,m.Ak)(e.agentIdentifier,this.featureName),t()}))}):(0,m.Ak)(e.agentIdentifier,t)}importAggregator(e,t,r={}){if(this.featAggregate)return;const n=async()=>{let n;await this.deferred;try{if((0,R.V)(e.init)){const{setupAgentSession:t}=await i.e(478).then(i.bind(i,8766));n=t(e)}}catch(e){(0,l.R)(20,e),this.ee.emit("internal-error",[e]),(0,a.p)(T.qh,[e],void 0,this.featureName,this.ee)}try{if(!this.#t(this.featureName,n,e.init))return(0,m.Ze)(this.agentIdentifier,this.featureName),void this.loadedSuccessfully(!1);const{Aggregate:i}=await t();this.featAggregate=new i(e,r),e.runtime.harvester.initializedAggregates.push(this.featAggregate),this.loadedSuccessfully(!0)}catch(e){(0,l.R)(34,e),this.abortHandler?.(),(0,m.Ze)(this.agentIdentifier,this.featureName,!0),this.loadedSuccessfully(!1),this.ee&&this.ee.abort()}};y.RI?(0,b.GG)(()=>n(),!0):n()}#t(e,t,r){if(this.blocked)return!1;switch(e){case n.K7.sessionReplay:return(0,w.SR)(r)&&!!t;case n.K7.sessionTrace:return!!t;default:return!0}}}var A=i(6630),S=i(2614);class _ extends E{static featureName=A.T;constructor(e){var t;super(e,A.T),this.setupInspectionEvents(e.agentIdentifier),t=e,p(u.Fw,function(e,r){"string"==typeof e&&("/"!==e.charAt(0)&&(e="/"+e),t.runtime.customTransaction=(r||"http://custom.transaction")+e,(0,a.p)(u.Pl+u.Fw,[(0,c.t)()],void 0,void 0,t.ee))},t),this.importAggregator(e,()=>i.e(478).then(i.bind(i,1983)))}setupInspectionEvents(e){const t=(t,r)=>{t&&(0,d.W)({agentIdentifier:e,timeStamp:t.timeStamp,loaded:"complete"===t.target.readyState,type:"window",name:r,data:t.target.location+""})};(0,b.sB)(e=>{t(e,"DOMContentLoaded")}),(0,b.GG)(e=>{t(e,"load")}),(0,b.Qr)(e=>{t(e,"navigate")}),this.ee.on(S.tS.UPDATE,(t,r)=>{(0,d.W)({agentIdentifier:e,type:"lifecycle",name:"session",data:r})})}}var O=i(384);var N=i(2843),I=i(3878),P=i(782);class j extends E{static featureName=P.T;constructor(e){super(e,P.T),y.RI&&((0,N.u)(()=>(0,a.p)("docHidden",[(0,c.t)()],void 0,P.T,this.ee),!0),(0,I.sp)("pagehide",()=>(0,a.p)("winPagehide",[(0,c.t)()],void 0,P.T,this.ee)),this.importAggregator(e,()=>i.e(478).then(i.bind(i,9917))))}}class k extends E{static featureName=h.TZ;constructor(e){super(e,h.TZ),y.RI&&document.addEventListener("securitypolicyviolation",e=>{(0,a.p)(h.xV,["Generic/CSPViolation/Detected"],void 0,this.featureName,this.ee)}),this.importAggregator(e,()=>i.e(478).then(i.bind(i,6555)))}}var C=i(6774),L=i(3304);class H{constructor(e,t,r,n,i){this.name="UncaughtError",this.message="string"==typeof e?e:(0,L.A)(e),this.sourceURL=t,this.line=r,this.column=n,this.__newrelic=i}}function M(e){return U(e)?e:new H(void 0!==e?.message?e.message:e,e?.filename||e?.sourceURL,e?.lineno||e?.line,e?.colno||e?.col,e?.__newrelic,e?.cause)}function K(e){const t="Unhandled Promise Rejection: ";if(!e?.reason)return;if(U(e.reason)){try{e.reason.message.startsWith(t)||(e.reason.message=t+e.reason.message)}catch(e){}return M(e.reason)}const r=M(e.reason);return(r.message||"").startsWith(t)||(r.message=t+r.message),r}function D(e){if(e.error instanceof SyntaxError&&!/:\d+$/.test(e.error.stack?.trim())){const t=new H(e.message,e.filename,e.lineno,e.colno,e.error.__newrelic,e.cause);return t.name=SyntaxError.name,t}return U(e.error)?e.error:M(e)}function U(e){return e instanceof Error&&!!e.stack}function F(e,t,r,i,o=(0,c.t)()){"string"==typeof e&&(e=new Error(e)),(0,a.p)("err",[e,o,!1,t,r.runtime.isRecording,void 0,i],void 0,n.K7.jserrors,r.ee),(0,a.p)("uaErr",[],void 0,n.K7.genericEvents,r.ee)}var W=i(4387),B=i(993),V=i(3785);function G(e,{customAttributes:t={},level:r=B.p_.INFO}={},n,i,o=(0,c.t)()){(0,V.R)(n.ee,e,t,r,i,o)}function z(e,t,r,i,o=(0,c.t)()){(0,a.p)(u.Pl+u.hG,[o,e,t,i],void 0,n.K7.genericEvents,r.ee)}function Z(e,t,r,i,o=(0,c.t)()){const{start:s,end:d,customAttributes:f}=t||{},h={customAttributes:f||{}};if("object"!=typeof h.customAttributes||"string"!=typeof e||0===e.length)return void(0,l.R)(57);const p=(e,t)=>null==e?t:"number"==typeof e?e:e instanceof PerformanceMark?e.startTime:Number.NaN;if(h.start=p(s,0),h.end=p(d,o),Number.isNaN(h.start)||Number.isNaN(h.end))(0,l.R)(57);else{if(h.duration=h.end-h.start,!(h.duration<0))return(0,a.p)(u.Pl+u.V1,[h,e,i],void 0,n.K7.genericEvents,r.ee),h;(0,l.R)(58)}}function q(e,t={},r,i,o=(0,c.t)()){(0,a.p)(u.Pl+u.fF,[o,e,t,i],void 0,n.K7.genericEvents,r.ee)}function X(e){p(u.eY,function(t){return Y(e,t)},e)}function Y(e,t,r){const i={};(0,l.R)(54,"newrelic.register"),t||={},t.eventSource="MicroFrontendBrowserAgent",t.licenseKey||=e.info.licenseKey,t.blocked=!1,t.parent=r||{};let o=()=>{};const s=e.runtime.registeredEntities,u=s.find(({metadata:{target:{id:e,name:r}}})=>e===t.id);if(u)return u.metadata.target.name!==t.name&&(u.metadata.target.name=t.name),u;const d=e=>{t.blocked=!0,o=e};e.init.api.allow_registered_children||d((0,x.J)(()=>(0,l.R)(55))),(0,W.c7)(t)||d((0,x.J)(()=>(0,l.R)(48,t))),(0,W.yo)(t.id)&&(0,W.yo)(t.name)||d((0,x.J)(()=>(0,l.R)(48,t)));const f={addPageAction:(r,n={})=>m(z,[r,{...i,...n},e],t),log:(r,n={})=>m(G,[r,{...n,customAttributes:{...i,...n.customAttributes||{}}},e],t),measure:(r,n={})=>m(Z,[r,{...n,customAttributes:{...i,...n.customAttributes||{}}},e],t),noticeError:(r,n={})=>m(F,[r,{...i,...n},e],t),register:(t={})=>m(Y,[e,t],f.metadata.target),recordCustomEvent:(r,n={})=>m(q,[r,{...i,...n},e],t),setApplicationVersion:e=>g("application.version",e),setCustomAttribute:(e,t)=>g(e,t),setUserId:e=>g("enduser.id",e),metadata:{customAttributes:i,target:t}},p=()=>(t.blocked&&o(),t.blocked);p()||s.push(f);const g=(e,t)=>{p()||(i[e]=t)},m=(t,r,i)=>{if(p())return;const o=(0,c.t)();(0,a.p)(h.xV,["API/register/".concat(t.name,"/called")],void 0,n.K7.metrics,e.ee);try{return e.init.api.duplicate_registered_data&&"register"!==t.name&&t(...r,void 0,o),t(...r,i,o)}catch(e){(0,l.R)(50,e)}};return f}class J extends E{static featureName=C.T;constructor(e){var t;super(e,C.T),t=e,p(u.o5,(e,r)=>F(e,r,t),t),function(e){p(u.bt,function(t){e.runtime.onerror=t},e)}(e),function(e){let t=0;p(u.k6,function(e,r){++t>10||(this.runtime.releaseIds[e.slice(-200)]=(""+r).slice(-200))},e)}(e),X(e);try{this.removeOnAbort=new AbortController}catch(e){}this.ee.on("internal-error",(t,r)=>{this.abortHandler&&(0,a.p)("ierr",[M(t),(0,c.t)(),!0,{},e.runtime.isRecording,r],void 0,this.featureName,this.ee)}),y.gm.addEventListener("unhandledrejection",t=>{this.abortHandler&&(0,a.p)("err",[K(t),(0,c.t)(),!1,{unhandledPromiseRejection:1},e.runtime.isRecording],void 0,this.featureName,this.ee)},(0,I.jT)(!1,this.removeOnAbort?.signal)),y.gm.addEventListener("error",t=>{this.abortHandler&&(0,a.p)("err",[D(t),(0,c.t)(),!1,{},e.runtime.isRecording],void 0,this.featureName,this.ee)},(0,I.jT)(!1,this.removeOnAbort?.signal)),this.abortHandler=this.#r,this.importAggregator(e,()=>i.e(478).then(i.bind(i,2176)))}#r(){this.removeOnAbort?.abort(),this.abortHandler=void 0}}var Q=i(8990);let ee=1;function te(e){const t=typeof e;return!e||"object"!==t&&"function"!==t?-1:e===y.gm?0:(0,Q.I)(e,"nr@id",function(){return ee++})}function re(e){if("string"==typeof e&&e.length)return e.length;if("object"==typeof e){if("undefined"!=typeof ArrayBuffer&&e instanceof ArrayBuffer&&e.byteLength)return e.byteLength;if("undefined"!=typeof Blob&&e instanceof Blob&&e.size)return e.size;if(!("undefined"!=typeof FormData&&e instanceof FormData))try{return(0,L.A)(e).length}catch(e){return}}}var ne=i(8139),ie=i(7836),oe=i(3434);const se={},ae=["open","send"];function ce(e){var t=e||ie.ee;const r=function(e){return(e||ie.ee).get("xhr")}(t);if(void 0===y.gm.XMLHttpRequest)return r;if(se[r.debugId]++)return r;se[r.debugId]=1,(0,ne.u)(t);var n=(0,oe.YM)(r),i=y.gm.XMLHttpRequest,o=y.gm.MutationObserver,s=y.gm.Promise,a=y.gm.setInterval,c="readystatechange",u=["onload","onerror","onabort","onloadstart","onloadend","onprogress","ontimeout"],d=[],f=y.gm.XMLHttpRequest=function(e){const t=new i(e),o=r.context(t);try{r.emit("new-xhr",[t],o),t.addEventListener(c,(s=o,function(){var e=this;e.readyState>3&&!s.resolved&&(s.resolved=!0,r.emit("xhr-resolved",[],e)),n.inPlace(e,u,"fn-",b)}),(0,I.jT)(!1))}catch(e){(0,l.R)(15,e);try{r.emit("internal-error",[e])}catch(e){}}var s;return t};function h(e,t){n.inPlace(t,["onreadystatechange"],"fn-",b)}if(function(e,t){for(var r in e)t[r]=e[r]}(i,f),f.prototype=i.prototype,n.inPlace(f.prototype,ae,"-xhr-",b),r.on("send-xhr-start",function(e,t){h(e,t),function(e){d.push(e),o&&(p?p.then(v):a?a(v):(g=-g,m.data=g))}(t)}),r.on("open-xhr-start",h),o){var p=s&&s.resolve();if(!a&&!s){var g=1,m=document.createTextNode(g);new o(v).observe(m,{characterData:!0})}}else t.on("fn-end",function(e){e[0]&&e[0].type===c||v()});function v(){for(var e=0;e<d.length;e++)h(0,d[e]);d.length&&(d=[])}function b(e,t){return t}return r}var ue="fetch-",de=ue+"body-",le=["arrayBuffer","blob","json","text","formData"],fe=y.gm.Request,he=y.gm.Response,pe="prototype";const ge={};function me(e){const t=function(e){return(e||ie.ee).get("fetch")}(e);if(!(fe&&he&&y.gm.fetch))return t;if(ge[t.debugId]++)return t;function r(e,r,n){var i=e[r];"function"==typeof i&&(e[r]=function(){var e,r=[...arguments],o={};t.emit(n+"before-start",[r],o),o[ie.P]&&o[ie.P].dt&&(e=o[ie.P].dt);var s=i.apply(this,r);return t.emit(n+"start",[r,e],s),s.then(function(e){return t.emit(n+"end",[null,e],s),e},function(e){throw t.emit(n+"end",[e],s),e})})}return ge[t.debugId]=1,le.forEach(e=>{r(fe[pe],e,de),r(he[pe],e,de)}),r(y.gm,"fetch",ue),t.on(ue+"end",function(e,r){var n=this;if(r){var i=r.headers.get("content-length");null!==i&&(n.rxSize=i),t.emit(ue+"done",[null,r],n)}else t.emit(ue+"done",[e],n)}),t}var ve=i(7485);class be{constructor(e){this.agentRef=e}generateTracePayload(t){const r=this.agentRef.loader_config;if(!this.shouldGenerateTrace(t)||!r)return null;var n=(r.accountID||"").toString()||null,i=(r.agentID||"").toString()||null,o=(r.trustKey||"").toString()||null;if(!n||!i)return null;var s=(0,e.ZF)(),a=(0,e.el)(),c=Date.now(),u={spanId:s,traceId:a,timestamp:c};return(t.sameOrigin||this.isAllowedOrigin(t)&&this.useTraceContextHeadersForCors())&&(u.traceContextParentHeader=this.generateTraceContextParentHeader(s,a),u.traceContextStateHeader=this.generateTraceContextStateHeader(s,c,n,i,o)),(t.sameOrigin&&!this.excludeNewrelicHeader()||!t.sameOrigin&&this.isAllowedOrigin(t)&&this.useNewrelicHeaderForCors())&&(u.newrelicHeader=this.generateTraceHeader(s,a,c,n,i,o)),u}generateTraceContextParentHeader(e,t){return"00-"+t+"-"+e+"-01"}generateTraceContextStateHeader(e,t,r,n,i){return i+"@nr=0-1-"+r+"-"+n+"-"+e+"----"+t}generateTraceHeader(e,t,r,n,i,o){if(!("function"==typeof y.gm?.btoa))return null;var s={v:[0,1],d:{ty:"Browser",ac:n,ap:i,id:e,tr:t,ti:r}};return o&&n!==o&&(s.d.tk=o),btoa((0,L.A)(s))}shouldGenerateTrace(e){return this.agentRef.init?.distributed_tracing?.enabled&&this.isAllowedOrigin(e)}isAllowedOrigin(e){var t=!1;const r=this.agentRef.init?.distributed_tracing;if(e.sameOrigin)t=!0;else if(r?.allowed_origins instanceof Array)for(var n=0;n<r.allowed_origins.length;n++){var i=(0,ve.D)(r.allowed_origins[n]);if(e.hostname===i.hostname&&e.protocol===i.protocol&&e.port===i.port){t=!0;break}}return t}excludeNewrelicHeader(){var e=this.agentRef.init?.distributed_tracing;return!!e&&!!e.exclude_newrelic_header}useNewrelicHeaderForCors(){var e=this.agentRef.init?.distributed_tracing;return!!e&&!1!==e.cors_use_newrelic_header}useTraceContextHeadersForCors(){var e=this.agentRef.init?.distributed_tracing;return!!e&&!!e.cors_use_tracecontext_headers}}var ye=i(9300),we=i(7295);function Re(e){return"string"==typeof e?e:e instanceof(0,O.dV)().o.REQ?e.url:y.gm?.URL&&e instanceof URL?e.href:void 0}var xe=["load","error","abort","timeout"],Te=xe.length,Ee=(0,O.dV)().o.REQ,Ae=(0,O.dV)().o.XHR;const Se="X-NewRelic-App-Data";class _e extends E{static featureName=ye.T;constructor(e){super(e,ye.T),this.dt=new be(e),this.handler=(e,t,r,n)=>(0,a.p)(e,t,r,n,this.ee);try{const e={xmlhttprequest:"xhr",fetch:"fetch",beacon:"beacon"};y.gm?.performance?.getEntriesByType("resource").forEach(t=>{if(t.initiatorType in e&&0!==t.responseStatus){const r={status:t.responseStatus},i={rxSize:t.transferSize,duration:Math.floor(t.duration),cbTime:0};Oe(r,t.name),this.handler("xhr",[r,i,t.startTime,t.responseEnd,e[t.initiatorType]],void 0,n.K7.ajax)}})}catch(e){}me(this.ee),ce(this.ee),function(e,t,r,i){function o(e){var t=this;t.totalCbs=0,t.called=0,t.cbTime=0,t.end=E,t.ended=!1,t.xhrGuids={},t.lastSize=null,t.loadCaptureCalled=!1,t.params=this.params||{},t.metrics=this.metrics||{},t.latestLongtaskEnd=0,e.addEventListener("load",function(r){A(t,e)},(0,I.jT)(!1)),y.lR||e.addEventListener("progress",function(e){t.lastSize=e.loaded},(0,I.jT)(!1))}function s(e){this.params={method:e[0]},Oe(this,e[1]),this.metrics={}}function u(t,r){e.loader_config.xpid&&this.sameOrigin&&r.setRequestHeader("X-NewRelic-ID",e.loader_config.xpid);var n=i.generateTracePayload(this.parsedOrigin);if(n){var o=!1;n.newrelicHeader&&(r.setRequestHeader("newrelic",n.newrelicHeader),o=!0),n.traceContextParentHeader&&(r.setRequestHeader("traceparent",n.traceContextParentHeader),n.traceContextStateHeader&&r.setRequestHeader("tracestate",n.traceContextStateHeader),o=!0),o&&(this.dt=n)}}function d(e,r){var n=this.metrics,i=e[0],o=this;if(n&&i){var s=re(i);s&&(n.txSize=s)}this.startTime=(0,c.t)(),this.body=i,this.listener=function(e){try{"abort"!==e.type||o.loadCaptureCalled||(o.params.aborted=!0),("load"!==e.type||o.called===o.totalCbs&&(o.onloadCalled||"function"!=typeof r.onload)&&"function"==typeof o.end)&&o.end(r)}catch(e){try{t.emit("internal-error",[e])}catch(e){}}};for(var a=0;a<Te;a++)r.addEventListener(xe[a],this.listener,(0,I.jT)(!1))}function l(e,t,r){this.cbTime+=e,t?this.onloadCalled=!0:this.called+=1,this.called!==this.totalCbs||!this.onloadCalled&&"function"==typeof r.onload||"function"!=typeof this.end||this.end(r)}function f(e,t){var r=""+te(e)+!!t;this.xhrGuids&&!this.xhrGuids[r]&&(this.xhrGuids[r]=!0,this.totalCbs+=1)}function p(e,t){var r=""+te(e)+!!t;this.xhrGuids&&this.xhrGuids[r]&&(delete this.xhrGuids[r],this.totalCbs-=1)}function g(){this.endTime=(0,c.t)()}function m(e,r){r instanceof Ae&&"load"===e[0]&&t.emit("xhr-load-added",[e[1],e[2]],r)}function v(e,r){r instanceof Ae&&"load"===e[0]&&t.emit("xhr-load-removed",[e[1],e[2]],r)}function b(e,t,r){t instanceof Ae&&("onload"===r&&(this.onload=!0),("load"===(e[0]&&e[0].type)||this.onload)&&(this.xhrCbStart=(0,c.t)()))}function w(e,r){this.xhrCbStart&&t.emit("xhr-cb-time",[(0,c.t)()-this.xhrCbStart,this.onload,r],r)}function R(e){var t,r=e[1]||{};if("string"==typeof e[0]?0===(t=e[0]).length&&y.RI&&(t=""+y.gm.location.href):e[0]&&e[0].url?t=e[0].url:y.gm?.URL&&e[0]&&e[0]instanceof URL?t=e[0].href:"function"==typeof e[0].toString&&(t=e[0].toString()),"string"==typeof t&&0!==t.length){t&&(this.parsedOrigin=(0,ve.D)(t),this.sameOrigin=this.parsedOrigin.sameOrigin);var n=i.generateTracePayload(this.parsedOrigin);if(n&&(n.newrelicHeader||n.traceContextParentHeader))if(e[0]&&e[0].headers)a(e[0].headers,n)&&(this.dt=n);else{var o={};for(var s in r)o[s]=r[s];o.headers=new Headers(r.headers||{}),a(o.headers,n)&&(this.dt=n),e.length>1?e[1]=o:e.push(o)}}function a(e,t){var r=!1;return t.newrelicHeader&&(e.set("newrelic",t.newrelicHeader),r=!0),t.traceContextParentHeader&&(e.set("traceparent",t.traceContextParentHeader),t.traceContextStateHeader&&e.set("tracestate",t.traceContextStateHeader),r=!0),r}}function x(e,t){this.params={},this.metrics={},this.startTime=(0,c.t)(),this.dt=t,e.length>=1&&(this.target=e[0]),e.length>=2&&(this.opts=e[1]);var r=this.opts||{},n=this.target;Oe(this,Re(n));var i=(""+(n&&n instanceof Ee&&n.method||r.method||"GET")).toUpperCase();this.params.method=i,this.body=r.body,this.txSize=re(r.body)||0}function T(e,t){if(this.endTime=(0,c.t)(),this.params||(this.params={}),(0,we.iW)(this.params))return;let i;this.params.status=t?t.status:0,"string"==typeof this.rxSize&&this.rxSize.length>0&&(i=+this.rxSize);const o={txSize:this.txSize,rxSize:i,duration:(0,c.t)()-this.startTime};r("xhr",[this.params,o,this.startTime,this.endTime,"fetch"],this,n.K7.ajax)}function E(e){const t=this.params,i=this.metrics;if(!this.ended){this.ended=!0;for(let t=0;t<Te;t++)e.removeEventListener(xe[t],this.listener,!1);t.aborted||(0,we.iW)(t)||(i.duration=(0,c.t)()-this.startTime,this.loadCaptureCalled||4!==e.readyState?null==t.status&&(t.status=0):A(this,e),i.cbTime=this.cbTime,r("xhr",[t,i,this.startTime,this.endTime,"xhr"],this,n.K7.ajax))}}function A(e,r){e.params.status=r.status;var i=function(e,t){var r=e.responseType;return"json"===r&&null!==t?t:"arraybuffer"===r||"blob"===r||"json"===r?re(e.response):"text"===r||""===r||void 0===r?re(e.responseText):void 0}(r,e.lastSize);if(i&&(e.metrics.rxSize=i),e.sameOrigin&&r.getAllResponseHeaders().indexOf(Se)>=0){var o=r.getResponseHeader(Se);o&&((0,a.p)(h.rs,["Ajax/CrossApplicationTracing/Header/Seen"],void 0,n.K7.metrics,t),e.params.cat=o.split(", ").pop())}e.loadCaptureCalled=!0}t.on("new-xhr",o),t.on("open-xhr-start",s),t.on("open-xhr-end",u),t.on("send-xhr-start",d),t.on("xhr-cb-time",l),t.on("xhr-load-added",f),t.on("xhr-load-removed",p),t.on("xhr-resolved",g),t.on("addEventListener-end",m),t.on("removeEventListener-end",v),t.on("fn-end",w),t.on("fetch-before-start",R),t.on("fetch-start",x),t.on("fn-start",b),t.on("fetch-done",T)}(e,this.ee,this.handler,this.dt),this.importAggregator(e,()=>i.e(478).then(i.bind(i,3845)))}}function Oe(e,t){var r=(0,ve.D)(t),n=e.params||e;n.hostname=r.hostname,n.port=r.port,n.protocol=r.protocol,n.host=r.hostname+":"+r.port,n.pathname=r.pathname,e.parsedOrigin=r,e.sameOrigin=r.sameOrigin}const Ne={},Ie=["pushState","replaceState"];function Pe(e){const t=function(e){return(e||ie.ee).get("history")}(e);return!y.RI||Ne[t.debugId]++||(Ne[t.debugId]=1,(0,oe.YM)(t).inPlace(window.history,Ie,"-")),t}var je=i(3738);function ke(e){p(u.BL,function(t=Date.now()){const r=t-y.WN;r<0&&(0,l.R)(62,t),(0,a.p)(h.XG,[u.BL,{time:r}],void 0,n.K7.metrics,e.ee),e.addToTrace({name:u.BL,start:t,origin:"nr"}),(0,a.p)(u.Pl+u.hG,[r,u.BL],void 0,n.K7.genericEvents,e.ee)},e)}const{He:Ce,bD:Le,d3:He,Kp:Me,TZ:Ke,Lc:De,uP:Ue,Rz:Fe}=je;class We extends E{static featureName=Ke;constructor(e){var t;super(e,Ke),t=e,p(u.U2,function(e){if(!(e&&"object"==typeof e&&e.name&&e.start))return;const r={n:e.name,s:e.start-y.WN,e:(e.end||e.start)-y.WN,o:e.origin||"",t:"api"};r.s<0||r.e<0||r.e<r.s?(0,l.R)(61,{start:r.s,end:r.e}):(0,a.p)("bstApi",[r],void 0,n.K7.sessionTrace,t.ee)},t),ke(e);if(!(0,R.V)(e.init))return void this.deregisterDrain();const r=this.ee;let o;Pe(r),this.eventsEE=(0,ne.u)(r),this.eventsEE.on(Ue,function(e,t){this.bstStart=(0,c.t)()}),this.eventsEE.on(De,function(e,t){(0,a.p)("bst",[e[0],t,this.bstStart,(0,c.t)()],void 0,n.K7.sessionTrace,r)}),r.on(Fe+He,function(e){this.time=(0,c.t)(),this.startPath=location.pathname+location.hash}),r.on(Fe+Me,function(e){(0,a.p)("bstHist",[location.pathname+location.hash,this.startPath,this.time],void 0,n.K7.sessionTrace,r)});try{o=new PerformanceObserver(e=>{const t=e.getEntries();(0,a.p)(Ce,[t],void 0,n.K7.sessionTrace,r)}),o.observe({type:Le,buffered:!0})}catch(e){}this.importAggregator(e,()=>i.e(478).then(i.bind(i,6974)),{resourceObserver:o})}}var Be=i(6344);class Ve extends E{static featureName=Be.TZ;#n;recorder;constructor(e){var t;let r;super(e,Be.TZ),t=e,p(u.CH,function(){(0,a.p)(u.CH,[],void 0,n.K7.sessionReplay,t.ee)},t),function(e){p(u.Tb,function(){(0,a.p)(u.Tb,[],void 0,n.K7.sessionReplay,e.ee)},e)}(e);try{r=JSON.parse(localStorage.getItem("".concat(S.H3,"_").concat(S.uh)))}catch(e){}(0,w.SR)(e.init)&&this.ee.on(u.CH,()=>this.#i()),this.#o(r)&&this.importRecorder().then(e=>{e.startRecording(Be.Qb.PRELOAD,r?.sessionReplayMode)}),this.importAggregator(this.agentRef,()=>i.e(478).then(i.bind(i,6167)),this),this.ee.on("err",e=>{this.blocked||this.agentRef.runtime.isRecording&&(this.errorNoticed=!0,(0,a.p)(Be.Vh,[e],void 0,this.featureName,this.ee))})}#o(e){return e&&(e.sessionReplayMode===S.g.FULL||e.sessionReplayMode===S.g.ERROR)||(0,w.Aw)(this.agentRef.init)}importRecorder(){return this.recorder?Promise.resolve(this.recorder):(this.#n??=Promise.all([i.e(478),i.e(249)]).then(i.bind(i,4866)).then(({Recorder:e})=>(this.recorder=new e(this),this.recorder)).catch(e=>{throw this.ee.emit("internal-error",[e]),this.blocked=!0,e}),this.#n)}#i(){this.blocked||(this.featAggregate?this.featAggregate.mode!==S.g.FULL&&this.featAggregate.initializeRecording(S.g.FULL,!0,Be.Qb.API):this.importRecorder().then(()=>{this.recorder.startRecording(Be.Qb.API,S.g.FULL)}))}}var Ge=i(3962);function ze(e){const t=e.ee.get("tracer");function r(){}p(u.dT,function(e){return(new r).get("object"==typeof e?e:{})},e);const i=r.prototype={createTracer:function(r,i){var o={},s=this,d="function"==typeof i;return(0,a.p)(h.xV,["API/createTracer/called"],void 0,n.K7.metrics,e.ee),e.runSoftNavOverSpa||(0,a.p)(u.hw+"tracer",[(0,c.t)(),r,o],s,n.K7.spa,e.ee),function(){if(t.emit((d?"":"no-")+"fn-start",[(0,c.t)(),s,d],o),d)try{return i.apply(this,arguments)}catch(e){const r="string"==typeof e?new Error(e):e;throw t.emit("fn-err",[arguments,this,r],o),r}finally{t.emit("fn-end",[(0,c.t)()],o)}}}};["actionText","setName","setAttribute","save","ignore","onEnd","getContext","end","get"].forEach(t=>{p.apply(this,[t,function(){return(0,a.p)(u.hw+t,[(0,c.t)(),...arguments],this,e.runSoftNavOverSpa?n.K7.softNav:n.K7.spa,e.ee),this},e,i])}),p(u.PA,function(){e.runSoftNavOverSpa?(0,a.p)(u.hw+"routeName",[performance.now(),...arguments],void 0,n.K7.softNav,e.ee):(0,a.p)(u.Pl+"routeName",[(0,c.t)(),...arguments],this,n.K7.spa,e.ee)},e)}class Ze extends E{static featureName=Ge.TZ;constructor(e){if(super(e,Ge.TZ),ze(e),!y.RI||!(0,O.dV)().o.MO)return;const t=Pe(this.ee);try{this.removeOnAbort=new AbortController}catch(e){}Ge.tC.forEach(e=>{(0,I.sp)(e,e=>{s(e)},!0,this.removeOnAbort?.signal)});const r=()=>(0,a.p)("newURL",[(0,c.t)(),""+window.location],void 0,this.featureName,this.ee);t.on("pushState-end",r),t.on("replaceState-end",r),(0,I.sp)(Ge.OV,e=>{s(e),(0,a.p)("newURL",[e.timeStamp,""+window.location],void 0,this.featureName,this.ee)},!0,this.removeOnAbort?.signal);let n=!1;const o=new((0,O.dV)().o.MO)((e,t)=>{n||(n=!0,requestAnimationFrame(()=>{(0,a.p)("newDom",[(0,c.t)()],void 0,this.featureName,this.ee),n=!1}))}),s=(0,x.s)(e=>{(0,a.p)("newUIEvent",[e],void 0,this.featureName,this.ee),o.observe(document.body,{attributes:!0,childList:!0,subtree:!0,characterData:!0})},100,{leading:!0});this.abortHandler=function(){this.removeOnAbort?.abort(),o.disconnect(),this.abortHandler=void 0},this.importAggregator(e,()=>i.e(478).then(i.bind(i,4393)),{domObserver:o})}}var qe=i(7378);const Xe={},Ye=["appendChild","insertBefore","replaceChild"];function Je(e){const t=function(e){return(e||ie.ee).get("jsonp")}(e);if(!y.RI||Xe[t.debugId])return t;Xe[t.debugId]=!0;var r=(0,oe.YM)(t),n=/[?&](?:callback|cb)=([^&#]+)/,i=/(.*)\.([^.]+)/,o=/^(\w+)(\.|$)(.*)$/;function s(e,t){if(!e)return t;const r=e.match(o),n=r[1];return s(r[3],t[n])}return r.inPlace(Node.prototype,Ye,"dom-"),t.on("dom-start",function(e){!function(e){if(!e||"string"!=typeof e.nodeName||"script"!==e.nodeName.toLowerCase())return;if("function"!=typeof e.addEventListener)return;var o=(a=e.src,c=a.match(n),c?c[1]:null);var a,c;if(!o)return;var u=function(e){var t=e.match(i);if(t&&t.length>=3)return{key:t[2],parent:s(t[1],window)};return{key:e,parent:window}}(o);if("function"!=typeof u.parent[u.key])return;var d={};function l(){t.emit("jsonp-end",[],d),e.removeEventListener("load",l,(0,I.jT)(!1)),e.removeEventListener("error",f,(0,I.jT)(!1))}function f(){t.emit("jsonp-error",[],d),t.emit("jsonp-end",[],d),e.removeEventListener("load",l,(0,I.jT)(!1)),e.removeEventListener("error",f,(0,I.jT)(!1))}r.inPlace(u.parent,[u.key],"cb-",d),e.addEventListener("load",l,(0,I.jT)(!1)),e.addEventListener("error",f,(0,I.jT)(!1)),t.emit("new-jsonp",[e.src],d)}(e[0])}),t}const $e={};function Qe(e){const t=function(e){return(e||ie.ee).get("promise")}(e);if($e[t.debugId])return t;$e[t.debugId]=!0;var r=t.context,n=(0,oe.YM)(t),i=y.gm.Promise;return i&&function(){function e(r){var o=t.context(),s=n(r,"executor-",o,null,!1);const a=Reflect.construct(i,[s],e);return t.context(a).getCtx=function(){return o},a}y.gm.Promise=e,Object.defineProperty(e,"name",{value:"Promise"}),e.toString=function(){return i.toString()},Object.setPrototypeOf(e,i),["all","race"].forEach(function(r){const n=i[r];e[r]=function(e){let i=!1;[...e||[]].forEach(e=>{this.resolve(e).then(s("all"===r),s(!1))});const o=n.apply(this,arguments);return o;function s(e){return function(){t.emit("propagate",[null,!i],o,!1,!1),i=i||!e}}}}),["resolve","reject"].forEach(function(r){const n=i[r];e[r]=function(e){const r=n.apply(this,arguments);return e!==r&&t.emit("propagate",[e,!0],r,!1,!1),r}}),e.prototype=i.prototype;const o=i.prototype.then;i.prototype.then=function(...e){var i=this,s=r(i);s.promise=i,e[0]=n(e[0],"cb-",s,null,!1),e[1]=n(e[1],"cb-",s,null,!1);const a=o.apply(this,e);return s.nextPromise=a,t.emit("propagate",[i,!0],a,!1,!1),a},i.prototype.then[oe.Jt]=o,t.on("executor-start",function(e){e[0]=n(e[0],"resolve-",this,null,!1),e[1]=n(e[1],"resolve-",this,null,!1)}),t.on("executor-err",function(e,t,r){e[1](r)}),t.on("cb-end",function(e,r,n){t.emit("propagate",[n,!0],this.nextPromise,!1,!1)}),t.on("propagate",function(e,r,n){if(!this.getCtx||r){const r=this,n=e instanceof Promise?t.context(e):null;let i;this.getCtx=function(){return i||(i=n&&n!==r?"function"==typeof n.getCtx?n.getCtx():n:r,i)}}})}(),t}const et={},tt="setTimeout",rt="setInterval",nt="clearTimeout",it="-start",ot=[tt,"setImmediate",rt,nt,"clearImmediate"];function st(e){const t=function(e){return(e||ie.ee).get("timer")}(e);if(et[t.debugId]++)return t;et[t.debugId]=1;var r=(0,oe.YM)(t);return r.inPlace(y.gm,ot.slice(0,2),tt+"-"),r.inPlace(y.gm,ot.slice(2,3),rt+"-"),r.inPlace(y.gm,ot.slice(3),nt+"-"),t.on(rt+it,function(e,t,n){e[0]=r(e[0],"fn-",null,n)}),t.on(tt+it,function(e,t,n){this.method=n,this.timerDuration=isNaN(e[1])?0:+e[1],e[0]=r(e[0],"fn-",this,n)}),t}const at={};function ct(e){const t=function(e){return(e||ie.ee).get("mutation")}(e);if(!y.RI||at[t.debugId])return t;at[t.debugId]=!0;var r=(0,oe.YM)(t),n=y.gm.MutationObserver;return n&&(window.MutationObserver=function(e){return this instanceof n?new n(r(e,"fn-")):n.apply(this,arguments)},MutationObserver.prototype=n.prototype),t}const{TZ:ut,d3:dt,Kp:lt,$p:ft,wW:ht,e5:pt,tH:gt,uP:mt,rw:vt,Lc:bt}=qe;class yt extends E{static featureName=ut;constructor(e){if(super(e,ut),ze(e),!y.RI)return;try{this.removeOnAbort=new AbortController}catch(e){}let t,r=0;const n=this.ee.get("tracer"),o=Je(this.ee),s=Qe(this.ee),u=st(this.ee),d=ce(this.ee),l=this.ee.get("events"),f=me(this.ee),h=Pe(this.ee),p=ct(this.ee);function g(e,t){h.emit("newURL",[""+window.location,t])}function m(){r++,t=window.location.hash,this[mt]=(0,c.t)()}function v(){r--,window.location.hash!==t&&g(0,!0);var e=(0,c.t)();this[pt]=~~this[pt]+e-this[mt],this[bt]=e}function b(e,t){e.on(t,function(){this[t]=(0,c.t)()})}this.ee.on(mt,m),s.on(vt,m),o.on(vt,m),this.ee.on(bt,v),s.on(ht,v),o.on(ht,v),this.ee.on("fn-err",(...t)=>{t[2]?.__newrelic?.[e.agentIdentifier]||(0,a.p)("function-err",[...t],void 0,this.featureName,this.ee)}),this.ee.buffer([mt,bt,"xhr-resolved"],this.featureName),l.buffer([mt],this.featureName),u.buffer(["setTimeout"+lt,"clearTimeout"+dt,mt],this.featureName),d.buffer([mt,"new-xhr","send-xhr"+dt],this.featureName),f.buffer([gt+dt,gt+"-done",gt+ft+dt,gt+ft+lt],this.featureName),h.buffer(["newURL"],this.featureName),p.buffer([mt],this.featureName),s.buffer(["propagate",vt,ht,"executor-err","resolve"+dt],this.featureName),n.buffer([mt,"no-"+mt],this.featureName),o.buffer(["new-jsonp","cb-start","jsonp-error","jsonp-end"],this.featureName),b(f,gt+dt),b(f,gt+"-done"),b(o,"new-jsonp"),b(o,"jsonp-end"),b(o,"cb-start"),h.on("pushState-end",g),h.on("replaceState-end",g),window.addEventListener("hashchange",g,(0,I.jT)(!0,this.removeOnAbort?.signal)),window.addEventListener("load",g,(0,I.jT)(!0,this.removeOnAbort?.signal)),window.addEventListener("popstate",function(){g(0,r>1)},(0,I.jT)(!0,this.removeOnAbort?.signal)),this.abortHandler=this.#r,this.importAggregator(e,()=>i.e(478).then(i.bind(i,5592)))}#r(){this.removeOnAbort?.abort(),this.abortHandler=void 0}}var wt=i(3333);class Rt extends E{static featureName=wt.TZ;constructor(e){super(e,wt.TZ);const t=[e.init.page_action.enabled,e.init.performance.capture_marks,e.init.performance.capture_measures,e.init.user_actions.enabled,e.init.performance.resources.enabled];var r;r=e,p(u.hG,(e,t)=>z(e,t,r),r),function(e){p(u.fF,(t,r)=>q(t,r,e),e)}(e),ke(e),X(e),function(e){p(u.V1,(t,r)=>Z(t,r,e),e)}(e);const o=e.init.feature_flags.includes("user_frustrations");let s;if(y.RI&&o&&(me(this.ee),ce(this.ee),s=Pe(this.ee)),y.RI){if(e.init.user_actions.enabled&&(wt.Zp.forEach(e=>(0,I.sp)(e,e=>(0,a.p)("ua",[e],void 0,this.featureName,this.ee),!0)),wt.qN.forEach(e=>{const t=(0,x.s)(e=>{(0,a.p)("ua",[e],void 0,this.featureName,this.ee)},500,{leading:!0});(0,I.sp)(e,t)}),o)){function c(t){const r=(0,ve.D)(t);return e.beacons.includes(r.hostname+":"+r.port)}function d(){s.emit("navChange")}y.gm.addEventListener("error",()=>{(0,a.p)("uaErr",[],void 0,n.K7.genericEvents,this.ee)},(0,I.jT)(!1,this.removeOnAbort?.signal)),this.ee.on("open-xhr-start",(e,t)=>{c(e[1])||t.addEventListener("readystatechange",()=>{2===t.readyState&&(0,a.p)("uaXhr",[],void 0,n.K7.genericEvents,this.ee)})}),this.ee.on("fetch-start",e=>{e.length>=1&&!c(Re(e[0]))&&(0,a.p)("uaXhr",[],void 0,n.K7.genericEvents,this.ee)}),s.on("pushState-end",d),s.on("replaceState-end",d),window.addEventListener("hashchange",d,(0,I.jT)(!0,this.removeOnAbort?.signal)),window.addEventListener("popstate",d,(0,I.jT)(!0,this.removeOnAbort?.signal))}if(e.init.performance.resources.enabled&&y.gm.PerformanceObserver?.supportedEntryTypes.includes("resource")){new PerformanceObserver(e=>{e.getEntries().forEach(e=>{(0,a.p)("browserPerformance.resource",[e],void 0,this.featureName,this.ee)})}).observe({type:"resource",buffered:!0})}}try{this.removeOnAbort=new AbortController}catch(l){}this.abortHandler=()=>{this.removeOnAbort?.abort(),this.abortHandler=void 0},t.some(e=>e)?this.importAggregator(e,()=>i.e(478).then(i.bind(i,8019))):this.deregisterDrain()}}var xt=i(2646);const Tt=new Map;function Et(e,t,r,n){if("object"!=typeof t||!t||"string"!=typeof r||!r||"function"!=typeof t[r])return(0,l.R)(29);const i=function(e){return(e||ie.ee).get("logger")}(e),o=(0,oe.YM)(i),s=new xt.y(ie.P);s.level=n.level,s.customAttributes=n.customAttributes;const a=t[r]?.[oe.Jt]||t[r];return Tt.set(a,s),o.inPlace(t,[r],"wrap-logger-",()=>Tt.get(a)),i}var At=i(1910);class St extends E{static featureName=B.TZ;constructor(e){var t;super(e,B.TZ),t=e,p(u.$9,(e,r)=>G(e,r,t),t),function(e){p(u.Wb,(t,r,{customAttributes:n={},level:i=B.p_.INFO}={})=>{Et(e.ee,t,r,{customAttributes:n,level:i})},e)}(e),X(e);const r=this.ee;["log","error","warn","info","debug","trace"].forEach(e=>{(0,At.i)(y.gm.console[e]),Et(r,y.gm.console,e,{level:"log"===e?"info":e})}),this.ee.on("wrap-logger-end",function([e]){const{level:t,customAttributes:n}=this;(0,V.R)(r,e,n,t)}),this.importAggregator(e,()=>i.e(478).then(i.bind(i,5288)))}}new class extends r{constructor(e){var t;(super(),y.gm)?(this.features={},(0,O.bQ)(this.agentIdentifier,this),this.desiredFeatures=new Set(e.features||[]),this.desiredFeatures.add(_),this.runSoftNavOverSpa=[...this.desiredFeatures].some(e=>e.featureName===n.K7.softNav),(0,s.j)(this,e,e.loaderType||"agent"),t=this,p(u.cD,function(e,r,n=!1){if("string"==typeof e){if(["string","number","boolean"].includes(typeof r)||null===r)return g(t,e,r,u.cD,n);(0,l.R)(40,typeof r)}else(0,l.R)(39,typeof e)},t),function(e){p(u.Dl,function(t){if("string"==typeof t||null===t)return g(e,"enduser.id",t,u.Dl,!0);(0,l.R)(41,typeof t)},e)}(this),function(e){p(u.nb,function(t){if("string"==typeof t||null===t)return g(e,"application.version",t,u.nb,!1);(0,l.R)(42,typeof t)},e)}(this),function(e){p(u.d3,function(){e.ee.emit("manual-start-all")},e)}(this),function(e){p(u.Pv,function(t=!0){if("boolean"==typeof t){if((0,a.p)(u.Pl+u.Pv,[t],void 0,"session",e.ee),e.runtime.consented=t,t){const t=e.features.page_view_event;t.onAggregateImported.then(e=>{const r=t.featAggregate;e&&!r.sentRum&&r.sendRum()})}}else(0,l.R)(65,typeof t)},e)}(this),this.run()):(0,l.R)(21)}get config(){return{info:this.info,init:this.init,loader_config:this.loader_config,runtime:this.runtime}}get api(){return this}run(){try{const e=function(e){const t={};return o.forEach(r=>{t[r]=!!e[r]?.enabled}),t}(this.init),t=[...this.desiredFeatures];t.sort((e,t)=>n.P3[e.featureName]-n.P3[t.featureName]),t.forEach(t=>{if(!e[t.featureName]&&t.featureName!==n.K7.pageViewEvent)return;if(this.runSoftNavOverSpa&&t.featureName===n.K7.spa)return;if(!this.runSoftNavOverSpa&&t.featureName===n.K7.softNav)return;const r=function(e){switch(e){case n.K7.ajax:return[n.K7.jserrors];case n.K7.sessionTrace:return[n.K7.ajax,n.K7.pageViewEvent];case n.K7.sessionReplay:return[n.K7.sessionTrace];case n.K7.pageViewTiming:return[n.K7.pageViewEvent];default:return[]}}(t.featureName).filter(e=>!(e in this.features));r.length>0&&(0,l.R)(36,{targetFeature:t.featureName,missingDependencies:r}),this.features[t.featureName]=new t(this)})}catch(e){(0,l.R)(22,e);for(const e in this.features)this.features[e].abortHandler?.();const t=(0,O.Zm)();delete t.initializedAgents[this.agentIdentifier]?.features,delete this.sharedAggregator;return t.ee.get(this.agentIdentifier).abort(),!1}}}({features:[_e,_,j,We,Ve,k,J,Rt,St,Ze,yt],loaderType:"spa"})})()})();</script>
	<!-- <meta name="format-detection" content="telephone=no"> -->
	<!--<meta name="viewport" content="width=device-width" />-->
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<meta name="description" content="The libraries of the Massachusetts Institute of Technology - Search, Visit, Research, Explore" />
	<title>Research support | MIT Libraries</title>
	<meta property="og:title" content="Research support | MIT Libraries"/>
<meta property="og:type" content="website" />
<meta property="og:image" content="https://libraries.mit.edu/app/themes/mitlib-parent/images/mit-libraries-logo-black-yellow-1200-1200.png"/>
<meta property="og:image:type" content="image/png" />
<meta property="og:image:width" content="1200" />
<meta property="og:image:height" content="1200" />
<meta property="og:image:alt" content="MIT Libraries logo" />
<meta property="og:description" content="Find out where and how to get help for your research or coursework. Expert help Make an appointment for a consult with an expert librarian Research guides: specialized guides for every research interest Not sure where to begin or who to contact? Complete our Ask us email form. Quick help Connect from on &amp; off-campus E-resource troubleshooting Guides for specific classes &amp; programs Writing &amp; publishing help Citing sources &amp; avoiding plagiarism Dissertations/theses: prepare &amp; submit your MIT thesis, or borrow others&#8217;  MIT thesis specifications DSpace@MIT: deposit your work to MIT&#8217;s repository Scholarly Communication Author identifiers: connect your name with [&hellip;]" />
<meta property="og:url" content="https://libraries.mit.edu/research-support/">
	<link rel="profile" href="https://gmpg.org/xfn/11" />
	<link rel="pingback" href="https://libraries.mit.edu/wp/xmlrpc.php" />
	<link rel="icon" href="https://cdn.libraries.mit.edu/files/branding/favicons/favicon.ico" sizes="32x32">
	<link rel="icon" href="https://cdn.libraries.mit.edu/files/branding/favicons/favicon.svg" type="image/svg+xml">
	<link rel="apple-touch-icon" href="https://cdn.libraries.mit.edu/files/branding/favicons/apple-touch-icon.png"><!-- 180×180 -->
	<link rel="manifest" href="https://cdn.libraries.mit.edu/files/branding/favicons/manifest.json">
	<meta name='robots' content='max-image-preview:large' />
	<style>img:is([sizes="auto" i], [sizes^="auto," i]) { contain-intrinsic-size: 3000px 1500px }</style>
	<link rel='dns-prefetch' href='//libraries.mit.edu' />
<link rel='dns-prefetch' href='//maxcdn.bootstrapcdn.com' />
<link rel='dns-prefetch' href='//use.typekit.net' />
<script type="text/javascript">
/* <![CDATA[ */
window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/16.0.1\/72x72\/","ext":".png","svgUrl":"https:\/\/s.w.org\/images\/core\/emoji\/16.0.1\/svg\/","svgExt":".svg","source":{"concatemoji":"https:\/\/libraries.mit.edu\/wp\/wp-includes\/js\/wp-emoji-release.min.js?ver=6.8.2"}};
/*! This file is auto-generated */
!function(s,n){var o,i,e;function c(e){try{var t={supportTests:e,timestamp:(new Date).valueOf()};sessionStorage.setItem(o,JSON.stringify(t))}catch(e){}}function p(e,t,n){e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(t,0,0);var t=new Uint32Array(e.getImageData(0,0,e.canvas.width,e.canvas.height).data),a=(e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(n,0,0),new Uint32Array(e.getImageData(0,0,e.canvas.width,e.canvas.height).data));return t.every(function(e,t){return e===a[t]})}function u(e,t){e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(t,0,0);for(var n=e.getImageData(16,16,1,1),a=0;a<n.data.length;a++)if(0!==n.data[a])return!1;return!0}function f(e,t,n,a){switch(t){case"flag":return n(e,"\ud83c\udff3\ufe0f\u200d\u26a7\ufe0f","\ud83c\udff3\ufe0f\u200b\u26a7\ufe0f")?!1:!n(e,"\ud83c\udde8\ud83c\uddf6","\ud83c\udde8\u200b\ud83c\uddf6")&&!n(e,"\ud83c\udff4\udb40\udc67\udb40\udc62\udb40\udc65\udb40\udc6e\udb40\udc67\udb40\udc7f","\ud83c\udff4\u200b\udb40\udc67\u200b\udb40\udc62\u200b\udb40\udc65\u200b\udb40\udc6e\u200b\udb40\udc67\u200b\udb40\udc7f");case"emoji":return!a(e,"\ud83e\udedf")}return!1}function g(e,t,n,a){var r="undefined"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope?new OffscreenCanvas(300,150):s.createElement("canvas"),o=r.getContext("2d",{willReadFrequently:!0}),i=(o.textBaseline="top",o.font="600 32px Arial",{});return e.forEach(function(e){i[e]=t(o,e,n,a)}),i}function t(e){var t=s.createElement("script");t.src=e,t.defer=!0,s.head.appendChild(t)}"undefined"!=typeof Promise&&(o="wpEmojiSettingsSupports",i=["flag","emoji"],n.supports={everything:!0,everythingExceptFlag:!0},e=new Promise(function(e){s.addEventListener("DOMContentLoaded",e,{once:!0})}),new Promise(function(t){var n=function(){try{var e=JSON.parse(sessionStorage.getItem(o));if("object"==typeof e&&"number"==typeof e.timestamp&&(new Date).valueOf()<e.timestamp+604800&&"object"==typeof e.supportTests)return e.supportTests}catch(e){}return null}();if(!n){if("undefined"!=typeof Worker&&"undefined"!=typeof OffscreenCanvas&&"undefined"!=typeof URL&&URL.createObjectURL&&"undefined"!=typeof Blob)try{var e="postMessage("+g.toString()+"("+[JSON.stringify(i),f.toString(),p.toString(),u.toString()].join(",")+"));",a=new Blob([e],{type:"text/javascript"}),r=new Worker(URL.createObjectURL(a),{name:"wpTestEmojiSupports"});return void(r.onmessage=function(e){c(n=e.data),r.terminate(),t(n)})}catch(e){}c(n=g(i,f,p,u))}t(n)}).then(function(e){for(var t in e)n.supports[t]=e[t],n.supports.everything=n.supports.everything&&n.supports[t],"flag"!==t&&(n.supports.everythingExceptFlag=n.supports.everythingExceptFlag&&n.supports[t]);n.supports.everythingExceptFlag=n.supports.everythingExceptFlag&&!n.supports.flag,n.DOMReady=!1,n.readyCallback=function(){n.DOMReady=!0}}).then(function(){return e}).then(function(){var e;n.supports.everything||(n.readyCallback(),(e=n.source||{}).concatemoji?t(e.concatemoji):e.wpemoji&&e.twemoji&&(t(e.twemoji),t(e.wpemoji)))}))}((window,document),window._wpemojiSettings);
/* ]]> */
</script>
<style id='wp-emoji-styles-inline-css' type='text/css'>

	img.wp-smiley, img.emoji {
		display: inline !important;
		border: none !important;
		box-shadow: none !important;
		height: 1em !important;
		width: 1em !important;
		margin: 0 0.07em !important;
		vertical-align: -0.1em !important;
		background: none !important;
		padding: 0 !important;
	}
</style>
<link rel='stylesheet' id='wp-block-library-css' href='https://libraries.mit.edu/wp/wp-includes/css/dist/block-library/style.min.css?ver=6.8.2' type='text/css' media='all' />
<style id='classic-theme-styles-inline-css' type='text/css'>
/*! This file is auto-generated */
.wp-block-button__link{color:#fff;background-color:#32373c;border-radius:9999px;box-shadow:none;text-decoration:none;padding:calc(.667em + 2px) calc(1.333em + 2px);font-size:1.125em}.wp-block-file__button{background:#32373c;color:#fff;text-decoration:none}
</style>
<style id='global-styles-inline-css' type='text/css'>
:root{--wp--preset--aspect-ratio--square: 1;--wp--preset--aspect-ratio--4-3: 4/3;--wp--preset--aspect-ratio--3-4: 3/4;--wp--preset--aspect-ratio--3-2: 3/2;--wp--preset--aspect-ratio--2-3: 2/3;--wp--preset--aspect-ratio--16-9: 16/9;--wp--preset--aspect-ratio--9-16: 9/16;--wp--preset--color--black: #000000;--wp--preset--color--cyan-bluish-gray: #abb8c3;--wp--preset--color--white: #ffffff;--wp--preset--color--pale-pink: #f78da7;--wp--preset--color--vivid-red: #cf2e2e;--wp--preset--color--luminous-vivid-orange: #ff6900;--wp--preset--color--luminous-vivid-amber: #fcb900;--wp--preset--color--light-green-cyan: #7bdcb5;--wp--preset--color--vivid-green-cyan: #00d084;--wp--preset--color--pale-cyan-blue: #8ed1fc;--wp--preset--color--vivid-cyan-blue: #0693e3;--wp--preset--color--vivid-purple: #9b51e0;--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple: linear-gradient(135deg,rgba(6,147,227,1) 0%,rgb(155,81,224) 100%);--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan: linear-gradient(135deg,rgb(122,220,180) 0%,rgb(0,208,130) 100%);--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange: linear-gradient(135deg,rgba(252,185,0,1) 0%,rgba(255,105,0,1) 100%);--wp--preset--gradient--luminous-vivid-orange-to-vivid-red: linear-gradient(135deg,rgba(255,105,0,1) 0%,rgb(207,46,46) 100%);--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray: linear-gradient(135deg,rgb(238,238,238) 0%,rgb(169,184,195) 100%);--wp--preset--gradient--cool-to-warm-spectrum: linear-gradient(135deg,rgb(74,234,220) 0%,rgb(151,120,209) 20%,rgb(207,42,186) 40%,rgb(238,44,130) 60%,rgb(251,105,98) 80%,rgb(254,248,76) 100%);--wp--preset--gradient--blush-light-purple: linear-gradient(135deg,rgb(255,206,236) 0%,rgb(152,150,240) 100%);--wp--preset--gradient--blush-bordeaux: linear-gradient(135deg,rgb(254,205,165) 0%,rgb(254,45,45) 50%,rgb(107,0,62) 100%);--wp--preset--gradient--luminous-dusk: linear-gradient(135deg,rgb(255,203,112) 0%,rgb(199,81,192) 50%,rgb(65,88,208) 100%);--wp--preset--gradient--pale-ocean: linear-gradient(135deg,rgb(255,245,203) 0%,rgb(182,227,212) 50%,rgb(51,167,181) 100%);--wp--preset--gradient--electric-grass: linear-gradient(135deg,rgb(202,248,128) 0%,rgb(113,206,126) 100%);--wp--preset--gradient--midnight: linear-gradient(135deg,rgb(2,3,129) 0%,rgb(40,116,252) 100%);--wp--preset--font-size--small: 13px;--wp--preset--font-size--medium: 20px;--wp--preset--font-size--large: 36px;--wp--preset--font-size--x-large: 42px;--wp--preset--spacing--20: 0.44rem;--wp--preset--spacing--30: 0.67rem;--wp--preset--spacing--40: 1rem;--wp--preset--spacing--50: 1.5rem;--wp--preset--spacing--60: 2.25rem;--wp--preset--spacing--70: 3.38rem;--wp--preset--spacing--80: 5.06rem;--wp--preset--shadow--natural: 6px 6px 9px rgba(0, 0, 0, 0.2);--wp--preset--shadow--deep: 12px 12px 50px rgba(0, 0, 0, 0.4);--wp--preset--shadow--sharp: 6px 6px 0px rgba(0, 0, 0, 0.2);--wp--preset--shadow--outlined: 6px 6px 0px -3px rgba(255, 255, 255, 1), 6px 6px rgba(0, 0, 0, 1);--wp--preset--shadow--crisp: 6px 6px 0px rgba(0, 0, 0, 1);}:where(.is-layout-flex){gap: 0.5em;}:where(.is-layout-grid){gap: 0.5em;}body .is-layout-flex{display: flex;}.is-layout-flex{flex-wrap: wrap;align-items: center;}.is-layout-flex > :is(*, div){margin: 0;}body .is-layout-grid{display: grid;}.is-layout-grid > :is(*, div){margin: 0;}:where(.wp-block-columns.is-layout-flex){gap: 2em;}:where(.wp-block-columns.is-layout-grid){gap: 2em;}:where(.wp-block-post-template.is-layout-flex){gap: 1.25em;}:where(.wp-block-post-template.is-layout-grid){gap: 1.25em;}.has-black-color{color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-color{color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-color{color: var(--wp--preset--color--white) !important;}.has-pale-pink-color{color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-color{color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-color{color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-color{color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-color{color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-color{color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-color{color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-color{color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-color{color: var(--wp--preset--color--vivid-purple) !important;}.has-black-background-color{background-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-background-color{background-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-background-color{background-color: var(--wp--preset--color--white) !important;}.has-pale-pink-background-color{background-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-background-color{background-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-background-color{background-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-background-color{background-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-background-color{background-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-background-color{background-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-background-color{background-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-background-color{background-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-background-color{background-color: var(--wp--preset--color--vivid-purple) !important;}.has-black-border-color{border-color: var(--wp--preset--color--black) !important;}.has-cyan-bluish-gray-border-color{border-color: var(--wp--preset--color--cyan-bluish-gray) !important;}.has-white-border-color{border-color: var(--wp--preset--color--white) !important;}.has-pale-pink-border-color{border-color: var(--wp--preset--color--pale-pink) !important;}.has-vivid-red-border-color{border-color: var(--wp--preset--color--vivid-red) !important;}.has-luminous-vivid-orange-border-color{border-color: var(--wp--preset--color--luminous-vivid-orange) !important;}.has-luminous-vivid-amber-border-color{border-color: var(--wp--preset--color--luminous-vivid-amber) !important;}.has-light-green-cyan-border-color{border-color: var(--wp--preset--color--light-green-cyan) !important;}.has-vivid-green-cyan-border-color{border-color: var(--wp--preset--color--vivid-green-cyan) !important;}.has-pale-cyan-blue-border-color{border-color: var(--wp--preset--color--pale-cyan-blue) !important;}.has-vivid-cyan-blue-border-color{border-color: var(--wp--preset--color--vivid-cyan-blue) !important;}.has-vivid-purple-border-color{border-color: var(--wp--preset--color--vivid-purple) !important;}.has-vivid-cyan-blue-to-vivid-purple-gradient-background{background: var(--wp--preset--gradient--vivid-cyan-blue-to-vivid-purple) !important;}.has-light-green-cyan-to-vivid-green-cyan-gradient-background{background: var(--wp--preset--gradient--light-green-cyan-to-vivid-green-cyan) !important;}.has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-amber-to-luminous-vivid-orange) !important;}.has-luminous-vivid-orange-to-vivid-red-gradient-background{background: var(--wp--preset--gradient--luminous-vivid-orange-to-vivid-red) !important;}.has-very-light-gray-to-cyan-bluish-gray-gradient-background{background: var(--wp--preset--gradient--very-light-gray-to-cyan-bluish-gray) !important;}.has-cool-to-warm-spectrum-gradient-background{background: var(--wp--preset--gradient--cool-to-warm-spectrum) !important;}.has-blush-light-purple-gradient-background{background: var(--wp--preset--gradient--blush-light-purple) !important;}.has-blush-bordeaux-gradient-background{background: var(--wp--preset--gradient--blush-bordeaux) !important;}.has-luminous-dusk-gradient-background{background: var(--wp--preset--gradient--luminous-dusk) !important;}.has-pale-ocean-gradient-background{background: var(--wp--preset--gradient--pale-ocean) !important;}.has-electric-grass-gradient-background{background: var(--wp--preset--gradient--electric-grass) !important;}.has-midnight-gradient-background{background: var(--wp--preset--gradient--midnight) !important;}.has-small-font-size{font-size: var(--wp--preset--font-size--small) !important;}.has-medium-font-size{font-size: var(--wp--preset--font-size--medium) !important;}.has-large-font-size{font-size: var(--wp--preset--font-size--large) !important;}.has-x-large-font-size{font-size: var(--wp--preset--font-size--x-large) !important;}
:where(.wp-block-post-template.is-layout-flex){gap: 1.25em;}:where(.wp-block-post-template.is-layout-grid){gap: 1.25em;}
:where(.wp-block-columns.is-layout-flex){gap: 2em;}:where(.wp-block-columns.is-layout-grid){gap: 2em;}
:root :where(.wp-block-pullquote){font-size: 1.5em;line-height: 1.6;}
</style>
<link rel='stylesheet' id='contact-form-7-css' href='https://libraries.mit.edu/app/plugins/contact-form-7/includes/css/styles.css?ver=6.1' type='text/css' media='all' />
<style id='contact-form-7-inline-css' type='text/css'>
.wpcf7 .wpcf7-recaptcha iframe {margin-bottom: 0;}.wpcf7 .wpcf7-recaptcha[data-align="center"] > div {margin: 0 auto;}.wpcf7 .wpcf7-recaptcha[data-align="right"] > div {margin: 0 0 0 auto;}
</style>
<link rel='stylesheet' id='sn-fontAwesome-css-css' href='//maxcdn.bootstrapcdn.com/font-awesome/4.2.0/css/font-awesome.min.css?ver=1.1' type='text/css' media='all' />
<link rel='stylesheet' id='sn-animate-css-css' href='https://libraries.mit.edu/app/plugins/dynamic-menu-manager/duogeek/inc/animate.css?ver=1.1' type='text/css' media='all' />
<link rel='stylesheet' id='dg-grid-css-css' href='https://libraries.mit.edu/app/plugins/dynamic-menu-manager/duogeek/inc/dg-grid.css?ver=1.1' type='text/css' media='all' />
<link rel='stylesheet' id='parent-styles-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/style.css?ver=0.8' type='text/css' media='all' />
<link rel='stylesheet' id='parent-global-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/css/build/global.css?ver=0.8' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='parent-ie-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/css/ie.css?ver=20121010' type='text/css' media='all' />
<![endif]-->
<link rel='stylesheet' id='adobe-fonts-css' href='//use.typekit.net/ixd2vgq.css?ver=0.8' type='text/css' media='all' />
<link rel='stylesheet' id='parent-forms-css' href='https://libraries.mit.edu/app/themes/mitlib-parent/css/build/forms.css?ver=0.8' type='text/css' media='all' />
<link rel='stylesheet' id='cf7cf-style-css' href='https://libraries.mit.edu/app/plugins/cf7-conditional-fields/style.css?ver=2.2.3' type='text/css' media='all' />
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/libs/modernizr.min.js?ver=2.8.3" id="modernizr-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/jquery.min.js?ver=1.11.1-local" id="jquery-js"></script>
<link rel="https://api.w.org/" href="https://libraries.mit.edu/wp-json/" /><link rel="alternate" title="JSON" type="application/json" href="https://libraries.mit.edu/wp-json/wp/v2/pages/160" /><link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://libraries.mit.edu/wp/xmlrpc.php?rsd" />
<meta name="generator" content="WordPress 6.8.2" />
<link rel="canonical" href="https://libraries.mit.edu/research-support/" />
<link rel='shortlink' href='https://libraries.mit.edu/?p=160' />
<link rel="alternate" title="oEmbed (JSON)" type="application/json+oembed" href="https://libraries.mit.edu/wp-json/oembed/1.0/embed?url=https%3A%2F%2Flibraries.mit.edu%2Fresearch-support%2F" />
<link rel="alternate" title="oEmbed (XML)" type="text/xml+oembed" href="https://libraries.mit.edu/wp-json/oembed/1.0/embed?url=https%3A%2F%2Flibraries.mit.edu%2Fresearch-support%2F&#038;format=xml" />

	<!-- Matomo Tag Manager -->
<script>
  var _mtm = window._mtm = window._mtm || [];
  _mtm.push({'mtm.startTime': (new Date().getTime()), 'event': 'mtm.Start'});
  (function() {
    var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
    g.async=true; g.src='https://matomo.libraries.mit.edu/js/container_oFWMSb3g.js'; s.parentNode.insertBefore(g,s);
  })();
</script>
<!-- End Matomo Tag Manager -->		<style type="text/css" id="wp-custom-css">
			/* special temporary styling for branded about page */
body.page-id-140 {
  background: #fff;
  color: #000;
}

body.page-id-140 .content {
  margin: 0;
  font-family: 'NHaasGroteskTxt', 'Helvetica Neue', 'Helvetica', 'Arial', sans-serif !important;
  line-height: 1.2;
}

body.page-id-140 .breadcrumbs--better {
  background-color: #555; 
  color: #eee;
}
body.page-id-140 .breadcrumbs--better a {
    color: #eee;
}

body.page-id-140 .main-content { 
  background: #fff url('/images/network-graphic/logo10.png') no-repeat right top;
  color: #000;
  padding-left: 0; 
  padding-right: 0;
  margin-bottom: 0;
}

body.page-id-140 .layout-band {
  padding: 2% 15px 1% 15px;
}

body.page-id-140 .ttl {
  font-family: 'NHaasGroteskDisp', 'Helvetica Neue', 'Helvetica', 'Arial', sans-serif !important; 
	font-weight: 600;
}
body.page-id-140 .main-content p {
  line-height: 1.1;
}

body.page-id-140 .main-content .list-unbulleted li {
  list-style: none;
  margin-left: 0;
}

body.page-id-140 .main-content .cta-link {
  transition: background-color ease-in-out .3s;
  display: inline-block;
  padding: 10px;  
  color: #000;
  font-size: 20px;
  font-weight: 600;
  text-decoration: underline;
}

body.page-id-140 .main-content .cta-link:hover {
  background-color: #d300cc;
  color: #fff;
}

body.page-id-140 .wrap-intro {
  padding: 4% 15px;
  color: #000;
}

body.page-id-140 .wrap-intro .ttl {
  font-size: 36px;
  font-weight: 600;
  line-height: .92;
  margin-bottom: .3em;
}

body.page-id-140 .wrap-intro .pull {
  font-size: 20px;
  line-height: 1.2;
}

body.page-id-140 .wrap-we-are {
  margin-top: 1rem;
}

body.page-id-140 .card { 
  transition: background-color ease-in-out .3s;
  background: #fff;
  color: #000;
  margin: 15px;
  padding-top: 5px;
  line-height: 0;
}

body.page-id-140 .card:hover {
  background-color: #0000FF;
  background-image: none;
  color: #fff;
}

body.page-id-140 .card:hover a {
  color: #fff !important;
}

body.page-id-140 .card .c-image {
  width: 100%;
  background-color: #000;
}

body.page-id-140 .card .c-content {
  padding: 10px 3%;
  font-size: 14px;
} 

body.page-id-140 .card .c-ttl1 {
  font-size: 20px;
  font-weight: 600;
  line-height: .92;
  margin: 0;
}

body.page-id-140 .card .c-ttl2 {
  margin-top: .2em;
  font-size: 14px;
  line-height: 1.2;
  font-weight: 400;
}

body.page-id-140 .wrap-fol {
  padding: 2% 15px 3% 15px;
  color: #000;
  font-size: 14px;
}

body.page-id-140 .wrap-fol .ttl {
  font-size: 36px;
  font-weight: 600;
  line-height: .92;
}

body.page-id-140 .wrap-fol .vision-item strong {
  display: block;
  margin: 1em 0 .2em 0;
  font-size: 20px;
  line-height: .92;
}

body.page-id-140 .wrap-fol .cta-link {
  margin-top: .5em;
}

body.page-id-140 .list-social {
  display: flex;
  justify-content: space-between;
}

body.page-id-140 .list-social a {
  flex: 1 1 auto;
  padding: 20px;  
  background-color: #fff;
  font-size: 28px;
  color: #234;  
  text-align: center;
}

body.page-id-140 .list-social a:hover {
  background-color: #00C800;
  color: #000;
}

body.page-id-140 .list-pipe {
  text-align: center;
}
body.page-id-140 .list-pipe li {
  list-style-type: none;
  display: inline-block;  
  margin: 0;  
  padding-right: 10px;
}
body.page-id-140 .list-pipe li:after  {
  content: "|";
  padding-left: 10px;
}

body.page-id-140 .list-pipe li:last-child:after  {
content: "";
}

@media only screen and (min-width: 768px) {

}

@media only screen and (min-width: 480px) {

  body.page-id-140 .wrap-case-studies, 
  body.page-id-140 .wrap-linkblocks {
    display: flex;
  } 
    
  body.page-id-140 .card {
    flex: 1 1 auto; 
    width: 30%; 
    align-items: stretch;
    margin: 15px 0 15px 15px;    
  }

  body.page-id-140 .card:last-child {
    margin-right: 15px;
  }
}


/* CREOS page styles */
body.page-id-27945 .title-page, 
body.page-id-27945 h2.subtitle {
	  font-family: 'NHaasGroteskTxt', 'Helvetica Neue', 'Khula', 'Helvetica', sans-serif !important;

}
body.page-id-27945 .title-page h1 {
	font-size: 110px;
	font-weight: 600;
	line-height: .8;
	margin-top: .2em;
}

body.page-id-27945 h2.subtitle {
	font-size: 24px;
	font-weight: 600;
	margin-bottom: .8em;
}
/* widget utility classes */
.sidebar .no-top-border {
	border-top: none;
}

.sidebar .hide-title .widget-title { 
	display: none;
}

.sidebar .callout.widget {
	background: #e4e4e4 ;
	border-top: 2px solid #c63 ;
	padding-left: 20px ;
	padding-right: 20px ;
		padding-top: 15px ;
		padding-bottom: 15px ;
		margin-bottom: 20px;
}		</style>
			<script>
		todayDate="";
	</script>
</head>

<body class="wp-singular page-template page-template-templates page-template-page page-template-templatespage-php page page-id-160 page-parent wp-theme-mitlib-parent page-research-support single-author">
	<div id="skip"><a href="#content">Skip to Main Content</a></div>
	<div class="wrap-page">
		<header class="header-main flex-container flex-end">
							<nav>
	<button class="menu--toggle"><!-- Mobile Hamburger icon -->
		<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="18.909px" height="13.091px" viewBox="2.182 6.545 18.909 13.091" enable-background="new 2.182 6.545 18.909 13.091" xml:space="preserve"><path d="M2.909,6.545h17.454c0.197,0,0.367,0.072,0.512,0.216c0.145,0.144,0.216,0.314,0.216,0.511s-0.071,0.367-0.216,0.511
		c-0.145,0.144-0.314,0.216-0.512,0.216H2.909c-0.197,0-0.367-0.072-0.511-0.216C2.254,7.639,2.182,7.469,2.182,7.272
		s0.072-0.367,0.216-0.511C2.542,6.617,2.712,6.545,2.909,6.545z M20.363,13.818H2.909c-0.197,0-0.367-0.072-0.511-0.216
		s-0.216-0.314-0.216-0.511c0-0.196,0.072-0.367,0.216-0.511s0.314-0.216,0.511-0.216h17.454c0.197,0,0.367,0.072,0.512,0.216
		s0.216,0.314,0.216,0.511c0,0.197-0.071,0.367-0.216,0.511S20.561,13.818,20.363,13.818z M20.363,19.636H2.909
		c-0.197,0-0.367-0.071-0.511-0.216s-0.216-0.314-0.216-0.511s0.072-0.367,0.216-0.511c0.144-0.145,0.314-0.217,0.511-0.217h17.454
		c0.197,0,0.367,0.072,0.512,0.217c0.145,0.144,0.216,0.314,0.216,0.511s-0.071,0.366-0.216,0.511S20.561,19.636,20.363,19.636z"/>
		</svg>
	</button><!-- end hamburger icon -->
</nav>

<!-- Menu shown on mobile screens, when the hamburger icon is tapped. -->
<nav id="nav-mobile" class="nav-main hidden-non-mobile" aria-hidden="true">
	<ul>
		<li><a href="/search" class="no-underline mobile-nav-link hide-mobile-nav-link">Search</a></li>
		<li><a href="/hours" class="no-underline mobile-nav-link hide-mobile-nav-link">Hours & locations</a></li>
		<li><a href="/borrow" class="no-underline mobile-nav-link hide-mobile-nav-link">Borrow & request</a></li>
		<li><a href="/research-support" class="no-underline mobile-nav-link hide-mobile-nav-link">Research support</a></li>
		<li><a href="/about" class="no-underline mobile-nav-link hide-mobile-nav-link">About</a></li>
	</ul>
</nav>
						
<h1 class="name-site group nav-logo">
	<a href="/" class="logo-mit-lib">
		<svg xmlns="http://www.w3.org/2000/svg" viewBox="5 -3 210 95"><title>MIT Libraries logo</title><path d="M8.12,9H20l4.35,15.65c.17.57.36,1.31.58,2.22s.44,1.81.67,2.68.53,2.12.8,3.25h.1c.23-1.13.48-2.22.75-3.25.2-.87.42-1.76.65-2.67s.43-1.65.6-2.22L32.92,9h12V44.75h-8.1V22.66c0-.93,0-1.95.1-3.05h-.1c-.27,1-.5,2-.7,2.85s-.38,1.61-.53,2.22l-.42,1.58-5.1,18.49h-7.3L17.67,26.3c-.1-.33-.25-.87-.45-1.6s-.38-1.48-.55-2.25-.42-1.82-.67-2.85h-.1v3c0,.8,0,1.6.08,2.4a8.53,8.53,0,0,1,0,1.75v18H8V9Zm40,0H57V44.75H48.12Zm22.1,7.45H59.82V9H89.57v7.45H79.07v28.3H70.22ZM8.12,50H17V78.25H33.64v7.5H8.12Zm28.7,0H45v6.6H36.82Zm0,10.15H45v25.6H36.82Zm27,26.4a9.82,9.82,0,0,1-4.55-1,7.9,7.9,0,0,1-3.2-3H56v3.2H48.2V50h8.15V63h.15a9.45,9.45,0,0,1,2.9-2.55,8.62,8.62,0,0,1,4.37-1,9.86,9.86,0,0,1,4.53,1,10,10,0,0,1,3.45,2.85A13.51,13.51,0,0,1,74,67.6a17.89,17.89,0,0,1,.7,5.4,19.45,19.45,0,0,1-.78,5.72A12.53,12.53,0,0,1,71.72,83a9.48,9.48,0,0,1-3.45,2.67A10.63,10.63,0,0,1,63.82,86.55Zm-2.3-6.45a4.14,4.14,0,0,0,3.67-1.92,9.45,9.45,0,0,0,1.28-5.27,9.74,9.74,0,0,0-1.28-5.3,4.2,4.2,0,0,0-3.77-2,4.43,4.43,0,0,0-4,2.1A9.7,9.7,0,0,0,56.12,73a8.49,8.49,0,0,0,1.45,5.17,4.69,4.69,0,0,0,4,2Zm15.11-20h7.8v4h.15a9.56,9.56,0,0,1,3-3.35,7.29,7.29,0,0,1,4-1,4.57,4.57,0,0,1,1.6.2v7H93a7.34,7.34,0,0,0-6,1.27q-2.16,1.78-2.16,6v11.5H76.63Zm26,26.3a12.1,12.1,0,0,1-3.53-.5,7.55,7.55,0,0,1-2.77-1.5A7,7,0,0,1,94.48,82a8.09,8.09,0,0,1-.66-3.4,7.29,7.29,0,0,1,.78-3.52,6.74,6.74,0,0,1,2.12-2.35,10.79,10.79,0,0,1,3.1-1.43,27,27,0,0,1,3.77-.75,24.35,24.35,0,0,0,5-1A1.93,1.93,0,0,0,110,67.7a2.56,2.56,0,0,0-.83-2,3.91,3.91,0,0,0-2.67-.7,4.41,4.41,0,0,0-3,.85,3.66,3.66,0,0,0-1.2,2.45H94.8a8.52,8.52,0,0,1,.8-3.4,8.14,8.14,0,0,1,2.17-2.8,10.65,10.65,0,0,1,3.58-1.9,16.29,16.29,0,0,1,5-.7,19.72,19.72,0,0,1,4.9.52,9.7,9.7,0,0,1,3.4,1.58,7.31,7.31,0,0,1,2.45,3,10.5,10.5,0,0,1,.8,4.25v12.9a13.08,13.08,0,0,0,.17,2.42,1.8,1.8,0,0,0,.73,1.23v.35h-7.9a3.53,3.53,0,0,1-.5-1.12,14.56,14.56,0,0,1-.35-1.72h0a8.4,8.4,0,0,1-2.73,2.54,10,10,0,0,1-4.68,1Zm2.6-5.2a5.46,5.46,0,0,0,3.68-1.2,4.27,4.27,0,0,0,1.42-3.35v-3a11.5,11.5,0,0,1-1.87.73c-.72.22-1.5.43-2.34.62a10.36,10.36,0,0,0-3.4,1.27,2.48,2.48,0,0,0-1,2.17,2.43,2.43,0,0,0,1,2.2,4.53,4.53,0,0,0,2.5.55h0Zm15.87-21h7.77v4H129a9.56,9.56,0,0,1,3-3.35,7.29,7.29,0,0,1,4-1,4.57,4.57,0,0,1,1.6.2v7h-.2a7.34,7.34,0,0,0-6,1.27c-1.49,1.22-2.24,3.22-2.23,6V85.75H121V60.15ZM140,50.1h8.13v6.6H140Zm0,10.15h8.13v25.5H140ZM164,86.6a15,15,0,0,1-5.7-1,12.07,12.07,0,0,1-4.3-2.85,12.84,12.84,0,0,1-2.7-4.33,15.07,15.07,0,0,1-1-5.4,14.74,14.74,0,0,1,1-5.33,12.72,12.72,0,0,1,2.7-4.3,12.58,12.58,0,0,1,4.13-2.94,14.62,14.62,0,0,1,10.28-.17,12.29,12.29,0,0,1,3.83,2.35A12.7,12.7,0,0,1,175.65,68a20.83,20.83,0,0,1,1.08,7.13H158.32a7.53,7.53,0,0,0,1.8,4.1,5.14,5.14,0,0,0,4,1.5,4.84,4.84,0,0,0,2.65-.68,4.28,4.28,0,0,0,1.6-1.87h8a9.47,9.47,0,0,1-1.5,3.33,10.85,10.85,0,0,1-2.8,2.73A12.06,12.06,0,0,1,168.49,86a15.31,15.31,0,0,1-4.52.5Zm4.5-16.3a6,6,0,0,0-1.5-3.65,4.37,4.37,0,0,0-3.3-1.35,4.64,4.64,0,0,0-3.6,1.35,7,7,0,0,0-1.65,3.65Zm21.9,16.35q-5.66,0-9-2.42a8.34,8.34,0,0,1-3.52-6.78h7.7A4.15,4.15,0,0,0,187,80.3a5.06,5.06,0,0,0,3.25,1,5.61,5.61,0,0,0,2.92-.65,2.08,2.08,0,0,0,1.08-1.9,1.82,1.82,0,0,0-.55-1.37,4.08,4.08,0,0,0-1.45-.85,11.46,11.46,0,0,0-2.08-.5c-.78-.11-1.59-.25-2.42-.42q-1.65-.3-3.3-.72a10,10,0,0,1-3-1.28,6.41,6.41,0,0,1-2.12-2.27,7.47,7.47,0,0,1-.8-3.68,7.21,7.21,0,0,1,.87-3.55,7.61,7.61,0,0,1,2.35-2.66,11.15,11.15,0,0,1,3.53-1.55,17.18,17.18,0,0,1,4.28-.52c3.63,0,6.42.73,8.35,2.2a8,8,0,0,1,3.2,6h-7.5a3,3,0,0,0-1.33-2.37,5.48,5.48,0,0,0-2.78-.62,5,5,0,0,0-2.52.58A1.9,1.9,0,0,0,186,67a1.34,1.34,0,0,0,.5,1.1,4.27,4.27,0,0,0,1.35.67,13.55,13.55,0,0,0,2,.48l2.33.4c1.13.2,2.27.44,3.42.73a10.5,10.5,0,0,1,3.17,1.32,7,7,0,0,1,2.3,2.42,7.84,7.84,0,0,1,.9,4,7.35,7.35,0,0,1-3.32,6.38,11.84,11.84,0,0,1-3.7,1.6,18.75,18.75,0,0,1-4.66.5Z" style="fill:#fff;" /></svg>
		<span class="sr">MIT Libraries</span>
	</a><!-- End MIT Libraries Logo -->
</h1><!-- End H1.name-site -->
							
<!-- Menu shown on non-mobile screens -->
<nav class="nav-main hidden-mobile" aria-label="Primary">
	<ul class="nav-main-list flex-container">
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-searchmenu-title" href="#" class="no-underline search-link main-nav-link menu-control">Search</a>
			</h2>
			<div aria-labelledby="main-nav-searchmenu-title" id="main-nav-searchmenu" class="links-sub flex-container group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Start here</h3>
					<ul class="list-unbulleted">
						<li><a href="/search">Search tools home</a></li>
						<li><a href="/search-collections">Search Our Collections <span class="about">Books, articles, and more</span></a></li>
						<li><a href="/worldcat">WorldCat<span class="about">Books &amp; more worldwide</span></a></li>
						<li><a href="https://libguides.mit.edu/az.php">Databases A-Z<span class="about">JSTOR, PubMed, Web of Science, etc.</span></a></li>
						<li><a href="/search-reserves">Course reserves</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">Also try</h3>
					<ul class="list-unbulleted">
						<li><a href="/google-scholar-tips">Google Scholar for MIT <span class="about">Change settings to get better access</span></a></li>
						<li><a href="/dspace">DSpace@MIT <span class="about">MIT research</span></a></li>
						<li><a href="/dome">Dome <span class="about">MIT-digitized images, maps, etc.</span></a></li>
						<li><a href="/site-search">Site search</a></li>
					</ul>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-hoursmenu-title" href="#" class="no-underline main-nav-link menu-control">Hours &amp; locations</a>
			</h2>
			<div aria-labelledby="main-nav-hoursmenu-title" id="main-nav-hoursmenu" class="links-sub flex-container group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Locations</h3>
					<ul class="list-unbulleted">
						<li><a href="/hours">Hours and locations home</a></li>
						<li><a href="/barker">Barker Library</a></li>
						<li><a href="/dewey">Dewey Library</a></li>
						<li><a href="/hayden">Hayden Library</a></li>
						<li><a href="/rotch">Rotch Library</a></li>
						<li><a href="/distinctive-collections">Distinctive Collections</a></li>
						<li><a href="/music">Lewis Music Library</a></li>
						<li><a href="/lsa">Library Storage Annex</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">Using the Libraries</h3>
					<ul class="list-unbulleted">
						<li><a href="/locations">Map of locations</a></li>
						<li><a href="/study">Study spaces</a></li>
						<li><a href="/disabilities">Persons with disabilities</a></li>
						<li><a href="/copying">Scan &amp; print</a></li>
						<li><a href="/exhibits">Exhibits &amp; galleries</a></li>
						<li><a href="/visitors">Visitors</a></li>
						<li><a href="/use-policies">Library use policy</a></li>
					</ul>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-borrowmenu-title" href="#" class="no-underline main-nav-link menu-control">Borrow &amp; request</a>
			</h2>
			<div aria-labelledby="main-nav-borrowmenu-title" id="main-nav-borrowmenu" class="links-sub flex-container group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Renew, request, suggest</h3>
					<ul class="list-unbulleted">
						<li><a href="/borrow">Borrow &amp; request home</a></li>
						<li><a href="/accounts">Accounts overview <span class="about">Your Account, ILLiad, Aeon, etc.</span></a></li>
						<li><a href="/search-collections">Search Our Collections <span class="about">Request items owned by MIT</span></a></li>
						<li><a href="/worldcat">WorldCat <span class="about">Request items not owned by MIT</span></a></li>
						<li><a href="/illiad">ILLiad <span class="about">Track your Interlibrary Borrowing requests</span></a></li>
						<li><a href="/suggest-purchase">Suggest a purchase</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">More information</h3>
					<ul class="list-unbulleted">
						<li><a href="/reserves">Course reserves</a></li>
						<li><a href="/borrow-direct">Borrow Direct <span class="about">Request items from Harvard, Yale, etc.</span></a></li>
						<li><a href="/otherlibraries">Visit non-MIT libraries <span class="about">Harvard, Borrow Direct, etc.</span></a></li>
					</ul>
				</div>
			</div>
		</li>
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-researchmenu-title" href="#" class="no-underline main-nav-link menu-control">Research support</a>
			</h2>
			<div aria-labelledby="main-nav-researchmenu-title" id="main-nav-researchmenu" class="links-sub flex-container push group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">Help &amp; useful tools</h3>
					<ul class="list-unbulleted">
						<li><a href="/research-support">Research support home</a></li>
						<li><a href="/ask">Ask us <span class="about">Email, chat, call, drop by</span></a></li>
						<li><a href="/experts">Research guides &amp; expert librarians <span class="about">For every research interest</span></a></li>
						<li><a href="/authenticate">Authenticate to online resources <span class="about">Tips &amp; tricks</span></a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">Publishing &amp; content management</h3>
					<ul class="list-unbulleted">
						<li><a href="/references">Citation &amp; writing tools <span class="about">Mendeley, Zotero, &amp; Overleaf</span></a></li>
						<li><a href="/citing">Citing sources <span class="about">Avoid plagiarism, format references, etc.</span></a></li>
						<li><a href="/data-services">Data services <span class="about">GIS, data management, statistical support</span></a></li>
						<li><a href="/scholarly">Scholarly communications <span class="about">Open access, copyright, &amp; publishing</span></a></li>
						<li><a href="/apis">APIs for scholarly resources</a></li>
					</ul>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end">
			<h2 class="main-nav-header">
				<a id="main-nav-aboutmenu-title" href="#" class="no-underline main-nav-link menu-control">About</a>
			</h2>
			<div aria-labelledby="main-nav-aboutmenu-title" id="main-nav-aboutmenu" class="links-sub flex-container push group">
				<div class="col-1 flex-item">
					<h3 class="heading-col">About the Libraries</h3>
					<ul class="list-unbulleted">
						<li><a href="/about/">About us home</a></li>
						<li><a href="/contact">Contact us</a></li>
						<li><a href="/jobs">Jobs</a></li>
						<li><a href="/giving">Giving to the MIT Libraries</a></li>
					</ul>
				</div>
				<div class="col-2 flex-item">
					<h3 class="heading-col">News, events, &amp; exhibits</h3>
					<a href="/events">Classes &amp; events</a>
					<a href="/news">News</a>
					<a href="/exhibits">Exhibits &amp; galleries</a>
					<a href="/news/in-the-media">In the media</a>
					<a href="/mit-reads/">MIT Reads</a>
				</div>
			</div><!-- end div.links-sub -->
		</li><!-- end div.links-primary -->
		<li class="link-primary flex-end small chat push">
			<h2 class="main-nav-header">
				<a id="main-nav-askusmenu-title" href="#" class="no-underline main-nav-link menu-control"><svg version="1.1" xmlns="http://www.w3.org/2000/svg" x="0px" y="0px" width="16.593px" height="16px" viewBox="0 0 16.593 16" enable-background="new 0 0 16.593 16" xml:space="preserve"><path d="M16.593 6.278c0 1.074-0.074 2.148-0.241 3.185 -0.204 1.353-1.722 2.574-3.055 2.722 -1.353 0.131-2.686 0.204-4.02 0.223L5.74 15.833C5.63 15.944 5.481 16 5.334 16c-0.094 0-0.167-0.019-0.241-0.037C4.871 15.87 4.74 15.647 4.74 15.407V12.37c-0.481-0.036-0.963-0.055-1.443-0.111 -1.334-0.148-2.853-1.443-3.074-2.796C0.074 8.426 0 7.352 0 6.296c0-1.092 0.074-2.185 0.223-3.24 0.222-1.352 1.74-2.648 3.074-2.797C4.963 0.093 6.63 0 8.297 0s3.333 0.093 5 0.259c1.333 0.149 2.851 1.445 3.055 2.797C16.519 4.111 16.593 5.204 16.593 6.278"/></svg><span>Ask Us</span></a>
			</h2>
			<div aria-labelledby="main-nav-askusmenu-title" id="main-nav-askusmenu" class="links-sub push">
				<div class="wrap-button-chat">
					<div id='libchat_be2c654b63dd43f31c56295ee5d78d88'></div>
				</div>
				<a class="more" href="/ask">More ways to ask us</a>
			</div>
		</li>
		<li class="link-primary flex-end small">
			<h2 class="main-nav-header">
				<a href="/accounts" class="no-underline main-nav-link account-link">
					<svg version="1.1" xmlns="http://www.w3.org/2000/svg" x="0" y="0" width="15.4" height="16" viewBox="0 0 15.4 16" enable-background="new 0 0 15.445 16" xml:space="preserve"><path d="M13.4 15.7C12.2 15.9 10.4 16 7.7 16c-5.4 0-7.3-0.6-7.3-0.6 -0.3-0.1-0.4-0.4-0.4-0.7 0.3-1.6 1.2-2.5 2.5-3.3 0.3-0.2 0.8-0.4 1.2-0.6 0.8-0.3 1.8-0.7 2-1.3C5.8 9.2 5.7 8.6 5.2 7.9c-1.4-2.3-1.7-4.3-0.8-5.9C5.1 0.7 6.4 0 7.7 0c1.4 0 2.6 0.7 3.3 2 0.9 1.6 0.7 3.6-0.8 5.9C9.8 8.6 9.6 9.2 9.8 9.6c0.2 0.6 1.2 1 2 1.3 0.4 0.2 0.9 0.4 1.2 0.6 1.2 0.8 2.1 1.6 2.5 3.3 0.1 0.3-0.1 0.6-0.4 0.7C15 15.4 14.5 15.6 13.4 15.7"/></svg><span>Account</span>
				</a>
			</h2>
		</li>
	</ul>
</nav>
						<a class="link-logo-mit" href="http://www.mit.edu"><img src="https://cdn.libraries.mit.edu/files/branding/local/mit_logo_std_rgb_white.svg" height="32" alt="MIT logo" >
			</a><!-- End MIT Logo -->
							
<a href="/search" class="link-site-search hidden-non-mobile">
	<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="12" height="16" viewBox="0 0 12 12" class="icon-search"><path d="M7.273 0.727q1.187 0 2.19 0.585t1.588 1.588 0.585 2.19-0.585 2.19-1.588 1.588-2.19 0.585q-1.278 0-2.33-0.676l-3.284 3.301q-0.295 0.284-0.688 0.284-0.403 0-0.688-0.284t-0.284-0.688 0.284-0.688l3.301-3.284q-0.676-1.051-0.676-2.33 0-1.188 0.585-2.19t1.588-1.588 2.19-0.585zM7.273 8q0.591 0 1.128-0.23t0.929-0.622 0.622-0.929 0.23-1.128-0.23-1.128-0.622-0.929-0.929-0.622-1.128-0.23-1.128 0.23-0.929 0.622-0.622 0.929-0.23 1.128 0.23 1.128 0.622 0.929 0.929 0.622 1.128 0.23z"></path></svg>
	<span class="bottom">Search</span>
</a><!-- End /search -->

<a href="/accounts" class="link-account hidden-non-mobile">
	<svg version="1.1" xmlns="http://www.w3.org/2000/svg" x="0" y="0" width="15.4" height="16" viewBox="0 0 15.4 16" enable-background="new 0 0 15.445 16" xml:space="preserve" class="icon-account"><path d="M13.4 15.7C12.2 15.9 10.4 16 7.7 16c-5.4 0-7.3-0.6-7.3-0.6 -0.3-0.1-0.4-0.4-0.4-0.7 0.3-1.6 1.2-2.5 2.5-3.3 0.3-0.2 0.8-0.4 1.2-0.6 0.8-0.3 1.8-0.7 2-1.3C5.8 9.2 5.7 8.6 5.2 7.9c-1.4-2.3-1.7-4.3-0.8-5.9C5.1 0.7 6.4 0 7.7 0c1.4 0 2.6 0.7 3.3 2 0.9 1.6 0.7 3.6-0.8 5.9C9.8 8.6 9.6 9.2 9.8 9.6c0.2 0.6 1.2 1 2 1.3 0.4 0.2 0.9 0.4 1.2 0.6 1.2 0.8 2.1 1.6 2.5 3.3 0.1 0.3-0.1 0.6-0.4 0.7C15 15.4 14.5 15.6 13.4 15.7"/></svg>
	<span class="bottom">Account</span>
</a><!-- End /barton-account -->

<a href="/contact" class="link-contact hidden-non-mobile">
	<i class="fa fa-book" aria-hidden="true"></i>
	<span class="bottom">Contact</span>
</a><!-- End /contact -->
					</header>


	<div class="breadcrumbs--better hidden-phone group" role="navigation" aria-label="breadcrumbs">
	<span><a href="/">Libraries home</a></span>
	Research support<span></span></div>


	<div id="stage" class="inner" role="main">

					
<div class="title-page">
			<h1>Research support</h1>
	</div>
		
		<div id="content" class="content has-sidebar">

							

<div class="main-content content-main">
	<div class="entry-content">
		<div class="entry-page-title">
				</div>
		<p>Find out where and how to get help for your research or coursework.</p>
<h2>Expert help</h2>
<ul>
<li><a href="https://libraries.mit.edu/consultations">Make an appointment</a> for a consult with an <a href="/experts">expert librarian</a></li>
<li><a href="/experts">Research guides</a>: specialized guides for every research interest</li>
<li>Not sure where to begin or who to contact? Complete our <a href="/ask-email">Ask us email form</a>.</li>
</ul>
<h2>Quick help</h2>
<ul>
<li><a style="line-height: 1.5em;" href="/offcampus">Connect from on &amp; off-campus</a></li>
<li><a style="line-height: 1.5em;" href="/research-support/troubleshooting">E-resource troubleshooting</a></li>
<li><a href="http://libguides.mit.edu/classguides">Guides for specific classes &amp; programs</a></li>
</ul>
<h2>Writing &amp; publishing help</h2>
<ul>
<li><a href="http://libguides.mit.edu/citing">Citing sources &amp; avoiding plagiarism</a></li>
<li><a href="/theses">Dissertations/theses: prepare &amp; submit your MIT thesis, or borrow others&#8217; </a></li>
<li><a href="/archives/thesis-specs/index.html">MIT thesis specifications</a></li>
<li><a href="http://dspace.mit.edu">DSpace@MIT: deposit your work to MIT&#8217;s repository</a></li>
<li><a href="/scholarly">Scholarly Communication</a></li>
<li><a href="http://libguides.mit.edu/authorids">Author identifiers: connect your name with your work</a></li>
</ul>
<h2>Help for getting organized: citation &amp; content management tools</h2>
<h3>Organize your references &amp; PDFs:</h3>
<ul>
<li><a href="/references">Overview of citation management</a></li>
<li><a href="/zotero">Zotero</a></li>
<li><a href="/mendeley">Mendeley</a></li>
</ul>
<h3>Organize your files &amp; information:</h3>
<ul>
<li><a href="http://libguides.mit.edu/cite-write">Citation Management and Writing Tools</a></li>
<li><a href="/data-management/store/organize/">Data management &#8211; Organize your files</a></li>
</ul>
	</div>
</div>
			
								
	<div id="sidebarContent" class="sidebar span3">
		<div class="sidebarWidgets">
			<aside id="black-studio-tinymce-5" class="widget-odd widget-first widget-1 no-top-border widget widget_black_studio_tinymce" role="complementary"><h2 class="widget-title">See also:</h2><div class="textwidget"><ul class="arrows">
<li><a title="Borrow &amp; request" href="/circ">Borrow &amp; request</a></li>
</ul>
</div></aside><aside id="black-studio-tinymce-39" class="widget-even widget-last widget-2 widget widget_black_studio_tinymce" role="complementary"><h2 class="widget-title">Information for:</h2><div class="textwidget"><ul>
<li><a href="/faculty">Faculty</a></li>
<li><a href="/alumni">Alumni</a></li>
<li><a href="/visitors">Visitors</a></li>
<li><a href="/disabilities">Persons with disabilities</a></li>
</ul>
</div></aside>		</div>
	</div>      
			
		</div><!-- end div#content -->

	</div><!-- end div#stage -->


	<footer>

		<div class="footer-main flex-container">
	<div class="links-all flex-container">
		<div class="flex-item">
			<h4><a href="/search">Search</a></h4>
			<a href="/search-collections" class="link-sub">Search Our Collections</a>
			<a href="/worldcat" class="link-sub">WorldCat</a>
			<a href="https://libguides.mit.edu/az.php" class="link-sub">Databases A-Z</a>
			<a href="/search-reserves" class="link-sub">Course reserves</a>
			<a href="/site-search" class="link-sub">Site search</a>
			<a href="/search" class="link-sub">More search options</a>
		</div>
		<div class="flex-item">
			<h4><a href="/hours">Hours &amp; locations</a></h4>
			<a href="/hours" class="link-sub">Hours</a>
			<a href="/locations" class="link-sub">Map of locations</a>
			<a href="/study" class="link-sub">Study spaces</a>
			<a href="/exhibits" class="link-sub">Exhibits &amp; galleries</a>
		</div>
		<div class="flex-item">
			<h4><a href="/borrow">Borrow &amp; request</a></h4>
			<a href="/accounts" class="link-sub">Accounts overview</a>
			<a href="/reserves" class="link-sub">Course reserves</a>
			<a href="/otherlibraries" class="link-sub">Visit non-MIT libraries</a>
			<a href="/borrow" class="link-sub">More borrow &amp; request options</a>
		</div>
		<div class="flex-item">
			<h4><a href="/research-support">Research support</a></h4>
			<a href="/ask" class="link-sub">Ask us</a>
			<a href="/experts" class="link-sub">Research guides &amp; expert librarians</a>
			<a href="/scholarly" class="link-sub">Scholarly communications</a>
			<a href="/references" class="link-sub">Citation &amp; writing software</a>
			<a href="/research-support" class="link-sub">More research support options</a>
		</div>
		<div class="flex-item">
			<h4><a href="/about">About us</a></h4>
			<span class="link-sub"><a href="/contact">Contact us</a> | <a href="/follow">Follow us</a></span>
			<span class="link-sub"><a href="/news">News</a></span>
			<span class="link-sub"><a href="/events">Classes &amp; events</a></span>
			<span class="link-sub"><a href="/use-policies">Use policy</a></span>
			<span class="link-sub"><a href="/giving">Giving</a></span>
			<span class="link-sub"><a href="/about">More about us</a></span>
		</div>
	</div><!-- end div.links-all -->

	<div class="identity flex-container">
		<a href="/" class="logo-mit-lib"><img src="https://cdn.libraries.mit.edu/files/branding/local/mitlib-wordmark.svg" alt="MIT Libraries logo"></a><!-- End MIT Libraries Logo -->

		<div class="links-primary flex-container">
			<span><a href="https://libraries.mit.edu/privacy" class="link-sub">Privacy</a></span>
			<span><a href="https://libraries.mit.edu/permissions" class="link-sub">Permissions</a></span>
			<span><a href="https://libraries.mit.edu/accessibility" class="link-sub">Accessibility</a></span>
			<span><a href="https://libraries.mit.edu/contact" class="link-sub">Contact us</a></span>
		</div><!-- End div.links-primary -->

	</div><!-- End div.identity -->
</div>

		<div class="footer-info-institute">
			<a class="link-logo-mit" href="https://www.mit.edu">
				<img src="https://cdn.libraries.mit.edu/files/branding/local/mit_lockup_std-three-line_rgb_white.svg" alt="MIT" width="152">
			</a>

			<div class="license">Content created by the MIT Libraries, <a href="https://creativecommons.org/licenses/by-nc/4.0/">CC BY-NC</a> unless otherwise noted. <a href="https://libraries.mit.edu/research-support/notices/copyright-notify/">Notify us about copyright concerns</a>.</div>
		</div><!-- End div.footer-info-institure -->
	</footer>

</div><!-- End div.wrap-page -->

<script type="speculationrules">
{"prefetch":[{"source":"document","where":{"and":[{"href_matches":"\/*"},{"not":{"href_matches":["\/wp\/wp-*.php","\/wp\/wp-admin\/*","\/app\/uploads\/*","\/app\/*","\/app\/plugins\/*","\/app\/themes\/mitlib-parent\/*","\/*\\?(.+)"]}},{"not":{"selector_matches":"a[rel~=\"nofollow\"]"}},{"not":{"selector_matches":".no-prefetch, .no-prefetch a"}}]},"eagerness":"conservative"}]}
</script>
            <script type="text/javascript">
                jQuery(function($) {
                    function equalHeight(group) {
                        tallest = 0;
                        group.each(function() {
                            thisHeight = $(this).height();
                            if(thisHeight > tallest) {
                                tallest = thisHeight;
                            }
                        });
                        group.height(tallest);
                    }

                    equalHeight($(".dg-grid-shortcode .dg_grid-shortcode-col"));

                    $(window).resize(function() {
                        equalHeight($(".dg-grid-shortcode .dg_grid-shortcode-col"));
                    });
                });
            </script>
            <script type="text/javascript" src="https://libraries.mit.edu/wp/wp-includes/js/dist/hooks.min.js?ver=4d63a3d491d11ffd8ac6" id="wp-hooks-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/wp/wp-includes/js/dist/i18n.min.js?ver=5e580eb46a90c2b997e6" id="wp-i18n-js"></script>
<script type="text/javascript" id="wp-i18n-js-after">
/* <![CDATA[ */
wp.i18n.setLocaleData( { 'text direction\u0004ltr': [ 'ltr' ] } );
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/contact-form-7/includes/swv/js/index.js?ver=6.1" id="swv-js"></script>
<script type="text/javascript" id="contact-form-7-js-before">
/* <![CDATA[ */
var wpcf7 = {
    "api": {
        "root": "https:\/\/libraries.mit.edu\/wp-json\/",
        "namespace": "contact-form-7\/v1"
    }
};
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/contact-form-7/includes/js/index.js?ver=6.1" id="contact-form-7-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/dev.js?ver=0.8" id="dev-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/libchat.js?ver=0.8" id="libchat-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/menu.toggle.js?ver=0.8" id="menu-toggle-js"></script>
<script type="text/javascript" id="parent-production-js-before">
/* <![CDATA[ */
const THEME_ROOT = "https://libraries.mit.edu/app/themes/mitlib-parent";
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/alerts.js?ver=0.8" id="parent-production-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/themes/mitlib-parent/js/core.js?ver=0.8" id="parent-interior-js"></script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/page-links-to/dist/new-tab.js?ver=3.3.7" id="page-links-to-js"></script>
<script type="text/javascript" id="wpcf7cf-scripts-js-extra">
/* <![CDATA[ */
var wpcf7cf_global_settings = {"ajaxurl":"https:\/\/libraries.mit.edu\/wp\/wp-admin\/admin-ajax.php"};
/* ]]> */
</script>
<script type="text/javascript" src="https://libraries.mit.edu/app/plugins/cf7-conditional-fields/js/scripts.js?ver=2.2.3" id="wpcf7cf-scripts-js"></script>
<script type="text/javascript">window.NREUM||(NREUM={});NREUM.info={"beacon":"bam.nr-data.net","licenseKey":"NRJS-03682cc69c1c5a39583","applicationID":"578343319","transactionName":"NQdVMkoCWUBYURENWAxNdgVMClhdFkIEA1I=","queueTime":0,"applicationTime":242,"atts":"GUBWRAIYSk4=","errorBeacon":"bam.nr-data.net","agent":""}</script></body>
</html>
", "response_headers": {"accept-ranges": ["bytes"], "age": ["421990"], "cache-control": ["public, max-age=604800"], "content-length": ["117657"], "content-type": ["text/html; charset=UTF-8"], "date": ["Tue, 09 Dec 2025 14:30:06 GMT"], "link": ["; rel=\"https://api.w.org/\", ; rel=\"alternate\"; title=\"JSON\"; type=\"application/json\", ; rel=shortlink"], "permissions-policy": ["geolocation=(), microphone=(), camera=()"], "referrer-policy": ["no-referrer-when-downgrade"], "server": ["nginx"], "strict-transport-security": ["max-age=300"], "vary": ["Accept-Encoding, Cookie"], "via": ["1.1 varnish"], "x-cache": ["HIT"], "x-cache-hits": ["1"], "x-content-type-options": ["nosniff"], "x-frame-options": ["SAMEORIGIN"], "x-pantheon-styx-hostname": ["styx-fe3-b-5df8569779-pqmgb"], "x-served-by": ["cache-chi-kigq8000105-CHI"], "x-styx-req-id": ["08be92e8-d135-11f0-a108-12562a46f4ee"], "x-timer": ["S1765290606.393752,VS0,VE3"], "x-orig-content-encoding": ["gzip"]}} diff --git a/tests/fixtures/mitlibwebsite/website.html b/tests/fixtures/mitlibwebsite/website.html new file mode 100644 index 0000000..23e7d61 --- /dev/null +++ b/tests/fixtures/mitlibwebsite/website.html @@ -0,0 +1,18 @@ + + + + + + +
+

Not Helpful

+
+ +

Hello World!

+ +
+

Also Not Helpful

+
+ + \ No newline at end of file diff --git a/tests/fixtures/mitlibwebsite/website_missing_og_description.html b/tests/fixtures/mitlibwebsite/website_missing_og_description.html new file mode 100644 index 0000000..047cee4 --- /dev/null +++ b/tests/fixtures/mitlibwebsite/website_missing_og_description.html @@ -0,0 +1,16 @@ + + + + + +
+

Not Helpful

+
+ +

Hello World!

+ +
+

Also Not Helpful

+
+ + \ No newline at end of file diff --git a/tests/sources/json/test_mitlibwebsite.py b/tests/sources/json/test_mitlibwebsite.py index 752dca2..033fe2f 100644 --- a/tests/sources/json/test_mitlibwebsite.py +++ b/tests/sources/json/test_mitlibwebsite.py @@ -1,15 +1,22 @@ # ruff: noqa: RUF001 +import base64 from unittest.mock import MagicMock, patch import transmogrifier.models as timdex from transmogrifier.sources.json.mitlibwebsite import MITLibWebsite -def create_mitlibwebsite_source_record_stub() -> dict: +def create_mitlibwebsite_source_record_stub( + html_filepath="tests/fixtures/mitlibwebsite/website.html", +) -> dict: + with open(html_filepath) as f: + html_content = f.read() + return { "url": "https://libraries.mit.edu/search/", "cdx_title": "Search | MIT Libraries", - "og_description": "Use this page to learn about different ways you can search the MIT Libraries' offerings.", # noqa: E501 + "html_base64": base64.b64encode(html_content.encode()).decode(), + "response_headers": {}, } @@ -45,6 +52,7 @@ def test_mitlibwebsite_transform_returns_timdex_record(mitlibwebsite_records): summary=[ "Use this page to learn about different ways you can search the MIT Libraries’ offerings. Use the Default Quick Search Our Quick Search is the default search on the Libraries’ homepage. This collects results from different library search tools and sorts the results into 4 categories: Books and media Articles and book chapters Archives and manuscript collections Our library website and guides The tool will search the 4 categories and present the top results from each category. It is useful to see the full breadth of what MIT Libraries has on a particular topic or author. Go straight to our […]" # noqa: E501 ], + fulltext=timdex_record.fulltext, ) @@ -119,13 +127,14 @@ def test_mitlibwebsite_get_links_success(): def test_mitlibwebsite_get_summary_success(): source_record = create_mitlibwebsite_source_record_stub() assert MITLibWebsite.get_summary(source_record) == [ - "Use this page to learn about different ways you can search the MIT Libraries' offerings." # noqa: E501 + "Use this page to learn about different ways you can search the MIT Libraries’ offerings. Use the Default Quick Search Our Quick Search is the default search on the Libraries’ homepage. This collects results from different library search tools and sorts the results into 4 categories: Books and media Articles and book chapters Archives and manuscript collections Our library website and guides The tool will search the 4 categories and present the top results from each category. It is useful to see the full breadth of what MIT Libraries has on a particular topic or author. Go straight to our […]" # noqa: E501 ] def test_mitlibwebsite_get_summary_returns_none_if_og_description_is_none(): - source_record = create_mitlibwebsite_source_record_stub() - source_record["og_description"] = None + source_record = create_mitlibwebsite_source_record_stub( + html_filepath="tests/fixtures/mitlibwebsite/website_missing_og_description.html" + ) assert MITLibWebsite.get_summary(source_record) is None diff --git a/transmogrifier/sources/json/mitlibwebsite.py b/transmogrifier/sources/json/mitlibwebsite.py index c933e56..442fcd9 100644 --- a/transmogrifier/sources/json/mitlibwebsite.py +++ b/transmogrifier/sources/json/mitlibwebsite.py @@ -1,5 +1,9 @@ +import base64 import hashlib import logging +from functools import lru_cache + +from bs4 import BeautifulSoup, Tag import transmogrifier.models as timdex from transmogrifier.sources.jsontransformer import JSONTransformer @@ -10,6 +14,30 @@ class MITLibWebsite(JSONTransformer): + @classmethod + @lru_cache(maxsize=8) + def parse_html(cls, html_base64: str) -> Tag: + """Parse HTML from base64 encoded ASCII string. + + For this mitlibwebsite source, also remove the
and