ब्राउज़र टैब के बीच घटनाओं, डेटा और कार्यों को साझा करने के लिए लाइब्रेरी

प्रणाम, प्रिय हेराबोसात्मकता!

लगभग आधे साल पहले, एक परियोजना को लागू करते समय, मुझे सर्वर टैब के साथ संचार का उपयोग किए बिना, ब्राउज़र टैब के बीच डेटा के आदान-प्रदान को व्यवस्थित करने, उनकी संख्या को ट्रैक करने और उनमें से कुछ को कार्य सौंपने की तत्काल आवश्यकता थी (अर्थात, संपूर्ण ग्राहक पर पूरी तरह से लागू)। नेटवर्क में उस समय कोई तैयार समाधान नहीं था, और इसलिए कॉफी की एक बाल्टी पर स्टॉक करने और अपनी पुन: प्रयोज्य बैसाखी लिखने का निर्णय लिया गया था। नतीजतन, परियोजना स्वयं, सफलतापूर्वक नहीं हुई, लेकिन पुस्तकालय विकसित किया गया था और अब तक हार्ड ड्राइव के डिब्बे में धूल इकट्ठा कर रहा है।

अब लाइब्रेरी को GitHub पर कुछ उदाहरणों के साथ अपलोड किया गया है , और हैब्रैट के तहत मैं इसके आवेदन की कुछ सूक्ष्मताओं और आंतरिक तर्क के हिस्से को उजागर करना चाहूंगा। मुझे खुशी होगी अगर मेरी लाइब्रेरी किसी को नौवीं बार बचाने में मदद करती है और अपनी साइकिल के आविष्कार से बचती है।

कौन परवाह करता है - बिल्ली में आपका स्वागत है।

इसकी आवश्यकता क्यों है और यह कहां उपयोगी हो सकता है

उदाहरण के लिए, ऑनलाइन स्टोर में, जब एक उपयोगकर्ता ने एक दर्जन टैब खोले और उनमें से एक में टोकरी में एक उत्पाद जोड़ा, हम अन्य सभी टैब को बता सकते हैं कि उन्हें उपयोगकर्ता के कार्यों (टोकरी में उत्पादों की संख्या को अपडेट करें) के अनुसार राज्य को बदलने की आवश्यकता है। या, उदाहरण के लिए, यदि हम अपनी साइट पर एक खिलाड़ी बनाना चाहते हैं, तो अलाका, वीकॉन्टेक्ट, जो अन्य सभी टैब में प्लेबैक को जाम कर देगा, अगर उपयोगकर्ता ने कुछ और चालू करने का फैसला किया है।

सामान्य तौर पर, यह लाइब्रेरी उन अनुप्रयोगों के लिए उपयोगी हो सकती है जहां टैब के बीच डेटा सिंक्रोनाइज़ेशन की आवश्यकता हो सकती है, लेकिन सर्वर साइड का उपयोग करने के लिए यह अवांछनीय (या संभव नहीं) है। या, यदि उपयोगकर्ता को डेटा भ्रष्टाचार / हानि से बचने के लिए कई टैब खोलने से रोकने की आवश्यकता है।

पुस्तकालय क्या कर सकते हैं

- खुले टैब की वर्तमान संख्या पर नज़र रखना, नए / बंद पुराने टैब खोलने की घटनाओं पर प्रतिक्रिया।
- कुछ घटनाओं के लिए कॉलबैक फ़ंक्शन सेट करने की क्षमता (केवल कुछ टैब में उन्हें बांधने की क्षमता के साथ)।
- इवेंट ऑब्जेक्ट में डेटा ट्रांसफर करने की क्षमता, अगर किसी टैब ने किसी घटना की सूचना दी है।
- केवल एक विशिष्ट टैब (या टैब के समूह) में किसी घटना की रिपोर्ट करने की क्षमता।
- कोड को वांछित टैब के संदर्भ में चलाएं, इस क्रिया को दूसरे टैब से आरंभ करें।

आंतरिक संरचना के बारे में कुछ शब्द

सबसे पहले, यह कहने योग्य है कि अपने कामकाज के लिए पुस्तकालय को ब्लॉब, ब्लो.बर्ल, वर्कर और लोकलस्टोरेज के लिए ब्राउज़र समर्थन की आवश्यकता है।

टैब के बीच संदेशों के आदान-प्रदान के कार्यान्वयन के बारे में इंटरनेट पर बहुत सारे प्रकार के विचार चल रहे हैं, जिनमें से अधिकांश टैब को बंद करने को ट्रैक करने में असमर्थता पर निर्भर करते हैं, या कोड को एक टैब से दूसरे टैब पर भेजने से रोकते हैं, या कुछ आधुनिक ब्राउज़रों में, निष्क्रिय टैब के सेटटाइमआउट को केवल एक बार निष्पादित करना संभव है। प्रति सेकंड (जो 5-10 खुले टैब के साथ एक गंभीर देरी का परिणाम है), या लोकलस्टोरेज इवेंट्स के लिए समर्थन की अनुपस्थिति में, या सर्वर के साथ संचार के माध्यम से कार्यान्वित किया जाता है। और के खिलाफ एक दर्जन कारणों से।

निम्नलिखित पथ को एक समाधान के रूप में चुना गया था:
1. आंतरिक कार्य शेड्यूलर, वर्तमान घटनाओं की सूची, सक्रिय टैब पर डेटा, कॉन्फ़िगरेशन और कुछ अन्य सेवा डेटा वाले ऑब्जेक्ट (पैक रूप में) को संग्रहीत करने के लिए लोकलस्टोरेज का उपयोग करें।
2. टैब की उपस्थिति / समापन को ट्रैक करने के लिए, वर्कर का उपयोग करें (ब्लॉब और ब्लॉब। बस यहां आवश्यक हैं), जिनके कार्यों को टैब के बैकग्राउंड पिंग करने के लिए कम किया जाता है (क्योंकि कार्यकर्ता निष्क्रिय टैब के लिए टाइमआउट की आवृत्ति पर ब्राउज़र प्रतिबंधों की उपेक्षा करता है)।
3. टैब (कार्यकर्ता से पिंग द्वारा) द्वारा आवश्यक कार्यों के अनुक्रमिक निष्पादन के लिए आंतरिक कार्य अनुसूचक का उपयोग करें।

एपीआई विवरण

पुस्तकालय में कोई बाहरी निर्भरता नहीं होती है। जब यह वैश्विक दायरे में जुड़ा होता है, तो __SE__ वस्तु उपलब्ध हो जाती है।

सिस्टम इवेंट

डिफ़ॉल्ट रूप से, पुस्तकालय तीन वैश्विक घटनाओं को लागू करता है।
tabOpened - जब एक नया टैब खोला जाता है तो उसे कॉल किया जाता है।
tabClosed - जब टैब में से एक बंद हो जाता है (टाइमआउट से क्रैश) कहा जाता है।
tabNameChanged - टैब का नाम बदलने पर कॉल किया जाता है।

कॉन्फ़िगरेशन विकल्प

__SE__। नाम - वर्तमान टैब का नाम (मुखौटा द्वारा एक पंक्ति "a-zA-Z \ _ \ - \ d")। विशिष्ट टैब में घटनाओं की रिपोर्ट करने के लिए उपयोग किया जाता है। यदि कई टैब का एक ही नाम है, तो यह पैरामीटर समूहिंग गुणों को प्राप्त करता है जब घटना उसी टैब के समूह के लिए तुरंत उड़ान भरती है।
डिफ़ॉल्ट मान "डिफ़ॉल्ट" है

__SE__। SelfExecution - एक ध्वज जो प्रश्न का उत्तर देता है "क्या मुझे वर्तमान टैब में घटनाओं को निष्पादित करना चाहिए जो स्वयं द्वारा ट्रिगर किए गए थे?" सीधे शब्दों में कहें, अगर हमारे पास "MyTabName" नाम के दो टैब हैं और उनमें से एक "MyTabName" नाम के टैब के लिए एक घटना की रिपोर्ट करता है, तो SelfExecution ध्वज सेट के आधार पर, एक निर्णय लिया जाएगा कि क्या हुआ के बारे में स्वयं को आरंभ करने वाले टैब को सूचित करें घटना।
डिफ़ॉल्ट मूल्य: गलत (स्वयं की घटनाओं के बारे में सूचित न करें)।
नोट 1: यह ध्वज केवल सामान्य ईवेंट हैंडलर्स के साथ काम करते समय प्रासंगिक है, उनके बारे में नीचे।
नोट 2: यदि घटना वैश्विक है (__SE __ में तीसरा तर्क पारित किए बिना ट्रिगर किया गया है। DispatchEvent () विधि, या __SE __ पास करना। तीसरे तर्क के रूप में निरंतर), इस ध्वज को अनदेखा किया जाएगा।

__SE__। मिलीसेकंड में सिंक एक पैरामीटर है जो वर्कर को बताता है कि टैब को कितनी बार पिंग करना है।
डिफ़ॉल्ट मान: 100 (आंतरिक स्थिर DEFAULT_WORKER_INTERVAL )।

__SE__। TabTimeoutMult एक गुणक है जो यह इंगित करता है कि यह बंद होने से पहले एक टैब के लिए प्रतीक्षा करने के लिए कितने चक्र हैं।
डिफ़ॉल्ट मान 2 है (आंतरिक स्थिर DEFAULT_TAB_TIMEOUT_MULTIPLIER )।

__SE__। SLockTimeoutMult - एक मल्टीप्लायर यह दर्शाता है कि लोकलस्टेज में ऑब्जेक्ट को अनलॉक करने के लिए कितने टिक की उम्मीद है।
डिफ़ॉल्ट मान: 2 (आंतरिक स्थिर DEFAULT_STORAGE_LOCK_MULTIPLIER )।

जब आप तीन मापदंडों (__SE __। सिंक, __SE __। TabTimeoutMult और __SE __। SLockTimeoutMult) में से किसी को बदलते हैं, तो नए मान स्वचालित रूप से अन्य टैब के साथ सिंक्रनाइज़ हो जाते हैं और पूर्ण सिंक्रनाइज़ेशन के बाद प्रभावी होते हैं। ये तीन पैरामीटर विशेष रूप से टैब सिंक्रनाइज़र के आंतरिक यांत्रिकी को प्रभावित करते हैं:
1) ऑब्जेक्ट जो स्थानीय कॉन्फ़िगरेशन में लाइब्रेरी कॉन्फ़िगरेशन को संग्रहीत करता है, में एक आंतरिक लॉकिंग तंत्र है (ताकि टैब संग्रहीत डेटा को खराब न करें और टैब से टैब तक बारी-बारी से कड़ाई से प्रदर्शन किया जाए)। अंतर्निहित "लॉक" में सीमाओं की एक क़ानून है जो सक्रिय टैब (रिपॉजिटरी के साथ काम करना और लॉक सेट करना) बंद होने पर टाइमआउट द्वारा रिपॉजिटरी को अनलॉक करता है। इस समयसीमा की गणना सूत्र द्वारा की जाती है:
__SE__.Sync * __SE__.SLockTimeoutMult
2) एक टैब को बंद करने का संकेत सूत्र द्वारा निर्धारित किया जाता है:
__SE__.Sync * __SE__.ActiveTabsCount * __SE__.TabTimeoutMult

स्थिरांक

__SE__। जीआईडी - एक वैश्विक घटना या वैश्विक हैंडलर की पहचान ("__Global__" के लिए चूक): यदि आप इस स्थिरांक को एक संकेतक के रूप में निर्दिष्ट करते हैं, जिस टैब को घटना को प्रेषित किया जाना है, तो घटना को सभी अन्य टैब प्राप्त होंगे। यदि आप __SE __ में लक्ष्य टैब निर्दिष्ट नहीं करते हैं तो यह पहचानकर्ता डिफ़ॉल्ट रूप से पारित हो जाता है। DispatchEvent () विधि। यदि आप इस पहचानकर्ता को __SE __ के लिए तीसरे तर्क के रूप में पास करते हैं। AddEventListener () विधि, तो संबंधित ईवेंट के लिए हैंडलर वैश्विक हो जाएगा और सभी टैब में तुरंत निष्पादित होगा।

__SE__। आईडी - वर्तमान टैब का विशिष्ट पहचानकर्ता। लाइब्रेरी शुरू होने पर उत्पन्न।

चर

__SE__। ActiveTabsCount - खुले टैब की वर्तमान संख्या का मान संग्रहीत करता है। यह आंतरिक कार्य अनुसूचक के प्रत्येक चक्र के साथ अद्यतन किया जाता है और अद्यतन आवृत्ति (सामान्य स्थिति में) उत्पाद के बराबर है ___ __। खुले टैब की संख्या से सिंक करें।

तरीकों

__SE__। getActiveTabs (शून्य)
वर्तमान खुले टैब का वर्णन करने वाली वस्तुओं की एक सरणी लौटाता है:

 //   . var TabObjectExample = { 'Checked' : true , //       . 'ConfigCache' : Object , //     . 'ID' : "152644ab-7138-297c-60a4-efd8d8a8380c" , //   ID . 'Name' : "Default" , //  . 'Ping' : 1398107406052 // TimeStamp   . }; 

__SE__। addEventListener (प्रकार, श्रोता [, टैबनेम] )
एक इवेंट हैंडलर जोड़ता है।
इवेंट हैंडलर स्थानीय और सामान्य हैं ।
स्थानीय ईवेंट हैंडलर : __SE__ ऑब्जेक्ट के wilds में संग्रहीत और वर्तमान टैब के भीतर काम करते हैं। एक स्थानीय ईवेंट हैंडलर बनाने के लिए, इस पद्धति के तीसरे तर्क को पारित नहीं करना पर्याप्त है।
साझा किए गए ईवेंट हैंडलर : स्थानीयस्टेज में लाइब्रेरी के कॉन्फ़िगरेशन ऑब्जेक्ट में संग्रहीत, एक SharedEventListener (सभी टैब के लिए उपलब्ध साझा हैंडलर) के रूप में। इस प्रकार के हैंडलर को TabName तर्क पारित करके बनाया गया है।
यदि हम __SE __ का उपयोग करते हैं। TabName के तर्क के रूप में स्थिर रहें, हैंडलर वैश्विक हो जाएगा और सभी टैब में निष्पादित हो जाएगा जब उनमें से किसी में भी संबंधित घटना होती है।
टाइप करें - प्रतिक्रिया करने के लिए घटना का प्रकार। "ए-जेडए-जेड" मुखौटा द्वारा स्ट्रिंग। आवश्यक है।
श्रोता - एक हैंडलर फ़ंक्शन जिसे इसी घटना के होने पर निष्पादित किया जाएगा। आवश्यक है।
जब फ़ंक्शन निष्पादित होता है, तो एक ऑब्जेक्ट जिसमें घटना और उपयोगकर्ता डेटा के बारे में डेटा होता है, उसे स्थानांतरित किया जाता है:

 //   . var EventObjectExample = { 'Data' : false , //    (   __SE__.dispatchEvent()). 'Sender' : //     . { ID : "81e0eaf0-3a02-15e1-b28c-7aa1629801c0" , //   . Name : "Default" // . } , 'Timestamp' : 1398113182091 // TimeStamp  . }; 

टैबनेम - उस टैब का नाम, जिसे ईवेंट हैंडलर को सौंपा गया है। मास्क स्ट्रिंग "a-zA-Z \ _ \ - \ d" है। यदि आप निरंतर __SE __ पास करते हैं। टैब के नाम के रूप में GID, तो हैंडलर वैश्विक हो जाएगा और सभी टैब में निष्पादित होगा।
नोट 1: आपको इस तथ्य पर ध्यान देना चाहिए कि श्रोता को उस टैब के संदर्भ में निष्पादित किया जाएगा जिसमें यह घटना द्वारा ट्रिगर किया गया था, इसलिए इसके कामकाज के लिए आवश्यक सभी डेटा को स्पष्ट रूप से निर्दिष्ट किया जाना चाहिए या घटना ऑब्जेक्ट में पास होना चाहिए।
नोट 2: सामान्य हैंडलर तब मौजूद रहते हैं जब उनकी उपस्थिति बंद होने वाला टैब बंद हो जाता है।

__SE__। hasEventListener (टाइप [, श्रोता [, टैबनेम, कॉलबैक]] )
इवेंट हैंडलर के लिए चेक। इसमें एक, दो, या चार तर्क (लेकिन तीन नहीं) लगते हैं।
प्रकार - जाँच की जा रही घटना का प्रकार। आवश्यक है।
श्रोता एक फ़ंक्शन है जिसे इवेंट हैंडलर के रूप में जांचा जाता है।
नोट: श्रोता तर्क गलत हो सकता है अगर तीसरे और चौथे तर्क के साथ संयोजन में उपयोग किया जाता है, और लक्ष्य यह निर्धारित करना है कि कोई विशेष हैंडलर नहीं है, लेकिन केवल तथ्य यह है कि एक हैंडलर है, जैसे कि।
यदि केवल एक या पहले दो तर्कों को पारित किया जाता है, तो चेक स्थानीय ईवेंट हैंडलर्स द्वारा होता है और चेक का परिणाम तुरंत वापस आ जाता है। एक उदाहरण:

 /* *    . */ var tabOpenedCallback = function(){ console.log( 'Local __SE__ event called on tabOpened.' ); }; //       . __SE__.addEventListener( 'tabOpened' , tabOpenedCallback ); __SE__.hasEventListener( 'tabOpened' , tabOpenedCallback ); //=> true __SE__.hasEventListener( 'tabOpened' ); //=> true __SE__.hasEventListener( 'someOtherEvent' ); //=> false /* *        : * => Local __SE__ event called on tabOpened. */ 

टैबनाम - टैब का नाम जिसके लिए एक सामान्य ईवेंट हैंडलर की जाँच की जाती है। यदि झूठ को इस तर्क के रूप में पारित किया जाता है, तो वांछित घटना के लिए कम से कम कुछ सामान्य हैंडलर की प्रमुख उपस्थिति के लिए एक खोज की जाएगी। यदि आप इस तर्क के रूप में __SE __ पास करते हैं। इस तर्क के अनुसार स्थिर रहें, तो खोज केवल वैश्विक हैंडलर द्वारा की जाएगी।
कॉलबैक - एक फ़ंक्शन जो एक तर्क के रूप में एक परीक्षा परिणाम लेता है।
जब सभी चार तर्क __SE __ को पास कर दिए जाते हैं। HasEventListener () विधि, सामान्य ईवेंट हैंडलर्स का उपयोग करके चेक किया जाता है और परीक्षण के परिणाम कॉलबैक फ़ंक्शन पर वापस आ जाते हैं।
नोट 1: सामान्य ईवेंट हैंडलर्स की जाँच करते समय, श्रोता और टैबनेम तर्क को गलत के रूप में पारित किया जा सकता है - इस मामले में, इस ईवेंट के लिए एक सामान्य हैंडलर के अस्तित्व को सिद्धांत रूप में जांचा जाएगा।
नोट 2: यदि आपको किसी अन्य टैब पर स्थानीय हैंडलर के अस्तित्व की जांच करने की आवश्यकता है, तो आप आवश्यक हैंडलर को एक सामान्य हैंडलर असाइन करके (चेक के परिणामों के साथ एक घटना लौटा सकते हैं) और तुरंत कॉलिंग इवेंट आरंभ कर सकते हैं।
एक उदाहरण:

 /* *    : */ var tabOpenedCallback = function(){ document.write( 'Shared __SE__ event called on tabOpened.' ); }; //       "TestTab"      . __SE__.addEventListener( 'tabOpened' , tabOpenedCallback , 'TestTab' ); /* *   .   : */ __SE__.Name = 'TestTab'; /* *   .            : * => Shared __SE__ event called on tabOpened. *    : */ var CheckCallback = function( CheckResult ){ console.log( CheckResult ); }; __SE__.hasEventListener( 'tabOpened' , false , 'TestTab' , CheckCallback ); //=>    true __SE__.hasEventListener( 'tabOpened' , false , false , CheckCallback ); //=>    true, ..         __SE__.hasEventListener( 'tabOpened' , false , __SE__.GID , CheckCallback ); //=>    false, ..    __SE__.hasEventListener( 'tabOpened' , false , 'NotExistingTab' , CheckCallback ); //=>    false 

__SE__। निष्कासन सूची (टाइप [, श्रोता [, टैबनेम, कॉलबैक]] )
एक इवेंट हैंडलर को हटाता है। इसमें एक, दो या चार (लेकिन तीन नहीं) तर्क लगते हैं।
सामान्य यांत्रिकी में, यह पूरी तरह से __SE __ के सिद्धांतों के साथ मेल खाता है। HasEventListener () विधि: एक / दो तर्कों के साथ यह स्थानीय घटना संचालकों के साथ काम करता है, चार के साथ - आम संचालकों के साथ।
नोट 1: हमेशा सही रिटर्न देता है।
नोट 2: यदि दोनों मामलों में श्रोता और तबनाम के बजाय दोनों गलत हैं, तो एक निश्चित घटना से जुड़े सभी सामान्य हैंडलर हटा दिए जाएंगे। यदि TabName सेट किया गया है, लेकिन श्रोता के बजाय गलत पारित किया जाता है, तो चयनित टैब के सभी सामान्य हैंडलर हटा दिए जाएंगे। यदि श्रोता पास हो जाता है, लेकिन TabName == गलत है, तो सभी टैब वांछित सामान्य हैंडलर को निकाल देंगे।
नोट 3: किसी अन्य टैब से किसी स्थानीय ईवेंट हैंडलर को निकालने के लिए, आपको इस टैब के संदर्भ में हटाए गए कोड को निष्पादित करना होगा। ऐसा करने के लिए, आपको किसी विशिष्ट ईवेंट के लिए वांछित टैब को एक अतिरिक्त सामान्य हैंडलर असाइन करना होगा और इस ईवेंट को रिपोर्ट करना होगा। मुख्य बात बाद में छोरों को साफ करने के लिए नहीं भूलना है।
नोट 3 का उदाहरण:

 /* *    : */ __SE__.Name = 'MainTab'; //     var someUserEventCallback = function( Event ){ document.write( 'Local __SE__ event called by tab "' + Event.Sender.Name + '" on ' + Event.Timestamp + '<br>' ); }; //        -  . __SE__.addEventListener( 'someUserEvent' , someUserEventCallback ); /* *   .   : */ __SE__.dispatchEvent( 'someUserEvent' ); //   ,        //           . var TabCallbackRemover = function(){ __SE__.removeEventListener( 'someUserEvent' ); //     __SE__.removeEventListener( 'removeListener' , false , 'MainTab' , function(){} ); //   }; __SE__.addEventListener( 'removeListener' , TabCallbackRemover , 'MainTab' ); //      __SE__.dispatchEvent( 'removeListener' ); //    __SE__.dispatchEvent( 'someUserEvent' ); //        , ..        

__SE__। प्रेषण (प्रकार [, डेटा [, टैबनेम]] )
किसी घटना की रिपोर्ट करता है। यह एक से तीन तर्कों (वांछित व्यवहार के आधार पर) से ले सकता है।
प्रकार - रिपोर्ट की गई घटना का प्रकार। "ए-जेडए-जेड" मुखौटा द्वारा स्ट्रिंग। आवश्यक है।
डेटा - डेटा जो हैंडलर फ़ंक्शन को पारित किए गए ईवेंट ऑब्जेक्ट के डेटा फ़ील्ड में स्थानांतरित किया जाएगा। प्रेषित डेटा का प्रारूप मनमाना (स्ट्रिंग, सरणी, ऑब्जेक्ट) है। डिफ़ॉल्ट मान गलत है।
टैबनाम - टैब या टैब का नाम (यदि नाम से समूह का उपयोग किया जाता है), जिसे घटना पर सूचित किया जाना चाहिए। डिफ़ॉल्ट मान स्थिर __SE __ है। GID - i.e. ईवेंट संदेश बिना किसी अपवाद के सभी टैब के लिए उड़ान भरता है।
कुछ उदाहरण:

 //     . __SE__.dispatchEvent( 'MyGlobalEvent' ); //     . __SE__.dispatchEvent( 'MyGlobalEvent' , { SomeField : 'SomeValue' } ); //       . __SE__.dispatchEvent( 'MyTargetedEvent' , false , 'TargetTabName' ); 

निष्कर्ष में

मुझे आशा है कि यह पुस्तकालय कुछ लोगों के लिए संगत समस्याओं को हल करने के लिए उपयोगी होगा, क्योंकि अगर मैंने इसे आधे साल पहले पकड़ा, तो मैं बहुत समय बचाऊंगा और अपनी बैसाखी बाइक का आविष्कार नहीं करूंगा। हां, इसे लागू करने की तुलना में इसे बहुत अलग तरीके से लागू किया जाता है, लेकिन आप हमेशा बेहतर कर सकते हैं। है न?

अगर किसी को लोकलस्टोरेज में कॉन्फ़िगरेशन ऑब्जेक्ट बनाने में दिलचस्पी है, तो कृपया:

 JSON.parse( localStorage[ '__SE__' ] ); 

सामान्य तौर पर, मैं जनता को और ओपनसोर्स समुदाय को सब कुछ देता हूं अगर कोई मानता है कि पुस्तकालय आगे विकास या सुधार / संशोधन के योग्य है। इसलिए, मैं GitHub के लिंक को फिर से डुप्लिकेट करूंगा।

इसके लिए मैंने प्रस्थान करने की जल्दबाजी की। :-)