@aircloudhq/web 1.0.0

package/src/helpers/sanitize-allowlist.js

@@ -0,0 +1,10 @@
+// Code generated by packages/npm/aircloud-web/tools/vendor-sanitizer.mjs from
+// vendor/rails-html-sanitizer (rails-html-sanitizer 1.7.1, loofah 2.25.2) — DO NOT EDIT.
+// The default allowlist of the Rails safe-list sanitizer and the URI rules of the Loofah scrubber it
+// delegates to; regenerated and compared byte-for-byte by test/unit/aircloud_web_package.bats.
+
+export const tags = Object.freeze(["a","abbr","acronym","address","b","big","blockquote","br","cite","code","dd","del","dfn","div","dl","dt","em","h1","h2","h3","h4","h5","h6","hr","i","img","ins","kbd","li","mark","ol","p","pre","samp","small","span","strong","sub","sup","time","tt","ul","var"]);
+export const attributes = Object.freeze(["abbr","alt","cite","class","datetime","height","href","lang","name","src","title","width","xml:lang"]);
+export const protocols = Object.freeze(["afs","aim","callto","data","ed2k","fax","ftp","gopher","http","https","irc","line","mailto","modem","news","nntp","rsync","rtsp","sftp","sms","ssh","tag","tel","telnet","urn","webcal","xmpp"]);
+export const dataMediaTypes = Object.freeze(["image/gif","image/jpeg","image/png","text/css","text/plain"]);
+export const uriAttributes = Object.freeze(["action","cite","href","longdesc","poster","preload","src","xlink:href","xml:base"]);

package/src/helpers/sanitize.js

@@ -0,0 +1,73 @@
+// ActionView::Helpers::SanitizeHelper with Rails' safe-list sanitizer: the default allowlist and the
+// URI rules are the vendored rails-html-sanitizer / Loofah data (sanitize-allowlist.js, generated).
+// Parsing uses the browser's HTML parser (a <template>), so the tree scrubbed is the tree a browser
+// would build. `sanitize` and `stripLinks` return markup; `stripTags` returns plain text (a React
+// text child is escaped by React — census § 4, output safety adapted).
+import { attributes as ALLOWED_ATTRIBUTES, dataMediaTypes, protocols, tags as ALLOWED_TAGS, uriAttributes } from './sanitize-allowlist.js';
+
+function parse(html) {
+  if (typeof document === 'undefined') throw new Error('sanitize: an HTML parser (document) is required');
+  const t = document.createElement('template');
+  t.innerHTML = String(html ?? '');
+  return t;
+}
+
+// Loofah CONTROL_CHARACTERS and its protocol grammar.
+const CONTROL = /[`\u0000- \u007F\s\u0080-ā]/g;
+const PROTOCOL = /^[a-z][a-z0-9+\-.]*(?::|&#0*58|&#x0*3a|(?:%|&#37;)3a)/i;
+const SEPARATOR = /:|&#0*58|&#x0*3a|(?:%|&#37;)3a/i;
+
+/** Loofah::HTML5::Scrub.allowed_uri? over an attribute value the parser already decoded. */
+export function allowedUri(value) {
+  const v = String(value).replace(CONTROL, '').toLowerCase();
+  if (!PROTOCOL.test(v)) return true;
+  const protocol = v.split(SEPARATOR)[0];
+  if (!protocols.includes(protocol)) return false;
+  if (protocol === 'data') {
+    const m = /^data:([^;,]*)/.exec(v);
+    return Boolean(m) && dataMediaTypes.includes(m[1]);
+  }
+  return true;
+}
+
+function scrub(node, tags, attrs) {
+  for (const child of [...node.childNodes]) {
+    if (child.nodeType === 3) continue; // text
+    if (child.nodeType === 1) {
+      scrub(child.content ?? child, tags, attrs); // bottom-up, as the PermitScrubber
+      const name = child.localName;
+      const foreign = child.namespaceURI && child.namespaceURI !== 'http://www.w3.org/1999/xhtml';
+      if (!tags.has(name) || foreign) {
+        // A foreign (svg/math) element is pruned with its content (namespace confusion); any other
+        // disallowed element is replaced by its children.
+        if (!foreign) child.replaceWith(...child.childNodes);
+        else child.remove();
+        continue;
+      }
+      for (const a of [...child.attributes]) {
+        if (!attrs.has(a.name) || (uriAttributes.includes(a.name) && !allowedUri(a.value))) child.removeAttribute(a.name);
+      }
+      continue;
+    }
+    child.remove(); // comments, processing instructions
+  }
+}
+
+/** sanitize(@article.body) — `tags` / `attributes` replace the default allowlist, as in Rails. */
+export function sanitize(html, options = {}) {
+  const t = parse(html);
+  scrub(t.content, new Set(options.tags ?? ALLOWED_TAGS), new Set(options.attributes ?? ALLOWED_ATTRIBUTES));
+  return t.innerHTML;
+}
+
+/** strip_tags("Strip <i>these</i> tags!") # => "Strip these tags!" */
+export function stripTags(html) {
+  return parse(html).content.textContent;
+}
+
+/** strip_links('<a href="http://www.rubyonrails.org">Ruby on Rails</a>') # => "Ruby on Rails" */
+export function stripLinks(html) {
+  const t = parse(html);
+  for (const a of [...t.content.querySelectorAll('a')]) a.replaceWith(...a.childNodes);
+  return t.innerHTML;
+}

package/src/helpers/tag.js

@@ -0,0 +1,37 @@
+// ActionView::RecordIdentifier (dom_id, dom_class) and TagHelper#token_list. A record's class is its
+// resource: the entity name is Rails' param_key (Flex names are already snake_case).
+
+function paramKey(resource) {
+  const name = typeof resource === 'string' ? resource : resource?.entity;
+  if (!name) throw new TypeError('domClass: a resource (entity name or projection resource) is required');
+  return name;
+}
+
+/** dom_class(post) # => "post"; dom_class(post, :edit) # => "edit_post" */
+export function domClass(resource, prefix) {
+  const key = paramKey(resource);
+  return prefix ? `${prefix}_${key}` : key;
+}
+
+/** dom_id(Post.find(45)) # => "post_45"; dom_id(Post.new) # => "new_post" */
+export function domId(resource, record, prefix) {
+  const id = record?.id;
+  if (id === undefined || id === null || id === '') return domClass(resource, prefix ?? 'new');
+  return `${domClass(resource, prefix)}_${id}`;
+}
+
+/** token_list("foo", { bar: true, baz: false }) # => "foo bar" */
+export function tokenList(...args) {
+  const out = [];
+  const add = (v) => {
+    if (v === null || v === undefined || v === false || v === '') return;
+    if (Array.isArray(v)) return v.forEach(add);
+    if (typeof v === 'object') {
+      for (const [k, on] of Object.entries(v)) if (on) add(k);
+      return;
+    }
+    for (const t of String(v).split(/\s+/)) if (t && !out.includes(t)) out.push(t);
+  };
+  args.forEach(add);
+  return out.join(' ');
+}

package/src/helpers/text.js

@@ -0,0 +1,143 @@
+// ActionView::Helpers::TextHelper at the census commit. `simpleFormat` and `highlight` return markup
+// (sanitized first, as in Rails); the others return plain text.
+import { i18nFor } from '../i18n/current.js';
+import { escapeHtml } from '../i18n/index.js';
+import { sanitize } from './sanitize.js';
+
+/** pluralize(2, "person") # => "2 people" — the locale's inflections (ADR-223). */
+export function pluralize(count, singular, plural, options = {}) {
+  const opts = typeof plural === 'object' && plural !== null ? plural : options;
+  const explicit = typeof plural === 'string' ? plural : opts.plural;
+  const i = i18nFor(opts);
+  if (i) return i.pluralize(count, singular, explicit);
+  const one = count === 1 || /^1(\.0+)?$/.test(String(count));
+  return `${count ?? 0} ${one ? singular : explicit ?? singular}`;
+}
+
+/** truncate("Once upon a time in a world far far away") # => "Once upon a time in a world..." */
+export function truncate(text, options = {}) {
+  const s = String(text ?? '');
+  const length = options.length ?? 30;
+  const omission = options.omission ?? '...';
+  if ([...s].length <= length) return s;
+  const chars = [...s];
+  let stop = length - [...omission].length;
+  if (stop < 0) stop = 0;
+  if (options.separator !== undefined && options.separator !== null) {
+    const head = chars.slice(0, stop + 1).join('');
+    const sep = options.separator;
+    let at = -1;
+    if (sep instanceof RegExp) {
+      const re = new RegExp(sep.source, sep.flags.includes('g') ? sep.flags : sep.flags + 'g');
+      for (const m of head.matchAll(re)) if (m.index <= stop) at = m.index;
+    } else {
+      at = head.lastIndexOf(sep, stop);
+    }
+    if (at >= 0) stop = [...head.slice(0, at)].length;
+  }
+  return chars.slice(0, stop).join('') + omission;
+}
+
+/** simple_format("Here is some basic text...\n...with a line break.") # => "<p>Here is some basic text...\n<br />...with a line break.</p>" */
+export function simpleFormat(text, htmlOptions = {}, options = {}) {
+  const wrapper = options.wrapperTag ?? options.wrapper_tag ?? 'p';
+  const s = options.sanitize === false ? String(text ?? '') : sanitize(String(text ?? ''), options.sanitizeOptions ?? {});
+  const attrs = Object.entries(htmlOptions)
+    .map(([k, v]) => ` ${k}="${escapeHtml(v)}"`)
+    .join('');
+  const paragraphs = s.replace(/\r\n?/g, '\n').split(/\n\n+/).filter((p) => p.length > 0);
+  if (paragraphs.length === 0) return `<${wrapper}${attrs}></${wrapper}>`;
+  return paragraphs
+    .map((p) => `<${wrapper}${attrs}>${p.replace(/([^\n]\n)(?=[^\n])/g, '$1<br />')}</${wrapper}>`)
+    .join('\n\n');
+}
+
+const escapeRegExp = (s) => String(s).replace(/[.*+?^${}()|[\]\\/-]/g, '\\$&');
+
+/** highlight("You searched for: rails", "rails") # => "You searched for: <mark>rails</mark>" */
+export function highlight(text, phrases, options = {}) {
+  const s = options.sanitize === false ? String(text ?? '') : sanitize(String(text ?? ''));
+  const list = (Array.isArray(phrases) ? phrases : [phrases]).filter((p) => p !== null && p !== undefined && String(p) !== '');
+  if (!s || list.length === 0) return s;
+  const highlighter = options.highlighter ?? '<mark>\\1</mark>';
+  const match = list.map((p) => (p instanceof RegExp ? p.source : escapeRegExp(p))).join('|');
+  return s.replace(new RegExp(`(${match})(?![^<]*?>)`, 'gi'), (_, m) => highlighter.replace(/\\1/g, m));
+}
+
+function cutExcerptPart(position, part, separator, options) {
+  if (part === undefined) return ['', ''];
+  const radius = options.radius ?? 100;
+  const omission = options.omission ?? '...';
+  let pieces = separator === '' ? [...part] : part.split(separator);
+  pieces = pieces.filter((p) => p !== '');
+  const affix = pieces.length > radius ? omission : '';
+  pieces = position === 'first' ? pieces.slice(Math.max(pieces.length - radius, 0)) : pieces.slice(0, radius);
+  return [affix, pieces.join(separator)];
+}
+
+/** excerpt("This is an example", "an", radius: 5) # => "...s is an exam..." */
+export function excerpt(text, phrase, options = {}) {
+  if (text === null || text === undefined || phrase === null || phrase === undefined) return undefined;
+  const separator = options.separator ?? '';
+  const regex = phrase instanceof RegExp ? phrase : new RegExp(escapeRegExp(phrase), 'i');
+  const matched = String(text).match(regex);
+  if (!matched) return undefined;
+  let found = matched[0];
+  if (separator !== '') {
+    const hit = String(text).split(separator).find((v) => regex.test(v));
+    if (hit !== undefined) found = hit;
+  }
+  const idx = String(text).indexOf(found);
+  const first = String(text).slice(0, idx);
+  const second = String(text).slice(idx + found.length);
+  const [prefix, firstPart] = cutExcerptPart('first', first, separator, options);
+  const [postfix, secondPart] = cutExcerptPart('second', second, separator, options);
+  const affix = [firstPart, separator, found, separator, secondPart].join('').trim();
+  return [prefix, affix, postfix].join('');
+}
+
+/** word_wrap("Once upon a time", line_width: 8) # => "Once\nupon a\ntime" */
+export function wordWrap(text, options = {}) {
+  const width = options.lineWidth ?? options.line_width ?? 80;
+  const brk = options.breakSequence ?? options.break_sequence ?? '\n';
+  return String(text ?? '')
+    .split('\n')
+    .map((line) =>
+      line.length > width
+        ? line.replace(new RegExp(`(.{1,${width}})(\\s+|$)`, 'g'), `$1${brk}`).replace(/\s+$/, '')
+        : line,
+    )
+    .join(brk);
+}
+
+const cycles = new Map();
+
+/** cycle("odd", "even") — alternates between its values on each call (one cycle per `name`). */
+export function cycle(...values) {
+  let name = 'default';
+  const last = values[values.length - 1];
+  if (last && typeof last === 'object' && !Array.isArray(last)) {
+    name = last.name ?? name;
+    values = values.slice(0, -1);
+  }
+  const key = JSON.stringify(values);
+  let c = cycles.get(name);
+  if (!c || c.key !== key) {
+    c = { key, values, index: 0 };
+    cycles.set(name, c);
+  }
+  const v = c.values[c.index];
+  c.index = (c.index + 1) % c.values.length;
+  return v;
+}
+
+/** reset_cycle(name) */
+export function resetCycle(name = 'default') {
+  cycles.delete(name);
+}
+
+/** current_cycle(name) */
+export function currentCycle(name = 'default') {
+  const c = cycles.get(name);
+  return c ? c.values[(c.index + c.values.length - 1) % c.values.length] : undefined;
+}

package/src/helpers/translation.js

@@ -0,0 +1,23 @@
+// ActionView::Helpers::TranslationHelper: `t`/`translate` and `l`/`localize` over the bound i18n
+// instance (the React I18nProvider binds it; the lazy scope of a page comes from the router wrapper
+// or `resourcePage`). The semantics are the i18n runtime's (contracts/deploy/v1/i18n-vectors.json).
+import { requireI18n } from '../i18n/current.js';
+
+/** t("membros.index.title") — or t(".title") inside a page (lazy lookup). */
+export function translate(key, options = {}) {
+  return requireI18n(options, 'translate').t(key, stripI18n(options));
+}
+
+/** l(Date.today, format: :long) */
+export function localize(value, options = {}) {
+  return requireI18n(options, 'localize').l(value, stripI18n(options));
+}
+
+export const t = translate;
+export const l = localize;
+
+function stripI18n(options) {
+  if (!options || !('i18n' in options)) return options;
+  const { i18n, ...rest } = options;
+  return rest;
+}

package/src/helpers/url.js

@@ -0,0 +1,86 @@
+// ActionView::Helpers::UrlHelper at the census commit: url_for, mail_to, sms_to, phone_to. The tag
+// helpers return markup (escaped attributes and content, as Rails' tag builder).
+//
+// **The locale travels in the URL** (ADR-223 D7; spec S4 § Locale negotiation): a same-origin URL
+// built while the current page carries a `locale` query parameter carries it forward, as Rails'
+// `default_url_options` does. Nothing stores the choice elsewhere.
+import { escapeHtml } from '../i18n/index.js';
+
+function currentLocation(options) {
+  if (options?.currentUrl) return new URL(String(options.currentUrl), 'http://x');
+  if (typeof location !== 'undefined') return new URL(location.href);
+  return undefined;
+}
+
+/**
+ * url_for — a path (or `{path, params, anchor}`) with the current page's `locale` parameter
+ * carried forward. An absolute URL to another origin is returned as given.
+ */
+export function urlFor(target, options = {}) {
+  const spec = typeof target === 'string' ? { path: target } : { ...target };
+  const here = currentLocation(options);
+  const base = here ? here.origin : 'http://x';
+  const url = new URL(spec.path ?? '', here ? here.href : 'http://x/');
+  if (url.origin !== base && /^[a-z][a-z0-9+.-]*:/i.test(spec.path ?? '')) return spec.path;
+  for (const [k, v] of Object.entries(spec.params ?? {})) {
+    if (v === undefined || v === null) url.searchParams.delete(k);
+    else url.searchParams.set(k, String(v));
+  }
+  const locale = here?.searchParams.get('locale');
+  if (locale && !url.searchParams.has('locale') && options.carryLocale !== false) url.searchParams.set('locale', locale);
+  if (spec.anchor) url.hash = spec.anchor;
+  return url.pathname + url.search + url.hash;
+}
+
+function attributes(html) {
+  return Object.entries(html ?? {})
+    .filter(([, v]) => v !== undefined && v !== null && v !== false)
+    .map(([k, v]) => (v === true ? ` ${k}` : ` ${k}="${escapeHtml(v)}"`))
+    .join('');
+}
+
+/** ERB::Util.url_encode: every byte outside [A-Za-z0-9_.~-] percent-encoded. */
+export function urlEncode(s) {
+  return encodeURIComponent(String(s)).replace(/[!'()*]/g, (c) => '%' + c.charCodeAt(0).toString(16).toUpperCase());
+}
+
+const present = (v) => v !== undefined && v !== null && v !== '';
+
+function split(name, htmlOptions) {
+  return typeof name === 'object' && name !== null ? [undefined, name] : [name, htmlOptions ?? {}];
+}
+
+/** mail_to "me@domain.com", "My email" # => <a href="mailto:me@domain.com">My email</a> */
+export function mailTo(email, name, htmlOptions) {
+  const [label, opts] = split(name, htmlOptions);
+  const { replyTo, ...rest } = opts;
+  const html = { ...rest };
+  if (present(replyTo)) html.reply_to = replyTo;
+  const extras = ['cc', 'bcc', 'body', 'subject', 'reply_to']
+    .filter((k) => present(html[k]))
+    .map((k) => `${k.replace('_', '-')}=${urlEncode(html[k])}`);
+  for (const k of ['cc', 'bcc', 'body', 'subject', 'reply_to']) delete html[k];
+  const href = `mailto:${urlEncode(email).replace(/%40/g, '@')}${extras.length ? '?' + extras.join('&') : ''}`;
+  return `<a${attributes({ ...html, href })}>${escapeHtml(label ?? email)}</a>`;
+}
+
+/** sms_to "5155555785", "Text me", body: "Hi" # => <a href="sms:5155555785;?&body=Hi">Text me</a> */
+export function smsTo(phoneNumber, name, htmlOptions) {
+  const [label, opts] = split(name, htmlOptions);
+  const { countryCode, country_code, body, ...html } = opts;
+  const cc = countryCode ?? country_code;
+  const code = present(cc) ? `+${urlEncode(cc)}` : '';
+  const b = present(body) ? `?&body=${urlEncode(body)}` : '';
+  return `<a${attributes({ ...html, href: `sms:${code}${urlEncode(phoneNumber)};${b}` })}>${escapeHtml(label ?? phoneNumber)}</a>`;
+}
+
+/** phone_to "1234567890", "Call me" # => <a href="tel:1234567890">Call me</a> */
+export function phoneTo(phoneNumber, name, htmlOptions) {
+  const [label, opts] = split(name, htmlOptions);
+  const { countryCode, country_code, ...html } = opts;
+  const cc = countryCode ?? country_code;
+  const code = cc === undefined || cc === null ? '' : `+${urlEncode(cc)}`;
+  return `<a${attributes({ ...html, href: `tel:${code}${urlEncode(phoneNumber)}` })}>${escapeHtml(label ?? phoneNumber)}</a>`;
+}
+
+export { attributes as htmlAttributes };

package/src/i18n/civil.js

@@ -0,0 +1,43 @@
+// Proleptic Gregorian civil-date arithmetic in whole days since 1970-01-01 (H. Hinnant's
+// days_from_civil / civil_from_days) — independent of the host's Date time-zone behaviour.
+
+export function floorDiv(a, b) {
+  return Math.floor(a / b);
+}
+
+export function daysFromCivil(y, m, d) {
+  const yy = m <= 2 ? y - 1 : y;
+  const era = floorDiv(yy, 400);
+  const yoe = yy - era * 400;
+  const mp = (m + 9) % 12;
+  const doy = Math.floor((153 * mp + 2) / 5) + d - 1;
+  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+  return era * 146097 + doe - 719468;
+}
+
+export function civilFromDays(days) {
+  const z = days + 719468;
+  const era = floorDiv(z, 146097);
+  const doe = z - era * 146097;
+  const yoe = Math.floor((doe - Math.floor(doe / 1460) + Math.floor(doe / 36524) - Math.floor(doe / 146096)) / 365);
+  const doy = doe - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100));
+  const mp = Math.floor((5 * doy + 2) / 153);
+  const d = doy - Math.floor((153 * mp + 2) / 5) + 1;
+  const m = mp < 10 ? mp + 3 : mp - 9;
+  const y = yoe + era * 400 + (m <= 2 ? 1 : 0);
+  return [y, m, d];
+}
+
+export function isLeap(y) {
+  return y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0);
+}
+
+/** 1-based day of the year. */
+export function dayOfYear(y, m, d) {
+  return daysFromCivil(y, m, d) - daysFromCivil(y, 1, 1) + 1;
+}
+
+/** 0 = Sunday. */
+export function weekdayOf(days) {
+  return (((days % 7) + 7 + 4) % 7);
+}

package/src/i18n/current.js

@@ -0,0 +1,25 @@
+// The i18n instance the helpers render with — Rails' I18n.locale, scoped to the page. The React
+// I18nProvider binds it; a framework-neutral caller binds it with setCurrentI18n, or passes `i18n`
+// in a helper's options.
+
+let current = null;
+
+export function setCurrentI18n(i18n) {
+  current = i18n;
+}
+
+export function currentI18n() {
+  return current;
+}
+
+/** The instance a helper call uses: its `i18n` option, else the bound one. */
+export function i18nFor(options) {
+  return options?.i18n ?? current;
+}
+
+/** Like i18nFor, but a helper that cannot render without translations refuses loudly. */
+export function requireI18n(options, helper) {
+  const i = i18nFor(options);
+  if (!i) throw new Error(`${helper}: no i18n instance is bound (I18nProvider, setCurrentI18n, or the i18n option)`);
+  return i;
+}

package/src/i18n/decimal.js

@@ -0,0 +1,109 @@
+// Exact decimal arithmetic on the digits of a number, so rounding is Ruby BigDecimal's half-up and
+// never a binary float's (ADR-223 D6: the JavaScript and Rust runtimes agree digit for digit).
+//
+// A decimal is { neg, int, frac } where int and frac are digit strings (int without leading zeros,
+// "0" for zero).
+
+/** Parse a number or a decimal string (optionally signed, optionally with an exponent). */
+export function parseDecimal(value) {
+  let s;
+  if (value && typeof value === 'object' && typeof value.int === 'string' && typeof value.frac === 'string') {
+    return { neg: Boolean(value.neg), int: value.int, frac: value.frac };
+  }
+  if (typeof value === 'number') {
+    if (!Number.isFinite(value)) throw new RangeError(`not a finite number: ${value}`);
+    s = String(value); // the shortest round-trip representation
+  } else if (typeof value === 'bigint') {
+    s = value.toString();
+  } else if (typeof value === 'string') {
+    s = value.trim();
+  } else {
+    throw new TypeError(`not a number: ${value}`);
+  }
+  const m = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/.exec(s);
+  if (!m || (m[2] === '' && (m[3] ?? '') === '')) throw new RangeError(`not a decimal: ${JSON.stringify(value)}`);
+  let int = m[2] || '0';
+  let frac = m[3] ?? '';
+  const exp = m[4] ? Number(m[4]) : 0;
+  if (exp > 0) {
+    const shift = frac.padEnd(exp, '0');
+    int += shift.slice(0, exp);
+    frac = shift.slice(exp);
+  } else if (exp < 0) {
+    const pad = int.padStart(-exp + 1, '0');
+    frac = pad.slice(pad.length + exp) + frac;
+    int = pad.slice(0, pad.length + exp);
+  }
+  int = int.replace(/^0+(?=\d)/, '');
+  const zero = /^0*$/.test(int) && /^0*$/.test(frac);
+  return { neg: m[1] === '-' && !zero, int, frac };
+}
+
+/** Round half-up (away from zero on a tie) to `precision` fraction digits; pads with zeros. */
+export function roundFixed(d, precision) {
+  if (precision < 0) throw new RangeError('negative precision');
+  if (d.frac.length <= precision) return { ...d, frac: d.frac.padEnd(precision, '0') };
+  const keep = d.int + d.frac.slice(0, precision);
+  const up = d.frac.charCodeAt(precision) >= 53; // '5'
+  let digits = up ? increment(keep) : keep;
+  const intLen = digits.length - precision;
+  const int = digits.slice(0, intLen).replace(/^0+(?=\d)/, '') || '0';
+  const frac = digits.slice(intLen);
+  const zero = /^0*$/.test(int) && /^0*$/.test(frac);
+  return { neg: d.neg && !zero, int, frac };
+}
+
+/** Round half-up to `digits` significant digits (Rails `significant: true`). */
+export function roundSignificant(d, digits) {
+  const all = (d.int + d.frac).replace(/^0+/, '');
+  if (all === '') return { ...d, frac: '' };
+  const intDigits = d.int === '0' ? 0 : d.int.length;
+  // position of the first significant digit relative to the decimal point
+  const leadingFracZeros = d.int === '0' ? d.frac.match(/^0*/)[0].length : 0;
+  const precision = intDigits > 0 ? Math.max(digits - intDigits, 0) : digits + leadingFracZeros;
+  if (intDigits > digits) {
+    // round the integer part itself
+    const scaled = { neg: d.neg, int: d.int.slice(0, digits), frac: d.int.slice(digits) + d.frac };
+    const r = roundFixed(scaled, 0);
+    return { neg: r.neg, int: r.int + '0'.repeat(intDigits - digits), frac: '' };
+  }
+  return roundFixed(d, precision);
+}
+
+function increment(digits) {
+  const a = digits.split('');
+  let i = a.length - 1;
+  while (i >= 0) {
+    if (a[i] === '9') {
+      a[i] = '0';
+      i -= 1;
+    } else {
+      a[i] = String.fromCharCode(a[i].charCodeAt(0) + 1);
+      return a.join('');
+    }
+  }
+  return '1' + a.join('');
+}
+
+/** Group the integer digits with `delimiter` every three digits. */
+export function delimit(int, delimiter) {
+  if (!delimiter) return int;
+  return int.replace(/\B(?=(\d{3})+(?!\d))/g, delimiter);
+}
+
+/** Compare a decimal to an integer. */
+export function isInteger(d) {
+  return /^0*$/.test(d.frac);
+}
+
+export function toNumber(d) {
+  return Number(`${d.neg ? '-' : ''}${d.int}${d.frac ? '.' + d.frac : ''}`);
+}
+
+export function abs(d) {
+  return { ...d, neg: false };
+}
+
+export function toPlain(d) {
+  return `${d.neg ? '-' : ''}${d.int}${d.frac ? '.' + d.frac : ''}`;
+}