Project-Pro/doitinpoland.com
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Pyziak Jacek
2023-09-12 21:41:04 +02:00
commit 3361a7f053
13284 changed files with 2116755 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

475
wp-content/plugins/mailchimp-for-wp/assets/js/third-party/placeholders.js vendored Normal file
View File

@@ -0,0 +1,475 @@
(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
"use strict";
/* eslint-disable */
/*!
* The MIT License
*
* Copyright (c) 2012 James Allardice
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*/
(function (global) {
'use strict'; //
// Test for support. We do this as early as possible to optimise for browsers
// that have native support for the attribute.
//
var test = document.createElement('input');
var nativeSupport = test.placeholder !== void 0;
global.Placeholders = {
nativeSupport: nativeSupport,
disable: nativeSupport ? noop : disablePlaceholders,
enable: nativeSupport ? noop : enablePlaceholders
};
if (nativeSupport) {
return;
} //
// If we reach this point then the browser does not have native support for
// the attribute.
//
// The list of input element types that support the placeholder attribute.
var validTypes = ['text', 'search', 'url', 'tel', 'email', 'password', 'number', 'textarea']; // The list of keycodes that are not allowed when the polyfill is configured
// to hide-on-input.
var badKeys = [// The following keys all cause the caret to jump to the end of the input
// value.
27, // Escape
33, // Page up
34, // Page down
35, // End
36, // Home
// Arrow keys allow you to move the caret manually, which should be
// prevented when the placeholder is visible.
37, // Left
38, // Up
39, // Right
40, // Down
// The following keys allow you to modify the placeholder text by removing
// characters, which should be prevented when the placeholder is visible.
8, // Backspace
46 // Delete
]; // Styling variables.
var placeholderStyleColor = '#ccc';
var placeholderClassName = 'placeholdersjs';
var classNameRegExp = new RegExp('(?:^|\\s)' + placeholderClassName + '(?!\\S)'); // The various data-* attributes used by the polyfill.
var ATTR_CURRENT_VAL = 'data-placeholder-value';
var ATTR_ACTIVE = 'data-placeholder-active';
var ATTR_INPUT_TYPE = 'data-placeholder-type';
var ATTR_FORM_HANDLED = 'data-placeholder-submit';
var ATTR_EVENTS_BOUND = 'data-placeholder-bound';
var ATTR_OPTION_FOCUS = 'data-placeholder-focus';
var ATTR_OPTION_LIVE = 'data-placeholder-live';
var ATTR_MAXLENGTH = 'data-placeholder-maxlength'; // Various other variables used throughout the rest of the script.
var UPDATE_INTERVAL = 100;
var head = document.getElementsByTagName('head')[0];
var root = document.documentElement;
var Placeholders = global.Placeholders;
var keydownVal; // Get references to all the input and textarea elements currently in the DOM
// (live NodeList objects to we only need to do this once).
var inputs = document.getElementsByTagName('input');
var textareas = document.getElementsByTagName('textarea'); // Get any settings declared as data-* attributes on the root element.
// Currently the only options are whether to hide the placeholder on focus
// or input and whether to auto-update.
var hideOnInput = root.getAttribute(ATTR_OPTION_FOCUS) === 'false';
var liveUpdates = root.getAttribute(ATTR_OPTION_LIVE) !== 'false'; // Create style element for placeholder styles (instead of directly setting
// style properties on elements - allows for better flexibility alongside
// user-defined styles).
var styleElem = document.createElement('style');
styleElem.type = 'text/css'; // Create style rules as text node.
var styleRules = document.createTextNode('.' + placeholderClassName + ' {' + 'color:' + placeholderStyleColor + ';' + '}'); // Append style rules to newly created stylesheet.
if (styleElem.styleSheet) {
styleElem.styleSheet.cssText = styleRules.nodeValue;
} else {
styleElem.appendChild(styleRules);
} // Prepend new style element to the head (before any existing stylesheets,
// so user-defined rules take precedence).
head.insertBefore(styleElem, head.firstChild); // Set up the placeholders.
var placeholder;
var elem;
for (var i = 0, len = inputs.length + textareas.length; i < len; i++) {
// Find the next element. If we've already done all the inputs we move on
// to the textareas.
elem = i < inputs.length ? inputs[i] : textareas[i - inputs.length]; // Get the value of the placeholder attribute, if any. IE10 emulating IE7
// fails with getAttribute, hence the use of the attributes node.
placeholder = elem.attributes.placeholder; // If the element has a placeholder attribute we need to modify it.
if (placeholder) {
// IE returns an empty object instead of undefined if the attribute is
// not present.
placeholder = placeholder.nodeValue; // Only apply the polyfill if this element is of a type that supports
// placeholders and has a placeholder attribute with a non-empty value.
if (placeholder && inArray(validTypes, elem.type)) {
newElement(elem);
}
}
} // If enabled, the polyfill will repeatedly check for changed/added elements
// and apply to those as well.
var timer = setInterval(function () {
for (var i = 0, len = inputs.length + textareas.length; i < len; i++) {
elem = i < inputs.length ? inputs[i] : textareas[i - inputs.length]; // Only apply the polyfill if this element is of a type that supports
// placeholders, and has a placeholder attribute with a non-empty value.
placeholder = elem.attributes.placeholder;
if (placeholder) {
placeholder = placeholder.nodeValue;
if (placeholder && inArray(validTypes, elem.type)) {
// If the element hasn't had event handlers bound to it then add
// them.
if (!elem.getAttribute(ATTR_EVENTS_BOUND)) {
newElement(elem);
} // If the placeholder value has changed or not been initialised yet
// we need to update the display.
if (placeholder !== elem.getAttribute(ATTR_CURRENT_VAL) || elem.type === 'password' && !elem.getAttribute(ATTR_INPUT_TYPE)) {
// Attempt to change the type of password inputs (fails in IE < 9).
if (elem.type === 'password' && !elem.getAttribute(ATTR_INPUT_TYPE) && changeType(elem, 'text')) {
elem.setAttribute(ATTR_INPUT_TYPE, 'password');
} // If the placeholder value has changed and the placeholder is
// currently on display we need to change it.
if (elem.value === elem.getAttribute(ATTR_CURRENT_VAL)) {
elem.value = placeholder;
} // Keep a reference to the current placeholder value in case it
// changes via another script.
elem.setAttribute(ATTR_CURRENT_VAL, placeholder);
}
}
} else if (elem.getAttribute(ATTR_ACTIVE)) {
hidePlaceholder(elem);
elem.removeAttribute(ATTR_CURRENT_VAL);
}
} // If live updates are not enabled cancel the timer.
if (!liveUpdates) {
clearInterval(timer);
}
}, UPDATE_INTERVAL); // Disabling placeholders before unloading the page prevents flash of
// unstyled placeholders on load if the page was refreshed.
addEventListener(global, 'beforeunload', function () {
Placeholders.disable();
}); //
// Utility functions
//
// No-op (used in place of public methods when native support is detected).
function noop() {} // Avoid IE9 activeElement of death when an iframe is used.
//
// More info:
// - http://bugs.jquery.com/ticket/13393
// - https://github.com/jquery/jquery/commit/85fc5878b3c6af73f42d61eedf73013e7faae408
function safeActiveElement() {
try {
return document.activeElement;
} catch (err) {}
} // Check whether an item is in an array. We don't use Array.prototype.indexOf
// so we don't clobber any existing polyfills. This is a really simple
// alternative.
function inArray(arr, item) {
for (var i = 0, len = arr.length; i < len; i++) {
if (arr[i] === item) {
return true;
}
}
return false;
} // Cross-browser DOM event binding
function addEventListener(elem, event, fn) {
if (elem.addEventListener) {
return elem.addEventListener(event, fn, false);
}
if (elem.attachEvent) {
return elem.attachEvent('on' + event, fn);
}
} // Move the caret to the index position specified. Assumes that the element
// has focus.
function moveCaret(elem, index) {
var range;
if (elem.createTextRange) {
range = elem.createTextRange();
range.move('character', index);
range.select();
} else if (elem.selectionStart) {
elem.focus();
elem.setSelectionRange(index, index);
}
} // Attempt to change the type property of an input element.
function changeType(elem, type) {
try {
elem.type = type;
return true;
} catch (e) {
// You can't change input type in IE8 and below.
return false;
}
}
function handleElem(node, callback) {
// Check if the passed in node is an input/textarea (in which case it can't
// have any affected descendants).
if (node && node.getAttribute(ATTR_CURRENT_VAL)) {
callback(node);
} else {
// If an element was passed in, get all affected descendants. Otherwise,
// get all affected elements in document.
var handleInputs = node ? node.getElementsByTagName('input') : inputs;
var handleTextareas = node ? node.getElementsByTagName('textarea') : textareas;
var handleInputsLength = handleInputs ? handleInputs.length : 0;
var handleTextareasLength = handleTextareas ? handleTextareas.length : 0; // Run the callback for each element.
var len = handleInputsLength + handleTextareasLength;
var elem;
for (var i = 0; i < len; i++) {
elem = i < handleInputsLength ? handleInputs[i] : handleTextareas[i - handleInputsLength];
callback(elem);
}
}
} // Return all affected elements to their normal state (remove placeholder
// value if present).
function disablePlaceholders(node) {
handleElem(node, hidePlaceholder);
} // Show the placeholder value on all appropriate elements.
function enablePlaceholders(node) {
handleElem(node, showPlaceholder);
} // Hide the placeholder value on a single element. Returns true if the
// placeholder was hidden and false if it was not (because it wasn't visible
// in the first place).
function hidePlaceholder(elem, keydownValue) {
var valueChanged = !!keydownValue && elem.value !== keydownValue;
var isPlaceholderValue = elem.value === elem.getAttribute(ATTR_CURRENT_VAL);
if ((valueChanged || isPlaceholderValue) && elem.getAttribute(ATTR_ACTIVE) === 'true') {
elem.removeAttribute(ATTR_ACTIVE);
elem.value = elem.value.replace(elem.getAttribute(ATTR_CURRENT_VAL), '');
elem.className = elem.className.replace(classNameRegExp, ''); // Restore the maxlength value. Old FF returns -1 if attribute not set.
// See GH-56.
var maxLength = elem.getAttribute(ATTR_MAXLENGTH);
if (parseInt(maxLength, 10) >= 0) {
elem.setAttribute('maxLength', maxLength);
elem.removeAttribute(ATTR_MAXLENGTH);
} // If the polyfill has changed the type of the element we need to change
// it back.
var type = elem.getAttribute(ATTR_INPUT_TYPE);
if (type) {
elem.type = type;
}
return true;
}
return false;
} // Show the placeholder value on a single element. Returns true if the
// placeholder was shown and false if it was not (because it was already
// visible).
function showPlaceholder(elem) {
var val = elem.getAttribute(ATTR_CURRENT_VAL);
if (elem.value === '' && val) {
elem.setAttribute(ATTR_ACTIVE, 'true');
elem.value = val;
elem.className += ' ' + placeholderClassName; // Store and remove the maxlength value.
var maxLength = elem.getAttribute(ATTR_MAXLENGTH);
if (!maxLength) {
elem.setAttribute(ATTR_MAXLENGTH, elem.maxLength);
elem.removeAttribute('maxLength');
} // If the type of element needs to change, change it (e.g. password
// inputs).
var type = elem.getAttribute(ATTR_INPUT_TYPE);
if (type) {
elem.type = 'text';
} else if (elem.type === 'password' && changeType(elem, 'text')) {
elem.setAttribute(ATTR_INPUT_TYPE, 'password');
}
return true;
}
return false;
} // Returns a function that is used as a focus event handler.
function makeFocusHandler(elem) {
return function () {
// Only hide the placeholder value if the (default) hide-on-focus
// behaviour is enabled.
if (hideOnInput && elem.value === elem.getAttribute(ATTR_CURRENT_VAL) && elem.getAttribute(ATTR_ACTIVE) === 'true') {
// Move the caret to the start of the input (this mimics the behaviour
// of all browsers that do not hide the placeholder on focus).
moveCaret(elem, 0);
} else {
// Remove the placeholder.
hidePlaceholder(elem);
}
};
} // Returns a function that is used as a blur event handler.
function makeBlurHandler(elem) {
return function () {
showPlaceholder(elem);
};
} // Returns a function that is used as a submit event handler on form elements
// that have children affected by this polyfill.
function makeSubmitHandler(form) {
return function () {
// Turn off placeholders on all appropriate descendant elements.
disablePlaceholders(form);
};
} // Functions that are used as a event handlers when the hide-on-input
// behaviour has been activated - very basic implementation of the 'input'
// event.
function makeKeydownHandler(elem) {
return function (e) {
keydownVal = elem.value; // Prevent the use of the arrow keys (try to keep the cursor before the
// placeholder).
if (elem.getAttribute(ATTR_ACTIVE) === 'true' && keydownVal === elem.getAttribute(ATTR_CURRENT_VAL) && inArray(badKeys, e.keyCode)) {
if (e.preventDefault) {
e.preventDefault();
}
return false;
}
};
}
function makeKeyupHandler(elem) {
return function () {
hidePlaceholder(elem, keydownVal); // If the element is now empty we need to show the placeholder
if (elem.value === '') {
elem.blur();
moveCaret(elem, 0);
}
};
}
function makeClickHandler(elem) {
return function () {
if (elem === safeActiveElement() && elem.value === elem.getAttribute(ATTR_CURRENT_VAL) && elem.getAttribute(ATTR_ACTIVE) === 'true') {
moveCaret(elem, 0);
}
};
} // Bind event handlers to an element that we need to affect with the
// polyfill.
function newElement(elem) {
// If the element is part of a form, make sure the placeholder string is
// not submitted as a value.
var form = elem.form;
if (form && typeof form === 'string') {
// Get the real form.
form = document.getElementById(form); // Set a flag on the form so we know it's been handled (forms can contain
// multiple inputs).
if (!form.getAttribute(ATTR_FORM_HANDLED)) {
addEventListener(form, 'submit', makeSubmitHandler(form));
form.setAttribute(ATTR_FORM_HANDLED, 'true');
}
} // Bind event handlers to the element so we can hide/show the placeholder
// as appropriate.
addEventListener(elem, 'focus', makeFocusHandler(elem));
addEventListener(elem, 'blur', makeBlurHandler(elem)); // If the placeholder should hide on input rather than on focus we need
// additional event handlers
if (hideOnInput) {
addEventListener(elem, 'keydown', makeKeydownHandler(elem));
addEventListener(elem, 'keyup', makeKeyupHandler(elem));
addEventListener(elem, 'click', makeClickHandler(elem));
} // Remember that we've bound event handlers to this element.
elem.setAttribute(ATTR_EVENTS_BOUND, 'true');
elem.setAttribute(ATTR_CURRENT_VAL, placeholder); // If the element doesn't have a value and is not focussed, set it to the
// placeholder string.
if (hideOnInput || elem !== safeActiveElement()) {
showPlaceholder(elem);
}
}
})(void 0);
},{}]},{},[1]);