: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
modifier: this._getKeyModifier(event)
element.addEventListener(baseName, event => {
if (baseName === "blur") {
if (!elementData.focused || !event.relatedTarget) {
elementData.focused = false;
} else if (baseName === "focus") {
if (elementData.focused) {
elementData.focused = true;
this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
value: valueGetter(event)
_setEventListeners(element, elementData, names, getter) {
for (const [baseName, eventName] of names) {
if (eventName === "Action" || this.data.actions?.[eventName]) {
if (eventName === "Focus" || eventName === "Blur") {
this._setEventListener(element, elementData, baseName, eventName, getter);
if (eventName === "Focus" && !this.data.actions?.Blur) {
this._setEventListener(element, elementData, "blur", "Blur", null);
} else if (eventName === "Blur" && !this.data.actions?.Focus) {
this._setEventListener(element, elementData, "focus", "Focus", null);
_setBackgroundColor(element) {
const color = this.data.backgroundColor || null;
element.style.backgroundColor = color === null ? "transparent" : Util.makeHexColor(color[0], color[1], color[2]);
const TEXT_ALIGNMENT = ["left", "center", "right"];
} = this.data.defaultAppearanceData;
const fontSize = this.data.defaultAppearanceData.fontSize || annotation_layer_DEFAULT_FONT_SIZE;
const style = element.style;
const roundToOneDecimal = x => Math.round(10 * x) / 10;
if (this.data.multiLine) {
const height = Math.abs(this.data.rect[3] - this.data.rect[1] - BORDER_SIZE);
const numberOfLines = Math.round(height / (LINE_FACTOR * fontSize)) || 1;
const lineHeight = height / numberOfLines;
computedFontSize = Math.min(fontSize, roundToOneDecimal(lineHeight / LINE_FACTOR));
const height = Math.abs(this.data.rect[3] - this.data.rect[1] - BORDER_SIZE);
computedFontSize = Math.min(fontSize, roundToOneDecimal(height / LINE_FACTOR));
style.fontSize = `calc(${computedFontSize}px * var(--scale-factor))`;
style.color = Util.makeHexColor(fontColor[0], fontColor[1], fontColor[2]);
if (this.data.textAlignment !== null) {
style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];
_setRequired(element, isRequired) {
element.setAttribute("required", true);
element.removeAttribute("required");
element.setAttribute("aria-required", isRequired);
class TextWidgetAnnotationElement extends WidgetAnnotationElement {
constructor(parameters) {
const isRenderable = parameters.renderForms || parameters.data.hasOwnCanvas || !parameters.data.hasAppearance && !!parameters.data.fieldValue;
setPropertyOnSiblings(base, key, value, keyInStorage) {
const storage = this.annotationStorage;
for (const element of this._getElementsByName(base.name, base.id)) {
if (element.domElement) {
element.domElement[key] = value;
storage.setValue(element.id, {
const storage = this.annotationStorage;
this.container.classList.add("textWidgetAnnotation");
const storedData = storage.getValue(id, {
value: this.data.fieldValue
let textContent = storedData.value || "";
const maxLen = storage.getValue(id, {
charLimit: this.data.maxLen
if (maxLen && textContent.length > maxLen) {
textContent = textContent.slice(0, maxLen);
let fieldFormattedValues = storedData.formattedValue || this.data.textContent?.join("\n") || null;
if (fieldFormattedValues && this.data.comb) {
fieldFormattedValues = fieldFormattedValues.replaceAll(/\s+/g, "");
formattedValue: fieldFormattedValues,
lastCommittedValue: null,
if (this.data.multiLine) {
element = document.createElement("textarea");
element.textContent = fieldFormattedValues ?? textContent;
if (this.data.doNotScroll) {
element.style.overflowY = "hidden";
element = document.createElement("input");
element.setAttribute("value", fieldFormattedValues ?? textContent);
if (this.data.doNotScroll) {
element.style.overflowX = "hidden";
if (this.data.hasOwnCanvas) {
GetElementsByNameSet.add(element);
element.setAttribute("data-element-id", id);
element.disabled = this.data.readOnly;
element.name = this.data.fieldName;
element.tabIndex = DEFAULT_TAB_INDEX;
this._setRequired(element, this.data.required);
element.maxLength = maxLen;
element.addEventListener("input", event => {
value: event.target.value
this.setPropertyOnSiblings(element, "value", event.target.value, "value");
elementData.formattedValue = null;
element.addEventListener("resetform", event => {
const defaultValue = this.data.defaultFieldValue ?? "";
element.value = elementData.userValue = defaultValue;
elementData.formattedValue = null;
let blurListener = event => {
if (formattedValue !== null && formattedValue !== undefined) {
event.target.value = formattedValue;
event.target.scrollLeft = 0;
if (this.enableScripting && this.hasJSActions) {
element.addEventListener("focus", event => {
if (elementData.focused) {
if (elementData.userValue) {
target.value = elementData.userValue;
elementData.lastCommittedValue = target.value;
elementData.commitKey = 1;
if (!this.data.actions?.Focus) {
elementData.focused = true;
element.addEventListener("updatefromsandbox", jsEvent => {
this.showElementAndHideCanvas(jsEvent.target);
elementData.userValue = event.detail.value ?? "";
value: elementData.userValue.toString()
event.target.value = elementData.userValue;
elementData.formattedValue = formattedValue;
if (formattedValue !== null && formattedValue !== undefined && event.target !== document.activeElement) {
event.target.value = formattedValue;
event.target.setSelectionRange(...event.detail.selRange);
target.removeAttribute("maxLength");
target.setAttribute("maxLength", charLimit);
let value = elementData.userValue;
if (!value || value.length <= charLimit) {
value = value.slice(0, charLimit);
target.value = elementData.userValue = value;
this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
selStart: target.selectionStart,
selEnd: target.selectionEnd
this._dispatchEventFromSandbox(actions, jsEvent);
element.addEventListener("keydown", event => {
elementData.commitKey = 1;
if (event.key === "Escape") {
} else if (event.key === "Enter" && !this.data.multiLine) {
} else if (event.key === "Tab") {
elementData.commitKey = 3;
if (elementData.lastCommittedValue === value) {
elementData.lastCommittedValue = value;
elementData.userValue = value;
this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
selStart: event.target.selectionStart,
selEnd: event.target.selectionEnd
const _blurListener = blurListener;
element.addEventListener("blur", event => {
if (!elementData.focused || !event.relatedTarget) {
if (!this.data.actions?.Blur) {
elementData.focused = false;
elementData.userValue = value;
if (elementData.lastCommittedValue !== value) {
this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
commitKey: elementData.commitKey,
selStart: event.target.selectionStart,
selEnd: event.target.selectionEnd
if (this.data.actions?.Keystroke) {
element.addEventListener("beforeinput", event => {
elementData.lastCommittedValue = null;
let selStart = selectionStart,
switch (event.inputType) {
case "deleteWordBackward":
const match = value.substring(0, selectionStart).match(/\w*[^\w]*$/);
selStart -= match[0].length;
case "deleteWordForward":
const match = value.substring(selectionStart).match(/^[^\w]*\w*/);
selEnd += match[0].length;
case "deleteContentBackward":
if (selectionStart === selectionEnd) {
case "deleteContentForward":
if (selectionStart === selectionEnd) {
this.linkService.eventBus?.dispatch("dispatcheventinsandbox", {
this._setEventListeners(element, elementData, [["focus", "Focus"], ["blur", "Blur"], ["mousedown", "Mouse Down"], ["mouseenter", "Mouse Enter"], ["mouseleave", "Mouse Exit"], ["mouseup", "Mouse Up"]], event => event.target.value);
element.addEventListener("blur", blurListener);
const fieldWidth = this.data.rect[2] - this.data.rect[0];
const combWidth = fieldWidth / maxLen;
element.classList.add("comb");
element.style.letterSpacing = `calc(${combWidth}px * var(--scale-factor) - 1ch)`;
element = document.createElement("div");
element.textContent = this.data.fieldValue;
element.style.verticalAlign = "middle";
element.style.display = "table-cell";
if (this.data.hasOwnCanvas) {
this._setTextStyle(element);
this._setBackgroundColor(element);
this._setDefaultPropertiesFromJS(element);
this.container.append(element);
class SignatureWidgetAnnotationElement extends WidgetAnnotationElement {
constructor(parameters) {
isRenderable: !!parameters.data.hasOwnCanvas
class CheckboxWidgetAnnotationElement extends WidgetAnnotationElement {
constructor(parameters) {
isRenderable: parameters.renderForms
const storage = this.annotationStorage;
let value = storage.getValue(id, {
value: data.exportValue === data.fieldValue
if (typeof value === "string") {
this.container.classList.add("buttonWidgetAnnotation", "checkBox");
const element = document.createElement("input");
GetElementsByNameSet.add(element);
element.setAttribute("data-element-id", id);
element.disabled = data.readOnly;
this._setRequired(element, this.data.required);
element.type = "checkbox";
element.name = data.fieldName;
element.setAttribute("checked", true);
element.setAttribute("exportValue", data.exportValue);
element.tabIndex = DEFAULT_TAB_INDEX;
element.addEventListener("change", event => {
for (const checkbox of this._getElementsByName(name, id)) {
const curChecked = checked && checkbox.exportValue === data.exportValue;
if (checkbox.domElement) {
checkbox.domElement.checked = curChecked;
storage.setValue(checkbox.id, {
element.addEventListener("resetform", event => {
const defaultValue = data.defaultFieldValue || "Off";
event.target.checked = defaultValue === data.exportValue;
if (this.enableScripting && this.hasJSActions) {
element.addEventListener("updatefromsandbox", jsEvent => {
event.target.checked = event.detail.value !== "Off";
value: event.target.checked
this._dispatchEventFromSandbox(actions, jsEvent);
this._setEventListeners(element, null, [["change", "Validate"], ["change", "Action"], ["focus", "Focus"], ["blur", "Blur"], ["mousedown", "Mouse Down"], ["mouseenter", "Mouse Enter"], ["mouseleave", "Mouse Exit"], ["mouseup", "Mouse Up"]], event => event.target.checked);
this._setBackgroundColor(element);
this._setDefaultPropertiesFromJS(element);
this.container.append(element);
class RadioButtonWidgetAnnotationElement extends WidgetAnnotationElement {
constructor(parameters) {
isRenderable: parameters.renderForms
this.container.classList.add("buttonWidgetAnnotation", "radioButton");
const storage = this.annotationStorage;
let value = storage.getValue(id, {
value: data.fieldValue === data.buttonValue
if (typeof value === "string") {