@salve-software/react-native-nitro-jsdom 1.1.0 → 2.1.0

package/cpp/quickjs/bindings/FormBindings.cpp

@@ -125,6 +125,300 @@ const char* kFormBootstrapScript = R"JS(
     // Per spec, submit() bypasses the "submit" event and constraint validation.
     // There is no real navigation in this sandbox, so this is intentionally inert.
   };
+  Element.prototype.reset = function() {
+    if (!isFormElement(this)) return;
+    this.dispatchEvent(new Event('reset', { bubbles: true, cancelable: true }));
+  };
+
+  // ── select.options / .selectedIndex / .selectedOptions ────────────────────
+  function isSelectElement(el) {
+    return !!el && el.tagName === 'SELECT';
+  }
+
+  function selectOptionsArray(select) {
+    return Array.prototype.slice.call(select.querySelectorAll('option'));
+  }
+
+  Object.defineProperty(Element.prototype, 'options', {
+    configurable: true,
+    get: function() {
+      if (!isSelectElement(this)) return undefined;
+      var select = this;
+      var opts = selectOptionsArray(select);
+      opts.item = function(index) { return this[index] !== undefined ? this[index] : null; };
+      opts.namedItem = function(name) {
+        for (var i = 0; i < this.length; i++) {
+          if (this[i].id === name || this[i].getAttribute('name') === name) return this[i];
+        }
+        return null;
+      };
+      opts.add = function(option, before) {
+        var refNode = null;
+        if (typeof before === 'number') refNode = this[before] || null;
+        else if (before) refNode = before;
+        if (refNode) select.insertBefore(option, refNode);
+        else select.appendChild(option);
+      };
+      opts.remove = function(index) {
+        var target = this[index];
+        if (target) select.removeChild(target);
+      };
+      return opts;
+    },
+  });
+
+  Object.defineProperty(Element.prototype, 'selectedIndex', {
+    configurable: true,
+    get: function() {
+      if (!isSelectElement(this)) return -1;
+      var opts = selectOptionsArray(this);
+      for (var i = 0; i < opts.length; i++) {
+        if (opts[i].selected) return i;
+      }
+      return (!this.multiple && opts.length > 0) ? 0 : -1;
+    },
+    set: function(index) {
+      if (!isSelectElement(this)) return;
+      var opts = selectOptionsArray(this);
+      for (var i = 0; i < opts.length; i++) {
+        opts[i].selected = (i === index);
+      }
+    },
+  });
+
+  Object.defineProperty(Element.prototype, 'selectedOptions', {
+    configurable: true,
+    get: function() {
+      if (!isSelectElement(this)) return undefined;
+      var opts = selectOptionsArray(this);
+      var selected = opts.filter(function(o) { return o.selected; });
+      if (selected.length === 0 && !this.multiple && opts.length > 0) return [opts[0]];
+      return selected;
+    },
+  });
+
+  // ── Constraint Validation API (ValidityState, checkValidity, ...) ─────────
+  // Covers the subset real-world CMS forms actually hit: required, pattern,
+  // min/max/minlength/maxlength, type="email"/"url"/"number" and custom
+  // validity. `step` is intentionally not modeled (stepMismatch is always
+  // false) — it needs the same "default step base" arithmetic per input type
+  // that browsers hardcode, which isn't worth it for this sandbox's scope.
+  // reportValidity() has no UI to report against here, so it's just an alias
+  // for checkValidity() (same outcome jsdom has, for the same reason).
+
+  var VALIDITY_KEYS = [
+    'valueMissing', 'typeMismatch', 'patternMismatch', 'tooLong', 'tooShort',
+    'rangeUnderflow', 'rangeOverflow', 'stepMismatch', 'badInput', 'customError',
+  ];
+
+  function ValidityState(flags) {
+    this._flags = flags;
+  }
+  VALIDITY_KEYS.forEach(function(key) {
+    Object.defineProperty(ValidityState.prototype, key, {
+      enumerable: true,
+      get: function() { return !!this._flags[key]; },
+    });
+  });
+  Object.defineProperty(ValidityState.prototype, 'valid', {
+    enumerable: true,
+    get: function() {
+      var flags = this._flags;
+      return !VALIDITY_KEYS.some(function(key) { return flags[key]; });
+    },
+  });
+  globalThis.ValidityState = ValidityState;
+
+  var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  var URL_RE = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\/\S+$/;
+
+  function isFieldElement(el) {
+    return el.tagName === 'INPUT' || el.tagName === 'SELECT' || el.tagName === 'TEXTAREA';
+  }
+
+  function fieldType(el) {
+    if (el.tagName === 'TEXTAREA') return 'textarea';
+    if (el.tagName === 'SELECT') return 'select';
+    return (el.getAttribute('type') || 'text').toLowerCase();
+  }
+
+  function computeValidityFlags(el) {
+    var flags = {};
+    if (el._customValidity) flags.customError = true;
+
+    if (!isFieldElement(el) || el.hasAttribute('disabled')) return flags;
+
+    var type = fieldType(el);
+    if (type === 'hidden') return flags;
+
+    var required = el.hasAttribute('required');
+
+    if (type === 'checkbox' || type === 'radio') {
+      if (required && !el.checked) flags.valueMissing = true;
+      return flags;
+    }
+
+    var value = el.value;
+
+    if (el.tagName === 'SELECT') {
+      if (required && !value) flags.valueMissing = true;
+      return flags;
+    }
+
+    if (required && value === '') flags.valueMissing = true;
+    if (value === '') return flags;
+
+    if (type === 'email' && !EMAIL_RE.test(value)) flags.typeMismatch = true;
+    if (type === 'url' && !URL_RE.test(value)) flags.typeMismatch = true;
+
+    var pattern = el.getAttribute('pattern');
+    if (pattern) {
+      try {
+        if (!new RegExp('^(?:' + pattern + ')$').test(value)) flags.patternMismatch = true;
+      } catch (e) {
+        // Invalid pattern attribute: browsers treat this as never matching,
+        // but silently ignoring it is the safer default for a headless sandbox.
+      }
+    }
+
+    var maxlength = el.getAttribute('maxlength');
+    if (maxlength !== null && value.length > parseInt(maxlength, 10)) flags.tooLong = true;
+
+    var minlength = el.getAttribute('minlength');
+    if (minlength !== null && value.length < parseInt(minlength, 10)) flags.tooShort = true;
+
+    if (type === 'number' || type === 'range') {
+      var num = Number(value);
+      if (value.trim() === '' || isNaN(num)) {
+        flags.badInput = true;
+      } else {
+        var min = el.getAttribute('min');
+        var max = el.getAttribute('max');
+        if (min !== null && num < Number(min)) flags.rangeUnderflow = true;
+        if (max !== null && num > Number(max)) flags.rangeOverflow = true;
+      }
+    }
+
+    return flags;
+  }
+
+  Object.defineProperty(Element.prototype, 'validity', {
+    configurable: true,
+    get: function() { return new ValidityState(computeValidityFlags(this)); },
+  });
+
+  Object.defineProperty(Element.prototype, 'willValidate', {
+    configurable: true,
+    get: function() {
+      return isFieldElement(this) && !this.hasAttribute('disabled') && fieldType(this) !== 'hidden';
+    },
+  });
+
+  var DEFAULT_MESSAGES = {
+    valueMissing: 'Please fill out this field.',
+    typeMismatch: 'Please enter a valid value.',
+    patternMismatch: 'Please match the requested format.',
+    tooLong: 'Please shorten this text.',
+    tooShort: 'Please lengthen this text.',
+    rangeUnderflow: 'Value must be greater than or equal to the minimum.',
+    rangeOverflow: 'Value must be less than or equal to the maximum.',
+    badInput: 'Please enter a valid value.',
+  };
+
+  Object.defineProperty(Element.prototype, 'validationMessage', {
+    configurable: true,
+    get: function() {
+      if (this._customValidity) return this._customValidity;
+      var flags = computeValidityFlags(this);
+      for (var i = 0; i < VALIDITY_KEYS.length; i++) {
+        if (flags[VALIDITY_KEYS[i]]) return DEFAULT_MESSAGES[VALIDITY_KEYS[i]] || '';
+      }
+      return '';
+    },
+  });
+
+  Element.prototype.setCustomValidity = function(message) {
+    this._customValidity = message == null ? '' : String(message);
+  };
+
+  function fieldCheckValidity(el) {
+    var valid = new ValidityState(computeValidityFlags(el)).valid;
+    if (!valid) {
+      var evt = new Event('invalid', { bubbles: false, cancelable: true });
+      el.dispatchEvent(evt);
+    }
+    return valid;
+  }
+
+  function formFields(form) {
+    return Array.prototype.filter.call(form.querySelectorAll('input, select, textarea'), function(el) {
+      return !el.hasAttribute('disabled');
+    });
+  }
+
+  Element.prototype.checkValidity = function() {
+    if (this.tagName === 'FORM') {
+      var fields = formFields(this);
+      var allValid = true;
+      for (var i = 0; i < fields.length; i++) {
+        if (!fieldCheckValidity(fields[i])) allValid = false;
+      }
+      return allValid;
+    }
+    return fieldCheckValidity(this);
+  };
+
+  Element.prototype.reportValidity = function() {
+    return this.checkValidity();
+  };
+
+  // ── element.form / form.elements ────────────────────────────────────────
+  var FORM_ASSOCIATED_TAGS = ['INPUT', 'SELECT', 'TEXTAREA', 'BUTTON', 'FIELDSET', 'OUTPUT'];
+
+  function formControls(form) {
+    return Array.prototype.slice.call(form.querySelectorAll('input, select, textarea, button, fieldset, output'));
+  }
+
+  Object.defineProperty(Element.prototype, 'form', {
+    configurable: true,
+    get: function() {
+      if (FORM_ASSOCIATED_TAGS.indexOf(this.tagName) === -1) return undefined;
+      var formId = this.getAttribute('form');
+      if (formId) {
+        var byId = document.getElementById(formId);
+        if (byId && byId.tagName === 'FORM') return byId;
+      }
+      return this.closest('form');
+    },
+  });
+
+  Object.defineProperty(Element.prototype, 'elements', {
+    configurable: true,
+    get: function() {
+      if (this.tagName !== 'FORM') return undefined;
+      return formControls(this);
+    },
+  });
+
+  var LABELABLE_TAGS = ['BUTTON', 'INPUT', 'METER', 'OUTPUT', 'PROGRESS', 'SELECT', 'TEXTAREA'];
+
+  Object.defineProperty(Element.prototype, 'labels', {
+    configurable: true,
+    get: function() {
+      if (LABELABLE_TAGS.indexOf(this.tagName) === -1) return null;
+      if (this.tagName === 'INPUT' && (this.getAttribute('type') || '').toLowerCase() === 'hidden') return null;
+      var result = [];
+      if (this.id) {
+        var candidates = this.ownerDocument.querySelectorAll('label[for]');
+        for (var i = 0; i < candidates.length; i++) {
+          if (candidates[i].getAttribute('for') === this.id) result.push(candidates[i]);
+        }
+      }
+      var wrapping = this.closest('label');
+      if (wrapping && result.indexOf(wrapping) === -1) result.push(wrapping);
+      return result;
+    },
+  });
 })();
 )JS";
 

package/cpp/quickjs/bindings/FormBindings.hpp

@@ -4,11 +4,15 @@
 
 namespace margelo::nitro::nitrojsdom {
 
-// Registers globalThis.FormData and Element.prototype.requestSubmit/submit
-// (tag-checked for "form" internally, mirroring ElementBindings' value/checked
-// pattern). Pure JS on top of the already-exposed querySelectorAll/Event
-// primitives — no native code needed. Must run after ElementBindings (for
-// globalThis.Element) and EventBindings (for globalThis.Event).
+// Registers globalThis.FormData, Element.prototype.requestSubmit/submit, and
+// the Constraint Validation API (globalThis.ValidityState,
+// Element.prototype.validity/willValidate/validationMessage/checkValidity()/
+// reportValidity()/setCustomValidity()). Tag-checked for "form"/"input"/
+// "select"/"textarea" internally, mirroring ElementBindings' value/checked
+// pattern. Pure JS on top of the already-exposed getAttribute/value/checked/
+// querySelectorAll/Event primitives — no native code needed. Must run after
+// ElementBindings (for globalThis.Element) and EventBindings (for
+// globalThis.Event).
 struct FormBindings {
   static void install(JSContext* ctx);
 };

package/cpp/quickjs/bindings/IntlBindings.cpp

@@ -0,0 +1,352 @@
+#include "IntlBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kIntlBootstrapScript = R"JS(
+(function() {
+  var LOCALE_DATA = {
+    en: {
+      months: {
+        long: ['January','February','March','April','May','June','July','August','September','October','November','December'],
+        short: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'],
+        narrow: ['J','F','M','A','M','J','J','A','S','O','N','D'],
+      },
+      weekdays: {
+        long: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
+        short: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
+        narrow: ['S','M','T','W','T','F','S'],
+      },
+      dayPeriod: ['AM', 'PM'],
+      decimal: '.',
+      group: ',',
+      dateOrder: 'MDY',
+      currencySpace: false,
+    },
+    pt: {
+      months: {
+        long: ['janeiro','fevereiro','março','abril','maio','junho','julho','agosto','setembro','outubro','novembro','dezembro'],
+        short: ['jan','fev','mar','abr','mai','jun','jul','ago','set','out','nov','dez'],
+        narrow: ['J','F','M','A','M','J','J','A','S','O','N','D'],
+      },
+      weekdays: {
+        long: ['domingo','segunda-feira','terça-feira','quarta-feira','quinta-feira','sexta-feira','sábado'],
+        short: ['dom','seg','ter','qua','qui','sex','sáb'],
+        narrow: ['D','S','T','Q','Q','S','S'],
+      },
+      dayPeriod: ['AM', 'PM'],
+      decimal: ',',
+      group: '.',
+      dateOrder: 'DMY',
+      currencySpace: true,
+    },
+  };
+
+  var CURRENCY_SYMBOLS = {
+    USD: '$', EUR: '€', GBP: '£', JPY: '¥', BRL: 'R$', CAD: 'CA$', AUD: 'A$', CHF: 'CHF', CNY: 'CN¥', INR: '₹', MXN: 'MX$',
+  };
+
+  var CURRENCY_DECIMALS = {
+    JPY: 0, KRW: 0, VND: 0, CLP: 0, ISK: 0, UGX: 0, XAF: 0, XOF: 0, XPF: 0,
+    BHD: 3, IQD: 3, JOD: 3, KWD: 3, OMR: 3, TND: 3,
+  };
+
+  function currencyDecimals(code) {
+    return CURRENCY_DECIMALS[code] !== undefined ? CURRENCY_DECIMALS[code] : 2;
+  }
+
+  function localeLanguage(locales) {
+    var tag = Array.isArray(locales) ? locales[0] : locales;
+    tag = String(tag || 'en');
+    return tag.split(/[-_]/)[0].toLowerCase();
+  }
+
+  function resolveLocale(locales) {
+    var lang = localeLanguage(locales);
+    return LOCALE_DATA[lang] || LOCALE_DATA.en;
+  }
+
+  function groupInteger(digits, groupSep) {
+    var out = '';
+    var count = 0;
+    for (var i = digits.length - 1; i >= 0; i--) {
+      out = digits.charAt(i) + out;
+      count++;
+      if (count % 3 === 0 && i !== 0) out = groupSep + out;
+    }
+    return out;
+  }
+
+  function formatFixed(value, minFrac, maxFrac, useGrouping, data) {
+    var negative = value < 0;
+    var abs = Math.abs(value);
+    var fixed = abs.toFixed(maxFrac);
+    var parts = fixed.split('.');
+    var intPart = parts[0];
+    var fracPart = parts[1] || '';
+
+    while (fracPart.length > minFrac && fracPart.charAt(fracPart.length - 1) === '0') {
+      fracPart = fracPart.slice(0, -1);
+    }
+
+    var out = useGrouping ? groupInteger(intPart, data.group) : intPart;
+    if (fracPart.length > 0) out += data.decimal + fracPart;
+    return (negative ? '-' : '') + out;
+  }
+
+  function NumberFormat(locales, options) {
+    this._data = resolveLocale(locales);
+    options = options || {};
+    this._style = options.style || 'decimal';
+    if (this._style === 'currency') {
+      if (!options.currency) throw new TypeError('Currency code is required with currency style.');
+      this._currency = options.currency;
+    }
+    var currDecimals = this._style === 'currency' ? currencyDecimals(this._currency) : undefined;
+    var defaultMinFrac = this._style === 'currency' ? currDecimals : 0;
+    var defaultMaxFrac = this._style === 'currency' ? currDecimals : (this._style === 'percent' ? 0 : 3);
+    this._minFrac = options.minimumFractionDigits !== undefined ? options.minimumFractionDigits : defaultMinFrac;
+    this._maxFrac = options.maximumFractionDigits !== undefined ? options.maximumFractionDigits : Math.max(defaultMaxFrac, this._minFrac);
+    this._useGrouping = options.useGrouping !== undefined ? !!options.useGrouping : true;
+  }
+
+  NumberFormat.prototype.format = function(value) {
+    value = Number(value);
+    if (this._style === 'percent') value = value * 100;
+    var formatted = formatFixed(value, this._minFrac, this._maxFrac, this._useGrouping, this._data);
+    if (this._style === 'percent') return formatted + '%';
+    if (this._style === 'currency') {
+      var symbol = CURRENCY_SYMBOLS[this._currency] || this._currency;
+      return symbol + (this._data.currencySpace ? ' ' : '') + formatted;
+    }
+    return formatted;
+  };
+
+  NumberFormat.prototype.resolvedOptions = function() {
+    return {
+      style: this._style,
+      currency: this._style === 'currency' ? this._currency : undefined,
+      minimumFractionDigits: this._minFrac,
+      maximumFractionDigits: this._maxFrac,
+      useGrouping: this._useGrouping,
+    };
+  };
+
+  function pad2(n) { return (n < 10 ? '0' : '') + n; }
+
+  var DATE_STYLE_OPTIONS = {
+    short: { year: '2-digit', month: 'numeric', day: 'numeric' },
+    medium: { year: 'numeric', month: 'short', day: 'numeric' },
+    long: { year: 'numeric', month: 'long', day: 'numeric' },
+    full: { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' },
+  };
+  var TIME_STYLE_OPTIONS = {
+    short: { hour: 'numeric', minute: 'numeric' },
+    medium: { hour: 'numeric', minute: 'numeric', second: 'numeric' },
+    long: { hour: 'numeric', minute: 'numeric', second: 'numeric' },
+    full: { hour: 'numeric', minute: 'numeric', second: 'numeric' },
+  };
+
+  function DateTimeFormat(locales, options) {
+    this._data = resolveLocale(locales);
+    options = options || {};
+
+    if (options.dateStyle || options.timeStyle) {
+      var withDate = options.dateStyle ? (DATE_STYLE_OPTIONS[options.dateStyle] || DATE_STYLE_OPTIONS.medium) : {};
+      var withTime = options.timeStyle ? (TIME_STYLE_OPTIONS[options.timeStyle] || TIME_STYLE_OPTIONS.short) : {};
+      options = Object.assign({}, withDate, withTime, options);
+    } else if (Object.keys(options).length === 0) {
+      options = { year: 'numeric', month: 'numeric', day: 'numeric' };
+    }
+
+    this._options = options;
+  }
+
+  function datePartFor(date, o, data) {
+    var textual = o.month === 'long' || o.month === 'short' || o.month === 'narrow';
+    var day = o.day ? (o.day === '2-digit' ? pad2(date.getDate()) : String(date.getDate())) : '';
+    var year = o.year ? (o.year === '2-digit' ? pad2(date.getFullYear() % 100) : String(date.getFullYear())) : '';
+    var month = o.month
+      ? (textual ? data.months[o.month][date.getMonth()] : (o.month === '2-digit' ? pad2(date.getMonth() + 1) : String(date.getMonth() + 1)))
+      : '';
+
+    if (!month && !day && !year) return '';
+
+    if (textual) {
+      if (data.dateOrder === 'MDY') {
+        var head = day ? month + ' ' + day : month;
+        return year ? head + ', ' + year : head;
+      }
+      return [day, month, year].filter(Boolean).join(' ');
+    }
+
+    var ordered = data.dateOrder === 'MDY' ? [month, day, year] : [day, month, year];
+    return ordered.filter(Boolean).join('/');
+  }
+
+  DateTimeFormat.prototype.format = function(date) {
+    date = date === undefined ? new Date() : (date instanceof Date ? date : new Date(date));
+    var o = this._options;
+    var data = this._data;
+    var pieces = [];
+
+    var datePart = datePartFor(date, o, data);
+    if (o.weekday) {
+      var w = date.getDay();
+      var weekdayName = data.weekdays[o.weekday === 'narrow' ? 'narrow' : (o.weekday === 'long' ? 'long' : 'short')][w];
+      pieces.push(datePart ? weekdayName + ', ' + datePart : weekdayName);
+    } else if (datePart) {
+      pieces.push(datePart);
+    }
+
+    if (o.hour) {
+      var h = date.getHours();
+      var hour12 = o.hour12 !== false;
+      var hourVal = hour12 ? (h % 12 === 0 ? 12 : h % 12) : h;
+      var timeSegs = [o.hour === '2-digit' ? pad2(hourVal) : String(hourVal)];
+      if (o.minute) timeSegs.push(pad2(date.getMinutes()));
+      if (o.second) timeSegs.push(pad2(date.getSeconds()));
+      var timeStr = timeSegs.join(':');
+      if (hour12) timeStr += ' ' + (h < 12 ? data.dayPeriod[0] : data.dayPeriod[1]);
+      pieces.push(timeStr);
+    } else if (o.minute) {
+      var timeSegs2 = [pad2(date.getMinutes())];
+      if (o.second) timeSegs2.push(pad2(date.getSeconds()));
+      pieces.push(timeSegs2.join(':'));
+    }
+
+    return pieces.join(', ');
+  };
+
+  DateTimeFormat.prototype.resolvedOptions = function() {
+    return Object.assign({}, this._options);
+  };
+
+  function pluralCategoryFor(n, lang) {
+    n = Math.abs(Number(n));
+    if (lang === 'pt') return (n === 0 || n === 1) ? 'one' : 'other';
+    return n === 1 ? 'one' : 'other';
+  }
+
+  function PluralRules(locales, options) {
+    this._lang = localeLanguage(locales);
+    options = options || {};
+    this._type = options.type || 'cardinal';
+  }
+
+  PluralRules.prototype.select = function(n) {
+    return pluralCategoryFor(n, this._lang);
+  };
+
+  PluralRules.prototype.resolvedOptions = function() {
+    return { locale: this._lang, type: this._type, pluralCategories: ['one', 'other'] };
+  };
+
+  var RTF_UNITS = {
+    en: {
+      year: ['year', 'years'], quarter: ['quarter', 'quarters'], month: ['month', 'months'],
+      week: ['week', 'weeks'], day: ['day', 'days'], hour: ['hour', 'hours'],
+      minute: ['minute', 'minutes'], second: ['second', 'seconds'],
+    },
+    pt: {
+      year: ['ano', 'anos'], quarter: ['trimestre', 'trimestres'], month: ['mês', 'meses'],
+      week: ['semana', 'semanas'], day: ['dia', 'dias'], hour: ['hora', 'horas'],
+      minute: ['minuto', 'minutos'], second: ['segundo', 'segundos'],
+    },
+  };
+
+  var RTF_PATTERNS = {
+    en: { past: '{0} {1} ago', future: 'in {0} {1}' },
+    pt: { past: 'há {0} {1}', future: 'em {0} {1}' },
+  };
+
+  var RTF_AUTO = {
+    en: {
+      day: { '-1': 'yesterday', '0': 'today', '1': 'tomorrow' },
+      week: { '-1': 'last week', '0': 'this week', '1': 'next week' },
+      month: { '-1': 'last month', '0': 'this month', '1': 'next month' },
+      year: { '-1': 'last year', '0': 'this year', '1': 'next year' },
+      second: { '0': 'now' },
+    },
+    pt: {
+      day: { '-1': 'ontem', '0': 'hoje', '1': 'amanhã' },
+      week: { '-1': 'semana passada', '0': 'esta semana', '1': 'semana que vem' },
+      month: { '-1': 'mês passado', '0': 'este mês', '1': 'próximo mês' },
+      year: { '-1': 'ano passado', '0': 'este ano', '1': 'próximo ano' },
+      second: { '0': 'agora' },
+    },
+  };
+
+  var RTF_UNIT_ALIASES = {
+    years: 'year', quarters: 'quarter', months: 'month', weeks: 'week',
+    days: 'day', hours: 'hour', minutes: 'minute', seconds: 'second',
+  };
+
+  function RelativeTimeFormat(locales, options) {
+    this._lang = RTF_UNITS[localeLanguage(locales)] ? localeLanguage(locales) : 'en';
+    options = options || {};
+    this._numeric = options.numeric || 'always';
+    this._style = options.style || 'long';
+  }
+
+  RelativeTimeFormat.prototype.format = function(value, unit) {
+    value = Number(value);
+    unit = RTF_UNIT_ALIASES[unit] || unit;
+    var units = RTF_UNITS[this._lang][unit];
+    if (!units) throw new RangeError('Invalid unit argument for RelativeTimeFormat.format()');
+
+    if (this._numeric === 'auto') {
+      var autoData = RTF_AUTO[this._lang][unit];
+      if (autoData && autoData[String(value)] !== undefined) {
+        return autoData[String(value)];
+      }
+    }
+
+    var n = Math.abs(value);
+    var unitName = units[pluralCategoryFor(n, this._lang) === 'one' ? 0 : 1];
+    var pattern = value < 0 ? RTF_PATTERNS[this._lang].past : RTF_PATTERNS[this._lang].future;
+    return pattern.replace('{0}', String(n)).replace('{1}', unitName);
+  };
+
+  RelativeTimeFormat.prototype.resolvedOptions = function() {
+    return { locale: this._lang, style: this._style, numeric: this._numeric };
+  };
+
+  globalThis.Intl = globalThis.Intl || {};
+  globalThis.Intl.NumberFormat = NumberFormat;
+  globalThis.Intl.DateTimeFormat = DateTimeFormat;
+  globalThis.Intl.PluralRules = PluralRules;
+  globalThis.Intl.RelativeTimeFormat = RelativeTimeFormat;
+
+  function hasOwnKeys(o) { return !!o && Object.keys(o).length > 0; }
+
+  Number.prototype.toLocaleString = function(locales, options) {
+    return new NumberFormat(locales, options).format(this);
+  };
+
+  Date.prototype.toLocaleString = function(locales, options) {
+    return new DateTimeFormat(locales, hasOwnKeys(options) ? options : { year: 'numeric', month: 'numeric', day: 'numeric', hour: 'numeric', minute: 'numeric', second: 'numeric' }).format(this);
+  };
+  Date.prototype.toLocaleDateString = function(locales, options) {
+    return new DateTimeFormat(locales, hasOwnKeys(options) ? options : { year: 'numeric', month: 'numeric', day: 'numeric' }).format(this);
+  };
+  Date.prototype.toLocaleTimeString = function(locales, options) {
+    return new DateTimeFormat(locales, hasOwnKeys(options) ? options : { hour: 'numeric', minute: 'numeric', second: 'numeric' }).format(this);
+  };
+})();
+)JS";
+
+} // namespace
+
+void IntlBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kIntlBootstrapScript, strlen(kIntlBootstrapScript),
+                            "<intl-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, result);
+}
+
+} // namespace margelo::nitro::nitrojsdom