Server-side tagging APIs

  const 
  
 addEventCallback 
  
 = 
  
 require 
 ( 
 'addEventCallback' 
 ); 
 addEventCallback 
 (( 
 containerId 
 , 
  
 eventData 
 ) 
  
 = 
>  
 { 
  
 // Take some action based on the event data. 
 }); 
 

  const 
  
 addEventCallback 
  
 = 
  
 require 
 ( 
 'addEventCallback' 
 ); 
 const 
  
 claimRequest 
  
 = 
  
 require 
 ( 
 'claimRequest' 
 ); 
 const 
  
 extractEventsFromMpv1 
  
 = 
  
 require 
 ( 
 'extractEventsFromMpv1' 
 ); 
 const 
  
 logToConsole 
  
 = 
  
 require 
 ( 
 'logToConsole' 
 ); 
 const 
  
 returnResponse 
  
 = 
  
 require 
 ( 
 'returnResponse' 
 ); 
 const 
  
 runContainer 
  
 = 
  
 require 
 ( 
 'runContainer' 
 ); 
 claimRequest 
 (); 
 const 
  
 events 
  
 = 
  
 extractEventsFromMpv1 
 (); 
 let 
  
 eventsCompleted 
  
 = 
  
 0 
 ; 
 events 
 . 
 forEach 
 (( 
 evt 
 , 
  
 i 
 ) 
  
 = 
>  
 { 
  
 runContainer 
 ( 
 evt 
 , 
  
 /* onComplete= */ 
  
 ( 
 bindToEvent 
 ) 
  
 = 
>  
 { 
  
 bindToEvent 
 ( 
 addEventCallback 
 )(( 
 containerId 
 , 
  
 eventData 
 ) 
  
 = 
>  
 { 
  
 logToConsole 
 ( 
 'Event Number: ' 
  
 + 
  
 i 
 ); 
  
 eventData 
 . 
 tags 
 . 
 forEach 
 (( 
 tag 
 ) 
  
 = 
>  
 { 
  
 logToConsole 
 ( 
 'Tag ID: ' 
  
 + 
  
 tag 
 . 
 id 
 ); 
  
 logToConsole 
 ( 
 'Tag Status: ' 
  
 + 
  
 tag 
 . 
 status 
 ); 
  
 logToConsole 
 ( 
 'Tag Execution Time: ' 
  
 + 
  
 tag 
 . 
 executionTime 
 ); 
  
 }); 
  
 }); 
  
 if 
  
 ( 
 events 
 . 
 length 
  
 === 
  
 ++ 
 eventsCompleted 
 ) 
  
 { 
  
 returnResponse 
 (); 
  
 } 
  
 }); 
 }); 
 

  const 
  
 addEventCallback 
  
 = 
  
 require 
 ( 
 'addEventCallback' 
 ); 
 addEventCallback 
 (( 
 containerId 
 , 
  
 eventData 
 ) 
  
 = 
>  
 { 
  
 // This will be called at the end of the current event. 
 }); 
 

  const 
  
 callLater 
  
 = 
  
 require 
 ( 
 'callLater' 
 ); 
 const 
  
 logToConsole 
  
 = 
  
 require 
 ( 
 'logToConsole' 
 ); 
 callLater 
 (() 
  
 = 
>  
 { 
  
 logToConsole 
 ( 
 'Logged asynchronously' 
 ); 
 }); 
 

  const 
  
 claimRequest 
  
 = 
  
 require 
 ( 
 'claimRequest' 
 ); 
 claimRequest 
 (); 
 

  claimRequest 
 (); 
 

  const 
  
 computeEffectiveTldPlusOne 
  
 = 
  
 require 
 ( 
 'computeEffectiveTldPlusOne' 
 ); 
 // Returns 'example.co.uk' 
 computeEffectiveTldPlusOne 
 ( 
 'analytics.example.co.uk' 
 ); 
 // Returns 'example.co.uk' 
 computeEffectiveTldPlusOne 
 ( 
 'https://analytics.example.co.uk/path' 
 ); 
 

  computeEffectiveTldPlusOne 
 ( 
 domainOrUrl 
 ); 
 

  const 
  
 createRegex 
  
 = 
  
 require 
 ( 
 'createRegex' 
 ); 
 const 
  
 domainRegex 
  
 = 
  
 createRegex 
 ( 
 '\\w+\\.com' 
 , 
  
 'i' 
 ); 
 // Returns '/foobar' 
 'example.com/foobar' 
 . 
 replace 
 ( 
 domainRegex 
 , 
  
 '' 
 ); 
 

  createRegex 
 ( 
 pattern 
 , 
  
 flags 
 ); 
 

  const 
  
 decodeUri 
  
 = 
  
 require 
 ( 
 'decodeUri' 
 ); 
 const 
  
 decodedUrl 
  
 = 
  
 decodeUri 
 ( 
 data 
 . 
 encodedUrl 
 ); 
 if 
  
 ( 
 decodedUrl 
 ) 
  
 { 
  
 // ... 
 } 
 

  decodeUri 
 ( 
 encoded_uri 
 ); 
 

  const 
  
 decodeUriComponent 
  
 = 
  
 require 
 ( 
 'decodeUriComponent' 
 ); 
 const 
  
 decodedQuery 
  
 = 
  
 decodeUriComponent 
 ( 
 data 
 . 
 query 
 ); 
 if 
  
 ( 
 decodedQuery 
 ) 
  
 { 
  
 // ... 
 } 
 

  decodeUriComponent 
 ( 
 encoded_uri_component 
 ); 
 

  const 
  
 encodeUri 
  
 = 
  
 require 
 ( 
 'encodeUri' 
 ); 
 const 
  
 sendHttpGet 
  
 = 
  
 require 
 ( 
 'sendHttpGet' 
 ); 
 sendHttpGet 
 ( 
 'https://www.example.com/' 
  
 + 
  
 encodeUri 
 ( 
 pathInput 
 )); 
 

  encodeUri 
 ( 
 uri 
 ); 
 

  const 
  
 encodeUriComponent 
  
 = 
  
 require 
 ( 
 'encodeUriComponent' 
 ); 
 const 
  
 sendHttpGet 
  
 = 
  
 require 
 ( 
 'sendHttpGet' 
 ); 
 sendHttpGet 
 ( 
 'https://www.example.com/?' 
  
 + 
  
 encodeUriComponent 
 ( 
 queryInput 
 )); 
 

  encodeUriComponent 
 ( 
 str 
 ); 
 

  const 
  
 extractEventsFromMpv1 
  
 = 
  
 require 
 ( 
 'extractEventsFromMpv1' 
 ); 
 const 
  
 isRequestMpv1 
  
 = 
  
 require 
 ( 
 'isRequestMpv1' 
 ); 
 if 
  
 ( 
 isRequestMpv1 
 ()) 
  
 { 
  
 const 
  
 events 
  
 = 
  
 extractEventsFromMpv1 
 (); 
  
 for 
  
 ( 
 let 
  
 i 
  
 = 
  
 0 
 ; 
  
 i 
 < 
 events 
 . 
 length 
 ; 
  
 ++ 
 i 
 ) 
  
 { 
  
 const 
  
 event 
  
 = 
  
 events 
 [ 
 i 
 ]; 
  
 // Process event. 
  
 } 
 } 
 

  extractEventsFromMpv1 
 (); 
 

  const 
  
 extractEventsFromMpv2 
  
 = 
  
 require 
 ( 
 'extractEventsFromMpv2' 
 ); 
 const 
  
 isRequestMpv2 
  
 = 
  
 require 
 ( 
 'isRequestMpv2' 
 ); 
 if 
  
 ( 
 isRequestMpv2 
 ()) 
  
 { 
  
 const 
  
 events 
  
 = 
  
 extractEventsFromMpv2 
 (); 
  
 for 
  
 ( 
 let 
  
 i 
  
 = 
  
 0 
 ; 
  
 i 
 < 
 events 
 . 
 length 
 ; 
  
 ++ 
 i 
 ) 
  
 { 
  
 const 
  
 event 
  
 = 
  
 events 
 [ 
 i 
 ]; 
  
 // Process event. 
  
 } 
 } 
 

  extractEventsFromMpv2 
 (); 
 

 fromBase64(base64EncodedString); 

  const 
  
 fromBase64 
  
 = 
  
 require 
 ( 
 'fromBase64' 
 ); 
 const 
  
 greeting 
  
 = 
  
 fromBase64 
 ( 
 'aGVsbG8=' 
 ); 
 if 
  
 ( 
 greeting 
  
 === 
  
 'hello' 
 ) 
  
 { 
  
 // ... 
 } 
 

  const 
  
 generateRandom 
  
 = 
  
 require 
 ( 
 'generateRandom' 
 ); 
 const 
  
 randomValue 
  
 = 
  
 generateRandom 
 ( 
 0 
 , 
  
 10000000 
 ); 
 

  generateRandom 
 ( 
 min 
 , 
  
 max 
 ); 
 

  getAllEventData 
 (); 
 

  getClientName 
 (); 
 

  { 
  
 containerId 
 : 
  
 string 
 , 
  
 debugMode 
 : 
  
 boolean 
 , 
  
 environmentName 
 : 
  
 string 
 , 
  
 environmentMode 
 : 
  
 boolean 
 , 
  
 previewMode 
 : 
  
 boolean 
 , 
  
 version 
 : 
  
 string 
 , 
 } 
 

  const 
  
 getContainerVersion 
  
 = 
  
 require 
 ( 
 'getContainerVersion' 
 ); 
 const 
  
 containerVersion 
  
 = 
  
 getContainerVersion 
 (); 
 const 
  
 containerId 
  
 = 
  
 containerVersion 
 [ 
 'containerId' 
 ]; 
 const 
  
 isDebug 
  
 = 
  
 containerVersion 
 [ 
 'debugMode' 
 ]; 
 

  getContainerVersion 
 (); 
 

  const 
  
 getCookieValues 
  
 = 
  
 require 
 ( 
 'getCookieValues' 
 ); 
 const 
  
 lastVisit 
  
 = 
  
 getCookieValues 
 ( 
 'lastVisit' 
 )[ 
 0 
 ]; 
 if 
  
 ( 
 lastVisit 
 ) 
  
 { 
  
 // ... 
 } 
 

  getCookieValues 
 ( 
 name 
 [, 
  
 noDecode 
 ]); 
 

  const 
  
 getEventData 
  
 = 
  
 require 
 ( 
 'getEventData' 
 ); 
 const 
  
 campaignId 
  
 = 
  
 getEventData 
 ( 
 'campaign.id' 
 ); 
 const 
  
 itemId 
  
 = 
  
 getEventData 
 ( 
 'items.0.id' 
 ); 
 const 
  
 referrer 
  
 = 
  
 getEventData 
 ( 
 'page_referrer' 
 ); 
 

  getEventData 
 ( 
 keyPath 
 ); 
 

  const 
  
 getGoogleAuth 
  
 = 
  
 require 
 ( 
 'getGoogleAuth' 
 ); 
 const 
  
 logToConsole 
  
 = 
  
 require 
 ( 
 'logToConsole' 
 ); 
 const 
  
 sendHttpGet 
  
 = 
  
 require 
 ( 
 'sendHttpGet' 
 ); 
 const 
  
 auth 
  
 = 
  
 getGoogleAuth 
 ({ 
  
 scopes 
 : 
  
 [ 
 'https://www.googleapis.com/auth/datastore' 
 ] 
 }); 
 sendHttpGet 
 ( 
  
 'https://firestore.googleapis.com/v1/projects/my-project/databases/(default)/documents/collection/document' 
 , 
  
 { 
 authorization 
 : 
  
 auth 
 } 
 ). 
 then 
 (( 
 result 
 ) 
  
 = 
>  
 { 
  
 if 
  
 ( 
 result 
 . 
 statusCode 
  
> = 
  
 200 
 && 
 result 
 . 
 statusCode 
 < 
 300 
 ) 
  
 { 
  
 logToConsole 
 ( 
 'Result: ' 
  
 + 
  
 result 
 . 
 body 
 ); 
  
 data 
 . 
 gtmOnSuccess 
 (); 
  
 } 
  
 else 
  
 { 
  
 data 
 . 
 gtmOnFailure 
 (); 
  
 } 
 }); 
 

  getGoogleAuth 
 ( 
 scopes 
 ); 
 

  { 
  
 'cache-control' 
 : 
  
 string 
 , 
  
 'expires' 
 : 
  
 string 
 , 
  
 'last-modified' 
 : 
  
 string 
 , 
 } 
 

  const 
  
 getGoogleScript 
  
 = 
  
 require 
 ( 
 'getGoogleScript' 
 ); 
 getGoogleScript 
 ( 
 'ANALYTICS' 
 ). 
 then 
 (( 
 result 
 ) 
  
 = 
>  
 { 
  
 // Operate on result.script and result.metadata here. 
 }); 
 

  getGoogleScript 
 ( 
 script 
 [, 
  
 options 
 ]); 
 

  getRemoteAddress 
 (); 
 

  getRequestBody 
 (); 
 

  const 
  
 getRequestHeader 
  
 = 
  
 require 
 ( 
 'getRequestHeader' 
 ); 
 const 
  
 host 
  
 = 
  
 getRequestHeader 
 ( 
 'host' 
 ); 
 

  getRequestHeader 
 ( 
 headerName 
 ); 
 

  const 
  
 getRequestMethod 
  
 = 
  
 require 
 ( 
 'getRequestMethod' 
 ); 
 if 
  
 ( 
 getRequestMethod 
 () 
  
 === 
  
 'POST' 
 ) 
  
 { 
  
 // Handle the POST request here. 
 } 
 

  getRequestMethod 
 (); 
 

  const 
  
 getRequestPath 
  
 = 
  
 require 
 ( 
 'getRequestPath' 
 ); 
 const 
  
 requestPath 
  
 = 
  
 getRequestPath 
 (); 
 if 
  
 ( 
 requestPath 
  
 === 
  
 '/' 
 ) 
  
 { 
  
 // Handle a request for the root path. 
 } 
 

  getRequestPath 
 (); 
 

  const 
  
 getRequestQueryParameter 
  
 = 
  
 require 
 ( 
 'getRequestQueryParameter' 
 ); 
 const 
  
 query 
  
 = 
  
 getRequestQueryParameter 
 ( 
 'query' 
 ); 
 if 
  
 ( 
 query 
 ) 
  
 { 
  
 // Process query here. 
 } 
 

  getRequestQueryParameter 
 ( 
 name 
 ); 
 

  const 
  
 getRequestQueryParameters 
  
 = 
  
 require 
 ( 
 'getRequestQueryParameters' 
 ); 
 const 
  
 queryParameters 
  
 = 
  
 getRequestQueryParameters 
 (); 
 if 
  
 ( 
 queryParameters 
 [ 
 'search' 
 ]) 
  
 { 
  
 // Handle the search query here. 
  
 const 
  
 maxResults 
  
 = 
  
 queryParameters 
 [ 
 'max_results' 
 ]; 
 } 
 

  getRequestQueryParameters 
 (); 
 

  const 
  
 getRequestQueryString 
  
 = 
  
 require 
 ( 
 'getRequestQueryString' 
 ); 
 const 
  
 queryString 
  
 = 
  
 getRequestQueryString 
 (); 
 if 
  
 ( 
 queryString 
  
 !== 
  
 '' 
 ) 
  
 { 
  
 // Handle the query string. 
 } 
 

  getRequestQueryString 
 (); 
 

  getTimestamp 
 (); 
 

  getTimestampMillis 
 (); 
 

  const 
  
 getType 
  
 = 
  
 require 
 ( 
 'getType' 
 ); 
 const 
  
 type 
  
 = 
  
 getType 
 ( 
 value 
 ); 
 if 
  
 ( 
 type 
  
 === 
  
 'string' 
 ) 
  
 { 
  
 // Handle string input. 
 } 
  
 else 
  
 if 
  
 ( 
 type 
  
 === 
  
 'number' 
 ) 
  
 { 
  
 // Handle numeric input. 
 } 
  
 else 
  
 { 
  
 logToConsole 
 ( 
 'Unsupported input type: ' 
 , 
  
 type 
 ); 
 } 
 

  getType 
 ( 
 value 
 ); 
 

  { 
  
 "keys" 
 : 
  
 { 
  
 "key1" 
 : 
  
 "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5" 
 , 
  
 "key2" 
 : 
  
 "OTg3NjU0MzIxMHp5eHd2dXRzcnFwb25tbGtqaWhnZmVkY2Jh" 
 , 
  
 ... 
  
 } 
 } 
 

  const 
  
 hmacSha256 
  
 = 
  
 require 
 ( 
 'hmacSha256' 
 ); 
 const 
  
 toBase64 
  
 = 
  
 require 
 ( 
 'toBase64' 
 ); 
 const 
  
 header 
  
 = 
  
 toBase64 
 ( 
 '{"alg":"HS256","typ":"JWT"}' 
 , 
  
 { 
 urlEncoding 
 : 
  
 true 
 }); 
 const 
  
 claim 
  
 = 
  
 toBase64 
 ( 
 '{"sub":"1234567890","iat":1698164946}' 
 , 
  
 { 
 urlEncoding 
 : 
  
 true 
 }); 
 const 
  
 signature 
  
 = 
  
 hmacSha256 
 ( 
 header 
  
 + 
  
 '.' 
  
 + 
  
 claim 
 , 
  
 'key1' 
 ); 
 const 
  
 jwt 
  
 = 
  
 header 
  
 + 
  
 "." 
  
 + 
  
 claim 
  
 + 
  
 '.' 
  
 + 
  
 signature 
 ; 
 

  hmacSha256 
 ( 
 data 
 , 
  
 keyId 
 , 
  
 options 
 ) 
 

  const 
  
 isRequestMpv1 
  
 = 
  
 require 
 ( 
 'isRequestMpv1' 
 ); 
 if 
  
 ( 
 isRequestMpv1 
 ()) 
  
 { 
  
 // Handle Measurement Protocol V1 request. 
  
 const 
  
 events 
  
 = 
  
 extractEventsFromMpv1 
 (); 
 } 
 

  isRequestMpv1 
 (); 
 

  const 
  
 isRequestMpv2 
  
 = 
  
 require 
 ( 
 'isRequestMpv2' 
 ); 
 if 
  
 ( 
 isRequestMpv2 
 ()) 
  
 { 
  
 // Handle Measurement Protocol V2 request. 
  
 const 
  
 events 
  
 = 
  
 extractEventsFromMpv2 
 (); 
 } 
 

  isRequestMpv2 
 (); 
 

  const 
  
 logToConsole 
  
 = 
  
 require 
 ( 
 'logToConsole' 
 ); 
 const 
  
 that 
  
 = 
  
 123 
 ; 
 const 
  
 those 
  
 = 
  
 { 
  
 ... 
  
 }; 
 logToConsole 
 ( 
 'that is: ' 
 , 
  
 that 
 , 
  
 ' and those is: ' 
 , 
  
 those 
 ); 
 

  logToConsole 
 ( 
 argument1 
 [, 
  
 argument2 
 , 
  
 ...]); 
 

  makeInteger 
 ( 
 value 
 ); 
 

  makeNumber 
 ( 
 value 
 ); 
 

  makeString 
 ( 
 value 
 ); 
 

  [ 
  
 { 
 'key' 
 : 
  
 'k1' 
 , 
  
 'value' 
 : 
  
 'v1' 
 }, 
  
 { 
 'key' 
 : 
  
 'k2' 
 , 
  
 'value' 
 : 
  
 'v2' 
 } 
 ] 
 

  { 
  
 'k1' 
 : 
  
 'v1' 
 , 
  
 'k2' 
 : 
  
 'v2' 
 } 
 

  makeTableMap 
 ( 
 tableObj 
 , 
  
 keyColumnName 
 , 
  
 valueColumnName 
 ); 
 

  { 
  
 href 
 : 
  
 string 
 , 
  
 origin 
 : 
  
 string 
 , 
  
 protocol 
 : 
  
 string 
 , 
  
 username 
 : 
  
 string 
 , 
  
 password 
 : 
  
 string 
 , 
  
 host 
 : 
  
 string 
 , 
  
 hostname 
 : 
  
 string 
 , 
  
 port 
 : 
  
 string 
 , 
  
 pathname 
 : 
  
 string 
 , 
  
 search 
 : 
  
 string 
 , 
  
 searchParams 
 : 
  
 Object<string 
 , 
  
 ( 
 string 
 | 
 Array 
 )>, 
  
 hash 
 : 
  
 string 
 , 
 } 
 

  const 
  
 parseUrl 
  
 = 
  
 require 
 ( 
 'parseUrl' 
 ); 
 const 
  
 urlObject 
  
 = 
  
 parseUrl 
 ( 
 'https://abc:xyz@example.com:8080/foo?param=val%2Cue#bar' 
 ); 
 

  parseUrl 
 ( 
 url 
 ); 
 

  returnResponse 
 (); 
 

  const 
  
 returnResponse 
  
 = 
  
 require 
 ( 
 'returnResponse' 
 ); 
 const 
  
 runContainer 
  
 = 
  
 require 
 ( 
 'runContainer' 
 ); 
 // Runs the container with a simple pageview event and then returns a response. 
 runContainer 
 ({ 
 'event_name' 
 : 
  
 'pageview' 
 }, 
  
 () 
  
 = 
>  
 returnResponse 
 ()); 
 

  runContainer 
 ( 
 event 
 , 
  
 onComplete 
 , 
  
 onStart 
 ); 
 

  const 
  
 logToConsole 
  
 = 
  
 require 
 ( 
 'logToConsole' 
 ); 
 const 
  
 sendEventToGoogleAnalytics 
  
 = 
  
 require 
 ( 
 'sendEventToGoogleAnalytics' 
 ); 
 const 
  
 setResponseHeader 
  
 = 
  
 require 
 ( 
 'setResponseHeader' 
 ); 
 const 
  
 setResponseStatus 
  
 = 
  
 require 
 ( 
 'setResponseStatus' 
 ); 
 // Sends an event to Google Analytics and returns failure if the request did not 
 // succeed. Additionally, if the request resulted in a redirect request, the 
 // code nominates a redirect response to be returned. 
 sendEventToGoogleAnalytics 
 ( 
 event 
 ). 
 then 
 (( 
 response 
 ) 
  
 = 
>  
 { 
  
 if 
  
 ( 
 response 
 . 
 location 
 ) 
  
 { 
  
 setResponseHeader 
 ( 
 'location' 
 , 
  
 response 
 . 
 location 
 ); 
  
 setResponseStatus 
 ( 
 302 
 ); 
  
 } 
  
 else 
  
 { 
  
 setResponseStatus 
 ( 
 200 
 ); 
  
 } 
  
 data 
 . 
 gtmOnSuccess 
 (); 
 }). 
 catch 
 (( 
 error 
 ) 
  
 = 
>  
 { 
  
 logToConsole 
 ( 
 error 
 . 
 reason 
 ); 
  
 setResponseStatus 
 ( 
 500 
 ); 
  
 data 
 . 
 gtmOnFailure 
 (); 
 }); 
 

  sendEventToGoogleAnalytics 
 ( 
 event 
 ); 
 

  const 
  
 sendHttpGet 
  
 = 
  
 require 
 ( 
 'sendHttpGet' 
 ); 
 // Returns the response body as the value for a variable. 
 return 
  
 sendHttpGet 
 ( 
 'https://example.com/item/' 
  
 + 
  
 data 
 . 
 itemId 
 , 
  
 { 
  
 headers 
 : 
  
 { 
 key 
 : 
  
 'value' 
 }, 
  
 timeout 
 : 
  
 500 
 , 
 }). 
 then 
 (( 
 result 
 ) 
  
 = 
>  
 result 
 . 
 body 
 , 
  
 () 
  
 = 
>  
 undefined 
 ); 
 

  sendHttpGet 
 ( 
 url 
 [, 
  
 options 
 ]); 
 

  const 
  
 sendHttpRequest 
  
 = 
  
 require 
 ( 
 'sendHttpRequest' 
 ); 
 const 
  
 setResponseBody 
  
 = 
  
 require 
 ( 
 'setResponseBody' 
 ); 
 const 
  
 setResponseHeader 
  
 = 
  
 require 
 ( 
 'setResponseHeader' 
 ); 
 const 
  
 setResponseStatus 
  
 = 
  
 require 
 ( 
 'setResponseStatus' 
 ); 
 const 
  
 postBody 
  
 = 
  
 'interaction=click&campaign=promotion&medium=email' 
 ; 
 // Sends a POST request and nominates response based on the response to the POST 
 // request. 
 sendHttpRequest 
 ( 
 'https://example.com/collect' 
 , 
  
 { 
  
 headers 
 : 
  
 { 
 key 
 : 
  
 'value' 
 }, 
  
 method 
 : 
  
 'POST' 
 , 
  
 timeout 
 : 
  
 500 
 , 
 }, 
  
 postBody 
 ). 
 then 
 (( 
 result 
 ) 
  
 = 
>  
 { 
  
 setResponseStatus 
 ( 
 result 
 . 
 statusCode 
 ); 
  
 setResponseBody 
 ( 
 result 
 . 
 body 
 ); 
  
 setResponseHeader 
 ( 
 'cache-control' 
 , 
  
 result 
 . 
 headers 
 [ 
 'cache-control' 
 ]); 
 }); 
 

  sendHttpRequest 
 ( 
 url 
 [, 
  
 options 
 [, 
  
 body 
 ]]); 
 

  const 
  
 sendPixelFromBrowser 
  
 = 
  
 require 
 ( 
 'sendPixelFromBrowser' 
 ); 
 sendPixelFromBrowser 
 ( 
 'https://example.com/?id=123' 
 ); 
 

  const 
  
 setCookie 
  
 = 
  
 require 
 ( 
 'setCookie' 
 ); 
 // Sets an httpOnly cookie with a max-age of 3600. 
 setCookie 
 ( 
 'cookieName' 
 , 
  
 'cookieValue' 
 , 
  
 { 
 'max-age' 
 : 
  
 3600 
 , 
  
 httpOnly 
 : 
  
 true 
 }); 
 

  setCookie 
 ( 
 name 
 , 
  
 value 
 [, 
  
 options 
 [, 
  
 noEncode 
 ]]); 
 

  setPixelResponse 
 (); 
 

  setResponseBody 
 ( 
 body 
 [, 
  
 encoding 
 ]); 
 

  setResponseHeader 
 ( 
 name 
 , 
  
 value 
 ); 
 

  setResponseStatus 
 ( 
 statusCode 
 ); 
 

  const 
  
 encodeUriComponent 
  
 = 
  
 require 
 ( 
 'encodeUriComponent' 
 ); 
 const 
  
 sendHttpGet 
  
 = 
  
 require 
 ( 
 'sendHttpGet' 
 ); 
 const 
  
 sha256 
  
 = 
  
 require 
 ( 
 'sha256' 
 ); 
 sha256 
 ( 
 'inputString' 
 , 
  
 ( 
 digest 
 ) 
  
 = 
>  
 { 
  
 sendHttpGet 
 ( 
 'https://example.com/collect?id=' 
  
 + 
  
 encodeUriComponent 
 ( 
 digest 
 )); 
 }); 
 sha256 
 ( 
 'inputString' 
 , 
  
 ( 
 digest 
 ) 
  
 = 
>  
 { 
  
 sendHttpGet 
 ( 
 'https://example.com/collect?id=' 
  
 + 
  
 encodeUriComponent 
 ( 
 digest 
 )); 
 }, 
  
 { 
 outputEncoding 
 : 
  
 'hex' 
 }); 
 

  sha256 
 ( 
 input 
 , 
  
 onSuccess 
 , 
  
 options 
  
 = 
  
 undefined 
 ); 
 

  const 
  
 encodeUriComponent 
  
 = 
  
 require 
 ( 
 'encodeUriComponent' 
 ); 
 const 
  
 sendHttpGet 
  
 = 
  
 require 
 ( 
 'sendHttpGet' 
 ); 
 const 
  
 sha256Sync 
  
 = 
  
 require 
 ( 
 'sha256Sync' 
 ); 
 const 
  
 digestBase64 
  
 = 
  
 sha256Sync 
 ( 
 'inputString' 
 ); 
 const 
  
 digestHex 
  
 = 
  
 sha256Sync 
 ( 
 'inputString' 
 , 
  
 { 
 outputEncoding 
 : 
  
 'hex' 
 }); 
 sendHttpGet 
 ( 
 'https://example.com/collect?id=' 
  
 + 
  
 encodeUriComponent 
 ( 
 digestBase64 
 )); 
 sendHttpGet 
 ( 
 'https://example.com/collect?id=' 
  
 + 
  
 encodeUriComponent 
 ( 
 digestHex 
 )); 
 

  sha256Sync 
 ( 
 input 
 , 
  
 options 
  
 = 
  
 undefined 
 ); 
 

  const 
  
 templateDataStorage 
  
 = 
  
 require 
 ( 
 'templateDataStorage' 
 ); 
 // Returns a copy of the value stored for the given key, or null if nothing 
 // is stored with that key. 
 templateDataStorage 
 . 
 getItemCopy 
 ( 
 key 
 ); 
 // Stores a copy of the value for the given key (or removes the data stored 
 // for the given key if the input value is null). 
 templateDataStorage 
 . 
 setItemCopy 
 ( 
 key 
 , 
  
 value 
 ); 
 // Removes the value stored for the given key, if present. 
 templateDataStorage 
 . 
 removeItem 
 ( 
 key 
 ); 
 // Deletes all values stored for the current template. 
 templateDataStorage 
 . 
 clear 
 (); 
 

  const 
  
 sendHttpGet 
  
 = 
  
 require 
 ( 
 'sendHttpGet' 
 ); 
 const 
  
 setResponseBody 
  
 = 
  
 require 
 ( 
 'setResponseBody' 
 ); 
 const 
  
 setResponseStatus 
  
 = 
  
 require 
 ( 
 'setResponseStatus' 
 ); 
 const 
  
 templateDataStorage 
  
 = 
  
 require 
 ( 
 'templateDataStorage' 
 ); 
 // Check to see if the item is in the cache. 
 const 
  
 cachedBody 
  
 = 
  
 templateDataStorage 
 . 
 getItemCopy 
 ( 
 data 
 . 
 key 
 ); 
 if 
  
 ( 
 cachedBody 
 ) 
  
 { 
  
 setResponseBody 
 ( 
 cachedBody 
 ); 
  
 data 
 . 
 gtmOnSuccess 
 (); 
  
 return 
 ; 
 } 
 sendHttpGet 
 ( 
 data 
 . 
 url 
 ). 
 then 
 (( 
 result 
 ) 
  
 = 
>  
 { 
  
 if 
  
 ( 
 result 
 . 
 statusCode 
  
> = 
  
 200 
 && 
 result 
 . 
 statusCode 
 < 
 300 
 ) 
  
 { 
  
 setResponseBody 
 ( 
 result 
 . 
 body 
 ); 
  
 templateDataStorage 
 . 
 setItemCopy 
 ( 
 data 
 . 
 key 
 , 
  
 result 
 . 
 body 
 ); 
  
 data 
 . 
 gtmOnSuccess 
 (); 
  
 } 
  
 else 
  
 { 
  
 data 
 . 
 gtmOnFailure 
 (); 
  
 } 
  
 setResponseStatus 
 ( 
 result 
 . 
 statusCode 
 ); 
 }); 
 

  const 
  
 createRegex 
  
 = 
  
 require 
 ( 
 'createRegex' 
 ); 
 const 
  
 testRegex 
  
 = 
  
 require 
 ( 
 'testRegex' 
 ); 
 const 
  
 domainRegex 
  
 = 
  
 createRegex 
 ( 
 '\\w+\\.com' 
 , 
  
 'i' 
 ); 
 // createRegex returns null if the regex is invalid or Re2 is not available. 
 if 
  
 ( 
 domainRegex 
  
 === 
  
 null 
 ) 
  
 return 
 ; 
 // Returns true 
 testRegex 
 ( 
 domainRegex 
 , 
  
 'example.com/foobar' 
 ); 
 

  testRegex 
 ( 
 regex 
 , 
  
 string 
 ); 
 

  toBase64 
 ( 
 input 
 , 
  
 options 
 ); 
 

  const 
  
 toBase64 
  
 = 
  
 require 
 ( 
 'toBase64' 
 ); 
 const 
  
 base64Hello 
  
 = 
  
 toBase64 
 ( 
 'hello' 
 ); 
 const 
  
 base64UrlHello 
  
 = 
  
 toBase64 
 ( 
 'hello' 
 , 
  
 { 
 urlEncoding 
 : 
  
 true 
 }); 
 

  BigQuery 
 . 
 insert 
 ( 
 connectionInfo 
 , 
  
 rows 
 [, 
  
 options 
 ]); 
 

  [{ 
 reason 
 : 
  
 'invalid' 
 }] 
 

  [ 
  
 { 
  
 "errors" 
 : 
  
 [ 
  
 { 
  
 "reason" 
 : 
 "invalid" 
  
 } 
  
 ], 
  
 "row" 
 : 
  
 { 
  
 "string_col" 
 : 
 "otherString" 
 , 
  
 "number_col" 
 :- 
 3 
 , 
  
 "bool_col" 
 : 
 3 
  
 } 
  
 }, 
  
 { 
  
 "errors" 
 : 
  
 [ 
  
 { 
  
 "reason" 
 : 
 "stopped" 
  
 } 
  
 ], 
  
 "row" 
 : 
  
 { 
  
 "string_col" 
 : 
 "stringValue" 
 , 
  
 "number_col" 
 : 
 5 
 , 
  
 " 
 bool_col 
 : 
 false 
  
 } 
  
 } 
 ] 
 

  const 
  
 BigQuery 
  
 = 
  
 require 
 ( 
 'BigQuery' 
 ); 
 const 
  
 connectionInfo 
  
 = 
  
 { 
  
 'projectId' 
 : 
  
 'gcp-cloud-project-id' 
 , 
  
 'datasetId' 
 : 
  
 'destination-dataset' 
 , 
  
 'tableId' 
 : 
  
 'destination-table' 
 , 
 }; 
 const 
  
 rows 
  
 = 
  
 [{ 
  
 'column1' 
 : 
  
 'String1' 
 , 
  
 'column2' 
 : 
  
 1234 
 , 
 }]; 
 const 
  
 options 
  
 = 
  
 { 
  
 'ignoreUnknownValues' 
 : 
  
 true 
 , 
  
 'skipInvalidRows' 
 : 
  
 false 
 , 
 }; 
 BigQuery 
 . 
 insert 
 ( 
 connectionInfo 
 , 
  
 rows 
 , 
  
 options 
 ) 
  
 . 
 then 
 ( 
 data 
 . 
 gtmOnSuccess 
 , 
  
 data 
 . 
 gtmOnFailure 
 ); 
 

  Firestore 
 . 
 read 
 ( 
 path 
 [, 
  
 options 
 ]); 
 

  const 
  
 Firestore 
  
 = 
  
 require 
 ( 
 'Firestore' 
 ); 
 return 
  
 Firestore 
 . 
 read 
 ( 
 'collection/document' 
 , 
  
 { 
  
 projectId 
 : 
  
 'gcp-cloud-project-id' 
 , 
 }). 
 then 
 (( 
 result 
 ) 
  
 = 
>  
 result 
 . 
 data 
 . 
 key 
 , 
  
 () 
  
 = 
>  
 undefined 
 ); 
 

  Firestore 
 . 
 write 
 ( 
 path 
 , 
  
 input 
 [, 
  
 options 
 ]); 
 

  const 
  
 Firestore 
  
 = 
  
 require 
 ( 
 'Firestore' 
 ); 
 const 
  
 input 
  
 = 
  
 { 
 key1 
 : 
  
 'value1' 
 , 
  
 key2 
 : 
  
 12345 
 }; 
 Firestore 
 . 
 write 
 ( 
 'collection/document' 
 , 
  
 input 
 , 
  
 { 
  
 projectId 
 : 
  
 'gcp-cloud-project-id' 
 , 
  
 merge 
 : 
  
 true 
 , 
 }). 
 then 
 (( 
 id 
 ) 
  
 = 
>  
 { 
  
 data 
 . 
 gtmOnSuccess 
 (); 
 }, 
  
 data 
 . 
 gtmOnFailure 
 ); 
 

  Firestore 
 . 
 query 
 ( 
 collection 
 , 
  
 queryConditions 
 [, 
  
 options 
 ]); 
 

  const 
  
 Firestore 
  
 = 
  
 require 
 ( 
 'Firestore' 
 ); 
 const 
  
 queries 
  
 = 
  
 const 
  
 queries 
  
 = 
  
 [[ 
 'id' 
 , 
  
 '==' 
 , 
  
 '5' 
 ]]; 
 return 
  
 Firestore 
 . 
 query 
 ( 
 'collection' 
 , 
  
 queries 
 , 
  
 { 
  
 projectId 
 : 
  
 'gcp-cloud-project-id' 
 , 
  
 limit 
 : 
  
 1 
 , 
 }). 
 then 
 (( 
 documents 
 ) 
  
 = 
>  
 documents 
 [ 
 0 
 ]. 
 data 
 . 
 key 
 , 
  
 () 
  
 = 
>  
 undefined 
 ); 
 

  Firestore 
 . 
 runTransaction 
 ( 
 callback 
 [, 
  
 options 
 ]); 
 

  const 
  
 Firestore 
  
 = 
  
 require 
 ( 
 'Firestore' 
 ); 
 const 
  
 path 
  
 = 
  
 'collection/document' 
 ; 
 const 
  
 projectId 
  
 = 
  
 'gcp-cloud-project-id' 
 ; 
 Firestore 
 . 
 runTransaction 
 (( 
 transaction 
 ) 
  
 = 
>  
 { 
  
 const 
  
 transactionOptions 
  
 = 
  
 { 
  
 projectId 
 : 
  
 projectId 
 , 
  
 transaction 
 : 
  
 transaction 
 , 
  
 }; 
  
 // Must return a promise. 
  
 return 
  
 Firestore 
 . 
 read 
 ( 
 path 
 , 
  
 transactionOptions 
 ). 
 then 
 (( 
 result 
 ) 
  
 = 
>  
 { 
  
 const 
  
 newInputCount 
  
 = 
  
 result 
 . 
 data 
 . 
 inputCount 
  
 + 
  
 1 
 ; 
  
 const 
  
 input 
  
 = 
  
 { 
 key1 
 : 
  
 'value1' 
 , 
  
 inputCount 
 : 
  
 newInputCount 
 }; 
  
 return 
  
 Firestore 
 . 
 write 
 ( 
 path 
 , 
  
 input 
 , 
  
 transactionOptions 
 ); 
  
 }); 
 }, 
  
 { 
  
 projectId 
 : 
  
 projectId 
 }). 
 then 
 (( 
 ids 
 ) 
  
 = 
>  
 { 
  
 data 
 . 
 gtmOnSuccess 
 (); 
 }, 
  
 data 
 . 
 gtmOnFailure 
 ); 
 

  Firestore 
 . 
 read 
 (...). 
 then 
 ( 
 onSuccess 
 , 
  
 ( 
 error 
 ) 
  
 = 
>  
 { 
  
 if 
  
 ( 
 error 
 . 
 reason 
  
 === 
  
 'unknown' 
 ) 
  
 { 
  
 // Handle the unknown error here. 
  
 } 
 }); 
 

  const 
  
 JSON 
  
 = 
  
 require 
 ( 
 'JSON' 
 ); 
 // The JSON input string is converted to an object. 
 const 
  
 object 
  
 = 
  
 JSON 
 . 
 parse 
 ( 
 '{"foo":"bar"}' 
 ); 
 // The input object is converted to a JSON string. 
 const 
  
 str 
  
 = 
  
 JSON 
 . 
 stringify 
 ({ 
 foo 
 : 
  
 'bar' 
 }); 
 

  JSON 
 . 
 parse 
 ( 
 stringInput 
 ); 
 JSON 
 . 
 stringify 
 ( 
 value 
 ); 
 

  const 
  
 Math 
  
 = 
  
 require 
 ( 
 'Math' 
 ); 
 // Retrieve the absolute value. 
 const 
  
 absolute 
  
 = 
  
 Math 
 . 
 abs 
 ( 
 - 
 3 
 ); 
 // Round the input down to the nearest integer. 
 const 
  
 roundedDown 
  
 = 
  
 Math 
 . 
 floor 
 ( 
 3.6 
 ); 
 // Round the input up to the nearest integer. 
 const 
  
 roundedUp 
  
 = 
  
 Math 
 . 
 ceil 
 ( 
 2.2 
 ); 
 // Round the input to the nearest integer. 
 const 
  
 rounded 
  
 = 
  
 Math 
 . 
 round 
 ( 
 3.1 
 ); 
 // Return the largest argument. 
 const 
  
 biggest 
  
 = 
  
 Math 
 . 
 max 
 ( 
 1 
 , 
  
 3 
 ); 
 // Return the smallest argument. 
 const 
  
 smallest 
  
 = 
  
 Math 
 . 
 min 
 ( 
 3 
 , 
  
 5 
 ); 
 // Return the first argument raised to the power of the second argument. 
 const 
  
 powerful 
  
 = 
  
 Math 
 . 
 pow 
 ( 
 3 
 , 
  
 1 
 ); 
 // Return the square root of the argument. 
 const 
  
 unsquared 
  
 = 
  
 Math 
 . 
 sqrt 
 ( 
 9 
 ); 
 

  const 
  
 addMessageListener 
  
 = 
  
 require 
 ( 
 'addMessageListener' 
 ); 
 addMessageListener 
 ( 
 'send_pixel' 
 , 
  
 ( 
 messageType 
 , 
  
 message 
 ) 
  
 = 
>  
 { 
  
 // This will be run whenever something sends a 'send_pixel' message. 
 }); 
 

  const 
  
 addMessageListener 
  
 = 
  
 require 
 ( 
 'addMessageListener' 
 ); 
 const 
  
 claimRequest 
  
 = 
  
 require 
 ( 
 'claimRequest' 
 ); 
 const 
  
 extractEventsFromMpv1 
  
 = 
  
 require 
 ( 
 'extractEventsFromMpv1' 
 ); 
 const 
  
 returnResponse 
  
 = 
  
 require 
 ( 
 'returnResponse' 
 ); 
 const 
  
 runContainer 
  
 = 
  
 require 
 ( 
 'runContainer' 
 ); 
 claimRequest 
 (); 
 addMessageListener 
 ( 
 'send_pixel' 
 , 
  
 ( 
 messageType 
 , 
  
 message 
 ) 
  
 = 
>  
 { 
  
 // This will be run whenever a tag sends a 'send_pixel' message. 
 }); 
 const 
  
 events 
  
 = 
  
 extractEventsFromMpv1 
 (); 
 let 
  
 eventsCompleted 
  
 = 
  
 0 
 ; 
 events 
 . 
 forEach 
 (( 
 event 
 , 
  
 i 
 ) 
  
 = 
>  
 { 
  
 runContainer 
 ( 
 events 
 [ 
 i 
 ], 
  
 /* onComplete= */ 
  
 () 
  
 = 
>  
 { 
  
 if 
  
 ( 
 events 
 . 
 length 
  
 === 
  
 ++ 
 eventsCompleted 
 ) 
  
 { 
  
 returnResponse 
 (); 
  
 } 
  
 }, 
  
 /* onStart= */ 
  
 ( 
 bindToEvent 
 ) 
  
 = 
>  
 { 
  
 if 
  
 ( 
 i 
  
 === 
  
 0 
 ) 
  
 { 
  
 bindToEvent 
 ( 
 addMessageListener 
 )( 
 'send_pixel' 
 , 
  
 ( 
 messageType 
 , 
  
 message 
 ) 
  
 = 
>  
 { 
  
 // This will be called whenever a tag for the first event sends a 
  
 // 'send_pixel' message. 
  
 }); 
  
 } 
  
 }); 
 }); 
 

  const 
  
 hasMessageListener 
  
 = 
  
 require 
 ( 
 'hasMessageListener' 
 ); 
 hasMessageListener 
 ( 
 'send_pixel' 
 ); 
 

  const 
  
 sendMessage 
  
 = 
  
 require 
 ( 
 'sendMessage' 
 ); 
 sendMessage 
 ( 
 'send_pixel' 
 , 
  
 { 
 url 
 : 
  
 'https://analytics.example.com/collect' 
 }); 
 

  Object 
 . 
 keys 
 ( 
 objectInput 
 ) 
 Object 
 . 
 values 
 ( 
 objectInput 
 ) 
 Object 
 . 
 entries 
 ( 
 objectInput 
 ) 
 Object 
 . 
 freeze 
 ( 
 objectInput 
 ) 
 Object 
 . 
 delete 
 ( 
 objectInput 
 , 
  
 keyToDelete 
 ) 
 

  const 
  
 Object 
  
 = 
  
 require 
 ( 
 'Object' 
 ); 
 // The keys of an object are enumerated in an array. 
 const 
  
 keys 
  
 = 
  
 Object 
 . 
 keys 
 ({ 
 foo 
 : 
  
 'bar' 
 }); 
 // The values of an object are enumerated in an array. 
 const 
  
 values 
  
 = 
  
 Object 
 . 
 values 
 ({ 
 foo 
 : 
  
 'bar' 
 }); 
 // The key/value pairs of an object are enumerated in an array. 
 const 
  
 entries 
  
 = 
  
 Object 
 . 
 entries 
 ({ 
 foo 
 : 
  
 'bar' 
 }); 
 // The input object is frozen. 
 const 
  
 frozen 
  
 = 
  
 Object 
 . 
 freeze 
 ({ 
 foo 
 : 
  
 'bar' 
 }); 
 // The key is removed from the input object. 
 const 
  
 obj1 
  
 = 
  
 { 
 deleteme 
 : 
  
 'value' 
 }; 
 Object 
 . 
 delete 
 ( 
 obj1 
 , 
  
 'deleteme' 
 ); 
 // Only a top-level key can be specified as the key to delete. 
 const 
  
 obj2 
  
 = 
  
 { 
 nested 
 : 
  
 { 
 key 
 : 
  
 'value' 
 }}; 
 Object 
 . 
 delete 
 ( 
 obj2 
 , 
  
 'nested.key' 
 ); 
  
 // This has no effect. 
 Object 
 . 
 delete 
 ( 
 obj2 
 . 
 nested 
 , 
  
 'key' 
 ); 
  
 // This deletes the nested key. 
 

  promise 
 . 
 then 
 (( 
 resolvedValue 
 ) 
  
 = 
>  
 { 
  
 // Handles when promise resolves. 
  
 }, 
  
 ( 
 rejectedValue 
 ) 
  
 = 
>  
 { 
  
 // Handles when promise rejects. 
  
 }); 
 promise 
 . 
 catch 
 (( 
 rejectedValue 
 ) 
  
 = 
>  
 { 
  
 // Handles when promise rejects. 
  
 }); 
 promise 
 . 
 finally 
 (() 
  
 = 
>  
 { 
  
 // Runs regardless of whether or not the previous promise resolves or 
  
 // rejects. 
  
 }); 
 

  Promise 
 . 
 all 
 ( 
 inputs 
 ); 
 

  const 
  
 Promise 
  
 = 
  
 require 
 ( 
 'Promise' 
 ); 
 const 
  
 sendHttpGet 
  
 = 
  
 require 
 ( 
 'sendHttpGet' 
 ); 
 return 
  
 Promise 
 . 
 all 
 ([ 
 'a' 
 , 
  
 sendHttpGet 
 ( 
 'https://example.com' 
 )]) 
  
 . 
 then 
 (( 
 results 
 ) 
  
 = 
>  
 { 
  
 // results will equal: ['a', {statusCode: 200, headers: {}, body: ''}] 
  
 }); 
 

  Promise 
 . 
 create 
 ( 
 resolver 
 ); 
 

  const 
  
 Promise 
  
 = 
  
 require 
 ( 
 'Promise' 
 ); 
 return 
  
 Promise 
 . 
 create 
 (( 
 resolve 
 , 
  
 reject 
 ) 
  
 = 
>  
 { 
  
 // Do asynchronous work that eventually calls resolve() or reject() 
 });