@jomae/catalog 0.9.0 → 0.10.0

package/dist/rules/match-media.js

@@ -0,0 +1,36 @@
+export const matchMedia = {
+    id: "match-media",
+    title: "Reacting to a breakpoint",
+    category: "layout",
+    replaces: ["react-responsive", "react-media", "use-media", "enquire.js"],
+    featureIds: ["matchmedia"],
+    native: "matchMedia()",
+    human: {
+        explainer: "These libraries wrap one method. matchMedia() takes the same query string a stylesheet would, reports whether it matches now, and fires an event when that changes, with no resize listener and no width arithmetic. Most uses of them are styling rather than logic, and a media or container query in CSS handles those without JavaScript running at all.",
+        snippet: `const wide = matchMedia("(min-width: 48rem)");
+
+function apply(event) {
+  // Same shape for the initial read and every later change.
+  setColumns(event.matches ? 3 : 1);
+}
+
+apply(wide);
+wide.addEventListener("change", apply);`,
+        mdnUrl: "https://developer.mozilla.org/en-US/docs/Web/API/Window/matchMedia",
+    },
+    agent: {
+        when: "JavaScript needs to know whether a media query currently matches",
+        unless: [
+            "You server-render and need the first paint to be right. matchMedia does not exist on the server and the client's first read happens after hydration, so a wrong first frame or a mismatch warning is the failure mode these libraries put real work into avoiding.",
+            "You are changing appearance rather than behaviour. A media query or a container query does that in CSS, which is fewer moving parts than either the library or this API.",
+            "You query an element's size rather than the viewport's. matchMedia only answers about the viewport and the device, so a component that responds to its own box needs a container query or ResizeObserver.",
+            "The library's other features are in use, such as react-responsive's device-property shorthands or its context-based overriding for tests.",
+        ],
+        snippet: 'matchMedia("(min-width: 48rem)").matches;',
+        handRolled: [
+            "a resize listener comparing window.innerWidth against a breakpoint number kept in JavaScript",
+            "an isMobile flag held in state and recomputed from innerWidth inside a debounced resize handler",
+        ],
+    },
+};
+//# sourceMappingURL=match-media.js.map

package/dist/rules/match-media.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-media.js","sourceRoot":"","sources":["../../src/rules/match-media.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAAS;IAC9B,EAAE,EAAE,aAAa;IACjB,KAAK,EAAE,0BAA0B;IACjC,QAAQ,EAAE,QAAQ;IAClB,QAAQ,EAAE,CAAC,kBAAkB,EAAE,aAAa,EAAE,WAAW,EAAE,YAAY,CAAC;IACxE,UAAU,EAAE,CAAC,YAAY,CAAC;IAC1B,MAAM,EAAE,cAAc;IACtB,KAAK,EAAE;QACL,SAAS,EACP,8VAA8V;QAChW,OAAO,EAAE;;;;;;;;wCAQ2B;QACpC,MAAM,EACJ,oEAAoE;KACvE;IACD,KAAK,EAAE;QACL,IAAI,EAAE,kEAAkE;QACxE,MAAM,EAAE;YACN,oQAAoQ;YACpQ,0KAA0K;YAC1K,2MAA2M;YAC3M,2IAA2I;SAC5I;QACD,OAAO,EAAE,2CAA2C;QACpD,UAAU,EAAE;YACV,8FAA8F;YAC9F,iGAAiG;SAClG;KACF;CACF,CAAC"}

package/dist/rules/number-format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number-format.d.ts","sourceRoot":"","sources":["../../src/rules/number-format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,YAAY,EAAE,IAgC1B,CAAC"}
+{"version":3,"file":"number-format.d.ts","sourceRoot":"","sources":["../../src/rules/number-format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,YAAY,EAAE,IAyC1B,CAAC"}

package/dist/rules/number-format.js

@@ -2,7 +2,14 @@ export const numberFormat = {
     id: "number-format",
     title: "Locale-aware number and currency formatting",
     category: "formatting",
-    replaces: ["numeral", "accounting", "currency.js", "format-number"],
+    replaces: [
+        "numeral",
+        "accounting",
+        "currency.js",
+        "format-number",
+        "pretty-bytes",
+        "filesize",
+    ],
     featureIds: ["intl"],
     native: "Intl.NumberFormat",
     human: {
@@ -19,6 +26,8 @@ export const numberFormat = {
             'You format units or compact notation. style: "unit" and notation: "compact" arrived long after the rest of Intl.NumberFormat, in Chrome {{chrome:javascript.builtins.Intl.NumberFormat.NumberFormat.options_parameter.options_unit_parameter}}, Firefox {{firefox:javascript.builtins.Intl.NumberFormat.NumberFormat.options_parameter.options_unit_parameter}} and Safari {{safari:javascript.builtins.Intl.NumberFormat.NumberFormat.options_parameter.options_unit_parameter}}, so an older target does not get them.',
             "You need safe decimal arithmetic, such as adding money values without floating-point rounding errors. currency.js and accounting.js do that math for you; Intl.NumberFormat only formats a number you already computed correctly.",
             "You need to parse a formatted string back into a number. Intl.NumberFormat is format-only; these libraries often provide the reverse direction too.",
+            'You format byte sizes and need the unit chosen for you. Intl.NumberFormat formats a magnitude you already picked, so "kilobyte" on 1200 prints 1,200 kB rather than 1.2 MB, and dividing down to the right unit first is the part pretty-bytes and filesize actually do.',
+            "You need binary units. The sanctioned unit list has no kibibyte, mebibyte or gibibyte, and asking for one throws a RangeError rather than falling back, so anything reporting KiB or MiB keeps its library.",
             "You need a custom format pattern, such as a specific abbreviation style, that the options Intl.NumberFormat exposes cannot express.",
         ],
         snippet: 'new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" }).format(value);',

package/dist/rules/number-format.js.map

@@ -1 +1 @@
-{"version":3,"file":"number-format.js","sourceRoot":"","sources":["../../src/rules/number-format.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,YAAY,GAAS;IAChC,EAAE,EAAE,eAAe;IACnB,KAAK,EAAE,6CAA6C;IACpD,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,eAAe,CAAC;IACnE,UAAU,EAAE,CAAC,MAAM,CAAC;IACpB,MAAM,EAAE,mBAAmB;IAC3B,KAAK,EAAE;QACL,SAAS,EACP,wZAAwZ;QAC1Z,OAAO,EAAE;;;kCAGqB;QAC9B,MAAM,EACJ,oGAAoG;KACvG;IACD,KAAK,EAAE;QACL,IAAI,EAAE,yGAAyG;QAC/G,MAAM,EAAE;YACN,0fAA0f;YAC1f,mOAAmO;YACnO,qJAAqJ;YACrJ,qIAAqI;SACtI;QACD,OAAO,EACL,uFAAuF;QACzF,UAAU,EAAE;YACV,oEAAoE;YACpE,kFAAkF;SACnF;KACF;CACF,CAAC"}
+{"version":3,"file":"number-format.js","sourceRoot":"","sources":["../../src/rules/number-format.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,YAAY,GAAS;IAChC,EAAE,EAAE,eAAe;IACnB,KAAK,EAAE,6CAA6C;IACpD,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE;QACR,SAAS;QACT,YAAY;QACZ,aAAa;QACb,eAAe;QACf,cAAc;QACd,UAAU;KACX;IACD,UAAU,EAAE,CAAC,MAAM,CAAC;IACpB,MAAM,EAAE,mBAAmB;IAC3B,KAAK,EAAE;QACL,SAAS,EACP,wZAAwZ;QAC1Z,OAAO,EAAE;;;kCAGqB;QAC9B,MAAM,EACJ,oGAAoG;KACvG;IACD,KAAK,EAAE;QACL,IAAI,EAAE,yGAAyG;QAC/G,MAAM,EAAE;YACN,0fAA0f;YAC1f,mOAAmO;YACnO,qJAAqJ;YACrJ,0QAA0Q;YAC1Q,6MAA6M;YAC7M,qIAAqI;SACtI;QACD,OAAO,EACL,uFAAuF;QACzF,UAAU,EAAE;YACV,oEAAoE;YACpE,kFAAkF;SACnF;KACF;CACF,CAAC"}

package/dist/rules/passkeys.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "../schema.ts";
+export declare const passkeys: Rule;
+//# sourceMappingURL=passkeys.d.ts.map

package/dist/rules/passkeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"passkeys.d.ts","sourceRoot":"","sources":["../../src/rules/passkeys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,QAAQ,EAAE,IA6CtB,CAAC"}

package/dist/rules/passkeys.js

@@ -0,0 +1,44 @@
+export const passkeys = {
+    id: "passkeys",
+    title: "Passkeys in the browser",
+    category: "device-apis",
+    replaces: ["@simplewebauthn/browser"],
+    featureIds: [],
+    manualBaseline: {
+        status: "newly",
+        verifiedOn: "2026-09-20",
+        note: "web-features has no ID for the JSON helpers this rule turns on, and they sit inside the 'webauthn' feature's own compat data rather than beside it. Deriving from that ID would badge this widely available on the ceremony's dates, Safari {{safari:webauthn}}, while the parseCreationOptionsFromJSON and toJSON calls that remove the need for a wrapper arrived in Safari {{safari:api.PublicKeyCredential.parseCreationOptionsFromJSON_static}}, Chrome {{chrome:api.PublicKeyCredential.parseCreationOptionsFromJSON_static}} and Firefox {{firefox:api.PublicKeyCredential.parseCreationOptionsFromJSON_static}}. Newly available on the helpers' own dates: the last engine shipped them in March 2025.",
+    },
+    native: "navigator.credentials with PublicKeyCredential",
+    human: {
+        explainer: "The browser half of a passkey flow is two calls: create() to register a credential and get() to sign a challenge. The reason a wrapper existed is that both used to need every challenge and id field converted to and from base64url by hand. parseCreationOptionsFromJSON and toJSON now do that conversion in the browser, so the server's JSON goes in and the response comes back out in the same shape.",
+        snippet: `// The server sends JSON; the browser parses it into the
+// ArrayBuffer-shaped options the call expects.
+const options = PublicKeyCredential.parseCreationOptionsFromJSON(fromServer);
+const credential = await navigator.credentials.create({
+  publicKey: options,
+});
+
+// And back to JSON for the response, without hand-rolled base64url.
+await fetch("/register", {
+  method: "POST",
+  body: JSON.stringify(credential.toJSON()),
+});`,
+        mdnUrl: "https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API",
+    },
+    agent: {
+        when: "registering or authenticating a passkey from the browser",
+        unless: [
+            "Your support target reaches below Chrome {{chrome:api.PublicKeyCredential.parseCreationOptionsFromJSON_static}}, Firefox {{firefox:api.PublicKeyCredential.parseCreationOptionsFromJSON_static}} or Safari {{safari:api.PublicKeyCredential.parseCreationOptionsFromJSON_static}}. The ceremony itself is years older than those, so the credential calls work while the JSON helpers that make the wrapper unnecessary do not, and the base64url conversion comes back.",
+            "You use the library's server package as well. @simplewebauthn/server generates and verifies the challenge, and the platform has no counterpart for that: this covers the browser side only.",
+            "You rely on the library's browser-capability helpers, such as its checks for a platform authenticator or for conditional UI, which are feature detection it has already written.",
+            "You need the same code path on a browser where conditional mediation behaves differently, which the library smooths over and the raw call does not.",
+        ],
+        snippet: "const credential = await navigator.credentials.get({ publicKey: options });",
+        handRolled: [
+            "base64url encode and decode helpers written next to a credentials.create call to convert challenge and id fields",
+            "a Uint8Array built by looping over atob output to turn a server challenge into bytes",
+        ],
+    },
+};
+//# sourceMappingURL=passkeys.js.map

package/dist/rules/passkeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"passkeys.js","sourceRoot":"","sources":["../../src/rules/passkeys.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAS;IAC5B,EAAE,EAAE,UAAU;IACd,KAAK,EAAE,yBAAyB;IAChC,QAAQ,EAAE,aAAa;IACvB,QAAQ,EAAE,CAAC,yBAAyB,CAAC;IACrC,UAAU,EAAE,EAAE;IACd,cAAc,EAAE;QACd,MAAM,EAAE,OAAO;QACf,UAAU,EAAE,YAAY;QACxB,IAAI,EAAE,irBAAirB;KACxrB;IACD,MAAM,EAAE,gDAAgD;IACxD,KAAK,EAAE;QACL,SAAS,EACP,+YAA+Y;QACjZ,OAAO,EAAE;;;;;;;;;;;IAWT;QACA,MAAM,EACJ,yEAAyE;KAC5E;IACD,KAAK,EAAE;QACL,IAAI,EAAE,0DAA0D;QAChE,MAAM,EAAE;YACN,0cAA0c;YAC1c,6LAA6L;YAC7L,kLAAkL;YAClL,qJAAqJ;SACtJ;QACD,OAAO,EACL,6EAA6E;QAC/E,UAAU,EAAE;YACV,kHAAkH;YAClH,sFAAsF;SACvF;KACF;CACF,CAAC"}

package/dist/rules/plural-rules.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "../schema.ts";
+export declare const pluralRules: Rule;
+//# sourceMappingURL=plural-rules.d.ts.map

package/dist/rules/plural-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plural-rules.d.ts","sourceRoot":"","sources":["../../src/rules/plural-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,WAAW,EAAE,IAkCzB,CAAC"}

package/dist/rules/plural-rules.js

@@ -0,0 +1,33 @@
+export const pluralRules = {
+    id: "plural-rules",
+    title: "Choosing a plural form",
+    category: "formatting",
+    replaces: ["pluralize"],
+    featureIds: ["intl-plural-rules"],
+    native: "Intl.PluralRules",
+    human: {
+        explainer: 'Picking between "1 file" and "2 files" by testing count === 1 is only correct in English, and barely. Russian needs one form for 3 and another for 5, and Polish and Arabic have more. Intl.PluralRules answers which category a number falls into for a locale, so the branching stops being a guess. It returns the category rather than the word, which is the part worth knowing before reaching for it.',
+        snippet: `const pr = new Intl.PluralRules("en-US");
+const forms = { one: "file", other: "files" };
+\`\${count} \${forms[pr.select(count)]}\`; // "1 file", "2 files"
+
+// Ordinals are the same API with a different type.
+new Intl.PluralRules("en-US", { type: "ordinal" }).select(22); // "two"`,
+        mdnUrl: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules",
+    },
+    agent: {
+        when: "choosing between singular and plural wording for a count",
+        unless: [
+            'You need the plural word itself. Intl.PluralRules returns a category such as "one" or "other" and never inflects anything, so "person" to "people" and "index" to "indices" still need pluralize or a table of your own. This is the difference that decides most cases.',
+            "You pluralise arbitrary nouns you do not control, such as user-supplied or database-driven labels. A category is only useful when you already hold both forms, which you cannot if the noun is unknown at build time.",
+            "You singularise as well as pluralise. pluralize goes both directions and this API goes neither.",
+            "Your strings already run through an ICU message catalogue. It has plural selection built in and doing it twice is how the two disagree.",
+        ],
+        snippet: 'new Intl.PluralRules(locale).select(count); // "one" | "other" | ...',
+        handRolled: [
+            'a count === 1 ternary picking between two words, or a bare + "s" appended to a noun',
+            "a lookup of irregular plurals kept next to the component that renders them",
+        ],
+    },
+};
+//# sourceMappingURL=plural-rules.js.map

package/dist/rules/plural-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plural-rules.js","sourceRoot":"","sources":["../../src/rules/plural-rules.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,WAAW,GAAS;IAC/B,EAAE,EAAE,cAAc;IAClB,KAAK,EAAE,wBAAwB;IAC/B,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,CAAC,WAAW,CAAC;IACvB,UAAU,EAAE,CAAC,mBAAmB,CAAC;IACjC,MAAM,EAAE,kBAAkB;IAC1B,KAAK,EAAE;QACL,SAAS,EACP,8YAA8Y;QAChZ,OAAO,EAAE;;;;;wEAK2D;QACpE,MAAM,EACJ,mGAAmG;KACtG;IACD,KAAK,EAAE;QACL,IAAI,EAAE,0DAA0D;QAChE,MAAM,EAAE;YACN,0QAA0Q;YAC1Q,uNAAuN;YACvN,iGAAiG;YACjG,yIAAyI;SAC1I;QACD,OAAO,EACL,sEAAsE;QACxE,UAAU,EAAE;YACV,qFAAqF;YACrF,4EAA4E;SAC7E;KACF;CACF,CAAC"}

package/dist/rules/pointer-events.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "../schema.ts";
+export declare const pointerEvents: Rule;
+//# sourceMappingURL=pointer-events.d.ts.map

package/dist/rules/pointer-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer-events.d.ts","sourceRoot":"","sources":["../../src/rules/pointer-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,aAAa,EAAE,IA2C3B,CAAC"}

package/dist/rules/pointer-events.js

@@ -0,0 +1,43 @@
+export const pointerEvents = {
+    id: "pointer-events",
+    title: "Touch and pointer gestures",
+    category: "device-apis",
+    replaces: ["hammerjs", "react-swipeable", "swiped-events"],
+    featureIds: ["pointer-events-api"],
+    native: "pointer events with touch-action",
+    human: {
+        explainer: "hammerjs was written when mouse and touch were separate event streams that had to be normalised, and it has not been maintained since 2016. Pointer events deliver both through one set of handlers, with pointerId to tell fingers apart and setPointerCapture so a drag keeps reporting after the pointer leaves the element. A swipe is a pointerdown coordinate, a pointerup coordinate, and a threshold.",
+        snippet: `let startX = 0;
+
+el.addEventListener("pointerdown", (event) => {
+  startX = event.clientX;
+  // Keeps events coming even if the pointer leaves the element.
+  el.setPointerCapture(event.pointerId);
+});
+
+el.addEventListener("pointerup", (event) => {
+  const dx = event.clientX - startX;
+  if (Math.abs(dx) > 50) onSwipe(dx > 0 ? "right" : "left");
+});
+
+// Tell the browser which direction you are handling, so it keeps
+// vertical scrolling for itself. In CSS: touch-action: pan-y.
+el.style.touchAction = "pan-y";`,
+        mdnUrl: "https://developer.mozilla.org/en-US/docs/Web/API/Pointer_events",
+    },
+    agent: {
+        when: "handling swipes, drags or other pointer gestures",
+        unless: [
+            "You need multi-touch recognisers such as pinch to zoom or two-finger rotate. Tracking several pointerIds and deriving the transform between them is real geometry, and it is most of what hammerjs is.",
+            "You need velocity, direction and threshold tuning that already feels right. A naive distance check fires on a slow drag that was never meant as a swipe, and the tuned version is the library's actual value.",
+            "You rely on hammerjs recognisers with conflict resolution between them, such as pan and swipe on the same element, where the ordering is configured rather than written.",
+            "Your support target reaches below Chrome {{chrome:pointer-events-api}}, Firefox {{firefox:pointer-events-api}} or Safari {{safari:pointer-events-api}}, which came to pointer events considerably later than the others.",
+        ],
+        snippet: 'el.addEventListener("pointerdown", (e) => el.setPointerCapture(e.pointerId));',
+        handRolled: [
+            "paired touchstart and touchend listeners reading changedTouches[0].clientX to work out a swipe direction",
+            "separate mousedown and touchstart branches doing the same thing, written because the two event streams disagree",
+        ],
+    },
+};
+//# sourceMappingURL=pointer-events.js.map

package/dist/rules/pointer-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer-events.js","sourceRoot":"","sources":["../../src/rules/pointer-events.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,aAAa,GAAS;IACjC,EAAE,EAAE,gBAAgB;IACpB,KAAK,EAAE,4BAA4B;IACnC,QAAQ,EAAE,aAAa;IACvB,QAAQ,EAAE,CAAC,UAAU,EAAE,iBAAiB,EAAE,eAAe,CAAC;IAC1D,UAAU,EAAE,CAAC,oBAAoB,CAAC;IAClC,MAAM,EAAE,kCAAkC;IAC1C,KAAK,EAAE;QACL,SAAS,EACP,+YAA+Y;QACjZ,OAAO,EAAE;;;;;;;;;;;;;;;gCAemB;QAC5B,MAAM,EAAE,iEAAiE;KAC1E;IACD,KAAK,EAAE;QACL,IAAI,EAAE,kDAAkD;QACxD,MAAM,EAAE;YACN,wMAAwM;YACxM,+MAA+M;YAC/M,0KAA0K;YAC1K,0NAA0N;SAC3N;QACD,OAAO,EACL,+EAA+E;QACjF,UAAU,EAAE;YACV,0GAA0G;YAC1G,iHAAiH;SAClH;KACF;CACF,CAAC"}

package/dist/rules/progress-indicator.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "../schema.ts";
+export declare const progressIndicator: Rule;
+//# sourceMappingURL=progress-indicator.d.ts.map

package/dist/rules/progress-indicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-indicator.d.ts","sourceRoot":"","sources":["../../src/rules/progress-indicator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,iBAAiB,EAAE,IAuC/B,CAAC"}

package/dist/rules/progress-indicator.js

@@ -0,0 +1,39 @@
+export const progressIndicator = {
+    id: "progress-indicator",
+    title: "Spinners and progress bars",
+    category: "forms",
+    replaces: ["react-spinners", "spinkit", "react-loader-spinner", "ldrs"],
+    featureIds: ["progress"],
+    native: "<progress>",
+    human: {
+        explainer: "A progress element with a value draws a determinate bar, and the same element with the value removed draws the indeterminate one, which is the browser's own spinner. It carries the right role and reports its value to assistive technology without any aria being written by hand, which is the part the div-and-keyframes version usually gets wrong. Styling it is CSS on the element and its two pseudo-elements.",
+        snippet: `<!-- Determinate. -->
+<progress value="0.7">70%</progress>
+
+<!-- Indeterminate: no value attribute at all. -->
+<progress></progress>
+
+<style>
+  progress { inline-size: 12rem; block-size: 0.5rem; }
+  /* The track and the filled part, in WebKit and Blink. */
+  progress::-webkit-progress-bar { background: #eee; }
+  progress::-webkit-progress-value { background: currentColor; }
+</style>`,
+        mdnUrl: "https://developer.mozilla.org/en-US/docs/Web/HTML/Element/progress",
+    },
+    agent: {
+        when: "showing that work is happening, or how far along it is",
+        unless: [
+            "You need a circular ring. The element draws a bar, and the pseudo-elements that style it are not a shape you can bend into an arc, so a ring is still SVG or a conic-gradient on your own markup.",
+            "The design is a branded multi-part animation, such as bouncing dots or a pulsing logo. Those are several moving elements and a progress element is one.",
+            "You need a page-level loading bar tied to route changes, which is what nprogress is: the visual is trivial and the router integration and its timing are the library.",
+            "Your styling has to match across engines exactly. The pseudo-elements differ between Blink, WebKit and Gecko, and accent-color only recolours the default rendering rather than restyling it.",
+        ],
+        snippet: "<progress></progress> <!-- indeterminate -->",
+        handRolled: [
+            "a div with a CSS keyframe rotation and a border-radius, standing in for a spinner, usually with no role or aria-label",
+            "a wrapper div whose inline width is set to a percentage string to draw a filled bar",
+        ],
+    },
+};
+//# sourceMappingURL=progress-indicator.js.map

package/dist/rules/progress-indicator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-indicator.js","sourceRoot":"","sources":["../../src/rules/progress-indicator.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,iBAAiB,GAAS;IACrC,EAAE,EAAE,oBAAoB;IACxB,KAAK,EAAE,4BAA4B;IACnC,QAAQ,EAAE,OAAO;IACjB,QAAQ,EAAE,CAAC,gBAAgB,EAAE,SAAS,EAAE,sBAAsB,EAAE,MAAM,CAAC;IACvE,UAAU,EAAE,CAAC,UAAU,CAAC;IACxB,MAAM,EAAE,YAAY;IACpB,KAAK,EAAE;QACL,SAAS,EACP,yZAAyZ;QAC3Z,OAAO,EAAE;;;;;;;;;;;SAWJ;QACL,MAAM,EACJ,oEAAoE;KACvE;IACD,KAAK,EAAE;QACL,IAAI,EAAE,wDAAwD;QAC9D,MAAM,EAAE;YACN,mMAAmM;YACnM,yJAAyJ;YACzJ,uKAAuK;YACvK,+LAA+L;SAChM;QACD,OAAO,EAAE,8CAA8C;QACvD,UAAU,EAAE;YACV,uHAAuH;YACvH,qFAAqF;SACtF;KACF;CACF,CAAC"}

package/dist/rules/screen-wake-lock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"screen-wake-lock.d.ts","sourceRoot":"","sources":["../../src/rules/screen-wake-lock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,cAAc,EAAE,IAyB5B,CAAC"}
+{"version":3,"file":"screen-wake-lock.d.ts","sourceRoot":"","sources":["../../src/rules/screen-wake-lock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,cAAc,EAAE,IA6B5B,CAAC"}

package/dist/rules/screen-wake-lock.js

@@ -20,6 +20,10 @@ await lock.release();`,
             "You need this in a non-secure (non-HTTPS) context, where the API isn't available at all.",
         ],
         snippet: `const lock = await navigator.wakeLock.request("screen");`,
+        handRolled: [
+            "a muted looping video kept playing off-screen so the display does not sleep",
+            "a no-op setInterval added in the hope the page keeps counting as active",
+        ],
     },
 };
 //# sourceMappingURL=screen-wake-lock.js.map

package/dist/rules/screen-wake-lock.js.map

@@ -1 +1 @@
-{"version":3,"file":"screen-wake-lock.js","sourceRoot":"","sources":["../../src/rules/screen-wake-lock.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,cAAc,GAAS;IAClC,EAAE,EAAE,kBAAkB;IACtB,KAAK,EAAE,0BAA0B;IACjC,QAAQ,EAAE,aAAa;IACvB,QAAQ,EAAE,CAAC,YAAY,EAAE,qBAAqB,CAAC;IAC/C,UAAU,EAAE,CAAC,kBAAkB,CAAC;IAChC,MAAM,EAAE,sCAAsC;IAC9C,KAAK,EAAE;QACL,SAAS,EACP,0RAA0R;QAC5R,OAAO,EAAE;;sBAES;QAClB,MAAM,EACJ,uEAAuE;KAC1E;IACD,KAAK,EAAE;QACL,IAAI,EAAE,4GAA4G;QAClH,MAAM,EAAE;YACN,sNAAsN;YACtN,2MAA2M;YAC3M,0FAA0F;SAC3F;QACD,OAAO,EAAE,0DAA0D;KACpE;CACF,CAAC"}
+{"version":3,"file":"screen-wake-lock.js","sourceRoot":"","sources":["../../src/rules/screen-wake-lock.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,cAAc,GAAS;IAClC,EAAE,EAAE,kBAAkB;IACtB,KAAK,EAAE,0BAA0B;IACjC,QAAQ,EAAE,aAAa;IACvB,QAAQ,EAAE,CAAC,YAAY,EAAE,qBAAqB,CAAC;IAC/C,UAAU,EAAE,CAAC,kBAAkB,CAAC;IAChC,MAAM,EAAE,sCAAsC;IAC9C,KAAK,EAAE;QACL,SAAS,EACP,0RAA0R;QAC5R,OAAO,EAAE;;sBAES;QAClB,MAAM,EACJ,uEAAuE;KAC1E;IACD,KAAK,EAAE;QACL,IAAI,EAAE,4GAA4G;QAClH,MAAM,EAAE;YACN,sNAAsN;YACtN,2MAA2M;YAC3M,0FAA0F;SAC3F;QACD,OAAO,EAAE,0DAA0D;QACnE,UAAU,EAAE;YACV,6EAA6E;YAC7E,yEAAyE;SAC1E;KACF;CACF,CAAC"}

package/dist/rules/scroll-into-view.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "../schema.ts";
+export declare const scrollIntoView: Rule;
+//# sourceMappingURL=scroll-into-view.d.ts.map

package/dist/rules/scroll-into-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-into-view.d.ts","sourceRoot":"","sources":["../../src/rules/scroll-into-view.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,cAAc,EAAE,IAsC5B,CAAC"}

package/dist/rules/scroll-into-view.js

@@ -0,0 +1,38 @@
+export const scrollIntoView = {
+    id: "scroll-into-view",
+    title: "Scrolling an element into view",
+    category: "scrolling",
+    replaces: [
+        "scroll-into-view-if-needed",
+        "compute-scroll-into-view",
+        "smooth-scroll-into-view-if-needed",
+    ],
+    featureIds: ["scroll-into-view"],
+    native: 'scrollIntoView({ block: "nearest" })',
+    human: {
+        explainer: 'These packages exist for one behaviour: scroll only if the element is not already visible, and scroll as little as possible when it is not. That is what block: "nearest" does, in every engine. The default is block: "start", which always scrolls and is why the native method got a reputation for being too blunt, so the option is the whole difference.',
+        snippet: `// Scrolls only as far as it has to, and not at all if the
+// option is already visible. Ideal for keyboard navigation.
+option.scrollIntoView({
+  block: "nearest",
+  inline: "nearest",
+  behavior: "smooth",
+});`,
+        mdnUrl: "https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView",
+    },
+    agent: {
+        when: "bringing an element into view, typically a highlighted option or a focused row",
+        unless: [
+            "You need the scroll offset computed without applying it. That is what compute-scroll-into-view is for on its own, and a virtualised list that batches its own scrolling genuinely needs the number rather than the movement.",
+            'You need a specific duration or easing. behavior: "smooth" exposes neither, and the browser picks both.',
+            "You must scroll several containers to a coordinated position. The native method walks its own ancestors on its own terms, so a scroll that has to stay in step across panes needs the offsets.",
+            "Your support target reaches below Chrome {{chrome:api.Element.scrollIntoView.options_parameter}}, Firefox {{firefox:api.Element.scrollIntoView.options_parameter}} or Safari {{safari:api.Element.scrollIntoView.options_parameter}}. The method is far older than that, so scrollIntoView() existing is not proof the options object is read.",
+        ],
+        snippet: 'el.scrollIntoView({ block: "nearest" });',
+        handRolled: [
+            "getBoundingClientRect on an element and its scroll container, compared to decide whether to set scrollTop",
+            "a scrollTop assignment computed from offsetTop minus the container's height, to centre a highlighted item",
+        ],
+    },
+};
+//# sourceMappingURL=scroll-into-view.js.map

package/dist/rules/scroll-into-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-into-view.js","sourceRoot":"","sources":["../../src/rules/scroll-into-view.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,cAAc,GAAS;IAClC,EAAE,EAAE,kBAAkB;IACtB,KAAK,EAAE,gCAAgC;IACvC,QAAQ,EAAE,WAAW;IACrB,QAAQ,EAAE;QACR,4BAA4B;QAC5B,0BAA0B;QAC1B,mCAAmC;KACpC;IACD,UAAU,EAAE,CAAC,kBAAkB,CAAC;IAChC,MAAM,EAAE,sCAAsC;IAC9C,KAAK,EAAE;QACL,SAAS,EACP,gWAAgW;QAClW,OAAO,EAAE;;;;;;IAMT;QACA,MAAM,EACJ,yEAAyE;KAC5E;IACD,KAAK,EAAE;QACL,IAAI,EAAE,gFAAgF;QACtF,MAAM,EAAE;YACN,8NAA8N;YAC9N,yGAAyG;YACzG,gMAAgM;YAChM,gVAAgV;SACjV;QACD,OAAO,EAAE,0CAA0C;QACnD,UAAU,EAAE;YACV,2GAA2G;YAC3G,2GAA2G;SAC5G;KACF;CACF,CAAC"}

package/dist/rules/segmenter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"segmenter.d.ts","sourceRoot":"","sources":["../../src/rules/segmenter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,SAAS,EAAE,IAyCvB,CAAC"}
+{"version":3,"file":"segmenter.d.ts","sourceRoot":"","sources":["../../src/rules/segmenter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,SAAS,EAAE,IA6CvB,CAAC"}

package/dist/rules/segmenter.js

@@ -36,6 +36,10 @@ const words = new Intl.Segmenter("en", { granularity: "word" });
         ],
         snippet: `const seg = new Intl.Segmenter("en", { granularity: "grapheme" });
 const count = [...seg.segment(text)].length;`,
+        handRolled: [
+            'str.length or split("") used to count characters, which counts an emoji or a combining accent as several',
+            "a regex over surrogate pairs to split a string into what the author is calling characters",
+        ],
     },
 };
 //# sourceMappingURL=segmenter.js.map

package/dist/rules/segmenter.js.map

@@ -1 +1 @@
-{"version":3,"file":"segmenter.js","sourceRoot":"","sources":["../../src/rules/segmenter.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAS;IAC7B,EAAE,EAAE,gBAAgB;IACpB,KAAK,EAAE,qCAAqC;IAC5C,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE;QACR,WAAW;QACX,mBAAmB;QACnB,eAAe;QACf,cAAc;QACd,iBAAiB;KAClB;IACD,UAAU,EAAE,CAAC,gBAAgB,CAAC;IAC9B,MAAM,EAAE,gBAAgB;IACxB,KAAK,EAAE;QACL,SAAS,EACP,2cAA2c;QAC7c,OAAO,EAAE;;;;;;;;;sBASS;QAClB,MAAM,EACJ,iGAAiG;KACpG;IACD,KAAK,EAAE;QACL,IAAI,EAAE,sFAAsF;QAC5F,MAAM,EAAE;YACN,sLAAsL;YACtL,6JAA6J;YAC7J,gLAAgL;YAChL,2HAA2H;YAC3H,+MAA+M;SAChN;QACD,OAAO,EAAE;6CACgC;KAC1C;CACF,CAAC"}
+{"version":3,"file":"segmenter.js","sourceRoot":"","sources":["../../src/rules/segmenter.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAS;IAC7B,EAAE,EAAE,gBAAgB;IACpB,KAAK,EAAE,qCAAqC;IAC5C,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE;QACR,WAAW;QACX,mBAAmB;QACnB,eAAe;QACf,cAAc;QACd,iBAAiB;KAClB;IACD,UAAU,EAAE,CAAC,gBAAgB,CAAC;IAC9B,MAAM,EAAE,gBAAgB;IACxB,KAAK,EAAE;QACL,SAAS,EACP,2cAA2c;QAC7c,OAAO,EAAE;;;;;;;;;sBASS;QAClB,MAAM,EACJ,iGAAiG;KACpG;IACD,KAAK,EAAE;QACL,IAAI,EAAE,sFAAsF;QAC5F,MAAM,EAAE;YACN,sLAAsL;YACtL,6JAA6J;YAC7J,gLAAgL;YAChL,2HAA2H;YAC3H,+MAA+M;SAChN;QACD,OAAO,EAAE;6CACgC;QACzC,UAAU,EAAE;YACV,0GAA0G;YAC1G,2FAA2F;SAC5F;KACF;CACF,CAAC"}

package/dist/rules/select.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/rules/select.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,MAAM,EAAE,IAyEpB,CAAC"}
+{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/rules/select.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,MAAM,EAAE,IA0EpB,CAAC"}

package/dist/rules/select.js

@@ -68,6 +68,7 @@ export const select = {
         "animated-select-picker",
         "branded-select-styling",
         "custom-select-picker-layouts",
+        "rich-media-picker",
         "select-menu-interaction",
     ],
 };

package/dist/rules/select.js.map

@@ -1 +1 @@
-{"version":3,"file":"select.js","sourceRoot":"","sources":["../../src/rules/select.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAS;IAC1B,EAAE,EAAE,qBAAqB;IACzB,KAAK,EAAE,qBAAqB;IAC5B,QAAQ,EAAE,OAAO;IACjB,QAAQ,EAAE;QACR,cAAc;QACd,YAAY;QACZ,SAAS;QACT,YAAY;QACZ,YAAY;QACZ,iBAAiB;QACjB,sBAAsB;QACtB,eAAe;KAChB;IACD,UAAU,EAAE,CAAC,qBAAqB,CAAC;IACnC,MAAM,EAAE,qCAAqC;IAC7C,KAAK,EAAE;QACL,SAAS,EACP,+YAA+Y;QACjZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;SA0BJ;QACL,MAAM,EAAE,6DAA6D;KACtE;IACD,KAAK,EAAE;QACL,IAAI,EAAE,4EAA4E;QAClF,MAAM,EAAE;YACN,0LAA0L;YAC1L,qFAAqF;YACrF,gLAAgL;YAChL,qEAAqE;SACtE;QACD,OAAO,EAAE;;;;;;SAMJ;QACL,UAAU,EAAE;YACV,8FAA8F;SAC/F;KACF;IACD,MAAM,EAAE;QACN,wBAAwB;QACxB,wBAAwB;QACxB,8BAA8B;QAC9B,yBAAyB;KAC1B;CACF,CAAC"}
+{"version":3,"file":"select.js","sourceRoot":"","sources":["../../src/rules/select.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,MAAM,GAAS;IAC1B,EAAE,EAAE,qBAAqB;IACzB,KAAK,EAAE,qBAAqB;IAC5B,QAAQ,EAAE,OAAO;IACjB,QAAQ,EAAE;QACR,cAAc;QACd,YAAY;QACZ,SAAS;QACT,YAAY;QACZ,YAAY;QACZ,iBAAiB;QACjB,sBAAsB;QACtB,eAAe;KAChB;IACD,UAAU,EAAE,CAAC,qBAAqB,CAAC;IACnC,MAAM,EAAE,qCAAqC;IAC7C,KAAK,EAAE;QACL,SAAS,EACP,+YAA+Y;QACjZ,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;SA0BJ;QACL,MAAM,EAAE,6DAA6D;KACtE;IACD,KAAK,EAAE;QACL,IAAI,EAAE,4EAA4E;QAClF,MAAM,EAAE;YACN,0LAA0L;YAC1L,qFAAqF;YACrF,gLAAgL;YAChL,qEAAqE;SACtE;QACD,OAAO,EAAE;;;;;;SAMJ;QACL,UAAU,EAAE;YACV,8FAA8F;SAC/F;KACF;IACD,MAAM,EAAE;QACN,wBAAwB;QACxB,wBAAwB;QACxB,8BAA8B;QAC9B,mBAAmB;QACnB,yBAAyB;KAC1B;CACF,CAAC"}

package/dist/rules/server-sent-events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-sent-events.d.ts","sourceRoot":"","sources":["../../src/rules/server-sent-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,gBAAgB,EAAE,IAqC9B,CAAC"}
+{"version":3,"file":"server-sent-events.d.ts","sourceRoot":"","sources":["../../src/rules/server-sent-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,gBAAgB,EAAE,IAyC9B,CAAC"}

package/dist/rules/server-sent-events.js

@@ -33,6 +33,10 @@ source.addEventListener("error", () => {
         snippet: `const source = new EventSource("/api/updates");
 source.addEventListener("price", (e) => update(JSON.parse(e.data)));
 source.close();`,
+        handRolled: [
+            "a setInterval or a self-rescheduling setTimeout re-fetching an endpoint to notice changes, with the delay tuned by hand",
+            "a long poll: a fetch the server holds open, re-issued from its own then handler",
+        ],
     },
 };
 //# sourceMappingURL=server-sent-events.js.map

package/dist/rules/server-sent-events.js.map

@@ -1 +1 @@
-{"version":3,"file":"server-sent-events.js","sourceRoot":"","sources":["../../src/rules/server-sent-events.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,gBAAgB,GAAS;IACpC,EAAE,EAAE,oBAAoB;IACxB,KAAK,EAAE,oBAAoB;IAC3B,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,CAAC,aAAa,EAAE,uBAAuB,CAAC;IAClD,UAAU,EAAE,CAAC,oBAAoB,CAAC;IAClC,MAAM,EAAE,aAAa;IACrB,KAAK,EAAE;QACL,SAAS,EACP,mWAAmW;QACrW,OAAO,EAAE;;;;;;;;;;;IAWT;QACA,MAAM,EAAE,8DAA8D;KACvE;IACD,KAAK,EAAE;QACL,IAAI,EAAE,0DAA0D;QAChE,MAAM,EAAE;YACN,kLAAkL;YAClL,oJAAoJ;YACpJ,gKAAgK;YAChK,+JAA+J;YAC/J,8JAA8J;SAC/J;QACD,OAAO,EAAE;;gBAEG;KACb;CACF,CAAC"}
+{"version":3,"file":"server-sent-events.js","sourceRoot":"","sources":["../../src/rules/server-sent-events.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,gBAAgB,GAAS;IACpC,EAAE,EAAE,oBAAoB;IACxB,KAAK,EAAE,oBAAoB;IAC3B,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,CAAC,aAAa,EAAE,uBAAuB,CAAC;IAClD,UAAU,EAAE,CAAC,oBAAoB,CAAC;IAClC,MAAM,EAAE,aAAa;IACrB,KAAK,EAAE;QACL,SAAS,EACP,mWAAmW;QACrW,OAAO,EAAE;;;;;;;;;;;IAWT;QACA,MAAM,EAAE,8DAA8D;KACvE;IACD,KAAK,EAAE;QACL,IAAI,EAAE,0DAA0D;QAChE,MAAM,EAAE;YACN,kLAAkL;YAClL,oJAAoJ;YACpJ,gKAAgK;YAChK,+JAA+J;YAC/J,8JAA8J;SAC/J;QACD,OAAO,EAAE;;gBAEG;QACZ,UAAU,EAAE;YACV,yHAAyH;YACzH,iFAAiF;SAClF;KACF;CACF,CAAC"}

package/dist/rules/speculation-rules.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "../schema.ts";
+export declare const speculationRules: Rule;
+//# sourceMappingURL=speculation-rules.d.ts.map

package/dist/rules/speculation-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"speculation-rules.d.ts","sourceRoot":"","sources":["../../src/rules/speculation-rules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,gBAAgB,EAAE,IAoC9B,CAAC"}

package/dist/rules/speculation-rules.js

@@ -0,0 +1,35 @@
+export const speculationRules = {
+    id: "speculation-rules",
+    title: "Prefetching the next page",
+    category: "async-data",
+    replaces: ["quicklink", "instant.page"],
+    featureIds: ["speculation-rules"],
+    native: "speculation rules",
+    human: {
+        explainer: "These scripts watch for links entering the viewport or being hovered, then inject a prefetch tag. Speculation rules say the same thing declaratively in a script tag the browser reads: which links to speculate on, and how eagerly. The browser handles the heuristics, and prerender goes further than any library can, rendering the next page so the click is instant. Chromium only for now.",
+        snippet: `<script type="speculationrules">
+  {
+    "prerender": [{
+      "where": { "href_matches": "/articles/*" },
+      "eagerness": "moderate"
+    }]
+  }
+</script>`,
+        mdnUrl: "https://developer.mozilla.org/en-US/docs/Web/API/Speculation_Rules_API",
+    },
+    agent: {
+        when: "prefetching or prerendering the page a visitor is likely to open next",
+        unless: [
+            "You ship to Firefox or Safari. Only Chromium has this, from Chrome {{chrome:speculation-rules}}, so the library is still what serves everyone else and this is an enhancement rather than a swap.",
+            "Prerendering would run analytics or side effects for a page nobody visited. A prerendered document runs its scripts, so anything counting a view has to check document.prerendering and wait, which is work the library never made you do.",
+            "The next URL is decided in JavaScript rather than present as a link, such as a router that builds the target from state. Rules match on the document's own hrefs.",
+            "Your pages are personalised or expensive to render, where speculating wrongly costs the server more than the click saves the visitor.",
+        ],
+        snippet: '<script type="speculationrules">{"prefetch":[{"where":{"href_matches":"/*"}}]}</script>',
+        handRolled: [
+            "an IntersectionObserver over anchors that injects a <link rel=prefetch> when one scrolls into view",
+            "a mouseover or touchstart listener on links that starts fetching the target before the click lands",
+        ],
+    },
+};
+//# sourceMappingURL=speculation-rules.js.map

package/dist/rules/speculation-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"speculation-rules.js","sourceRoot":"","sources":["../../src/rules/speculation-rules.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,gBAAgB,GAAS;IACpC,EAAE,EAAE,mBAAmB;IACvB,KAAK,EAAE,2BAA2B;IAClC,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,CAAC,WAAW,EAAE,cAAc,CAAC;IACvC,UAAU,EAAE,CAAC,mBAAmB,CAAC;IACjC,MAAM,EAAE,mBAAmB;IAC3B,KAAK,EAAE;QACL,SAAS,EACP,oYAAoY;QACtY,OAAO,EAAE;;;;;;;UAOH;QACN,MAAM,EACJ,wEAAwE;KAC3E;IACD,KAAK,EAAE;QACL,IAAI,EAAE,uEAAuE;QAC7E,MAAM,EAAE;YACN,mMAAmM;YACnM,4OAA4O;YAC5O,mKAAmK;YACnK,uIAAuI;SACxI;QACD,OAAO,EACL,yFAAyF;QAC3F,UAAU,EAAE;YACV,oGAAoG;YACpG,oGAAoG;SACrG;KACF;CACF,CAAC"}

package/dist/rules/temporal.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from "../schema.ts";
+export declare const temporal: Rule;
+//# sourceMappingURL=temporal.d.ts.map

package/dist/rules/temporal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.d.ts","sourceRoot":"","sources":["../../src/rules/temporal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,QAAQ,EAAE,IAmCtB,CAAC"}

package/dist/rules/temporal.js

@@ -0,0 +1,34 @@
+export const temporal = {
+    id: "temporal",
+    title: "Date arithmetic and time zones",
+    category: "formatting",
+    replaces: ["moment-timezone", "spacetime", "@js-joda/core", "js-joda"],
+    featureIds: ["temporal"],
+    native: "Temporal",
+    human: {
+        explainer: "These libraries exist because Date cannot do the job: it has no concept of a time zone beyond the host's, and adding a day across a daylight saving boundary gives the wrong answer. Temporal is the replacement, with ZonedDateTime carrying an IANA zone and arithmetic that respects it. It is not in every engine yet, so this is a plan rather than a deletion, and the honest move today is the official polyfill.",
+        snippet: `const meeting = Temporal.ZonedDateTime.from(
+  "2026-03-08T01:30:00-05:00[America/New_York]",
+);
+
+// Adds a calendar day, not 24 hours, so the DST change is handled.
+meeting.add({ days: 1 }).toString();`,
+        mdnUrl: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Temporal",
+    },
+    agent: {
+        when: "doing date arithmetic or working with named time zones",
+        unless: [
+            "You ship to Safari, or to any engine below Chrome {{chrome:temporal}} or Firefox {{firefox:temporal}}. Temporal is not available everywhere yet, so today this means adding @js-temporal/polyfill rather than removing a dependency, and that polyfill is larger than most of the libraries it would replace.",
+            "You only format dates for display. Intl.DateTimeFormat already does that everywhere, and the date-format rule covers it. Temporal is for the arithmetic.",
+            "You parse loose or non-ISO input. Temporal is deliberately strict and throws on anything ambiguous, which is the opposite of what moment was liked for.",
+            "You depend on moment-timezone's bundled zone database at a pinned version, for example to reproduce a historical calculation. Temporal reads the zone data the engine ships, which moves under you.",
+            "The codebase is on moment and the migration is the work. Two date libraries in one bundle is worse than one, so a partial migration costs more than either end state.",
+        ],
+        snippet: 'Temporal.ZonedDateTime.from("2026-03-08T01:30:00-05:00[America/New_York]").add({ days: 1 });',
+        handRolled: [
+            "a date rebuilt through UTC offsets with getTimezoneOffset, to move a timestamp into another zone",
+            "adding 86400000 milliseconds to a timestamp to mean tomorrow, which is an hour out on the two days a year the offset changes",
+        ],
+    },
+};
+//# sourceMappingURL=temporal.js.map

package/dist/rules/temporal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal.js","sourceRoot":"","sources":["../../src/rules/temporal.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAS;IAC5B,EAAE,EAAE,UAAU;IACd,KAAK,EAAE,gCAAgC;IACvC,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,CAAC,iBAAiB,EAAE,WAAW,EAAE,eAAe,EAAE,SAAS,CAAC;IACtE,UAAU,EAAE,CAAC,UAAU,CAAC;IACxB,MAAM,EAAE,UAAU;IAClB,KAAK,EAAE;QACL,SAAS,EACP,0ZAA0Z;QAC5Z,OAAO,EAAE;;;;;qCAKwB;QACjC,MAAM,EACJ,2FAA2F;KAC9F;IACD,KAAK,EAAE;QACL,IAAI,EAAE,wDAAwD;QAC9D,MAAM,EAAE;YACN,+SAA+S;YAC/S,0JAA0J;YAC1J,yJAAyJ;YACzJ,qMAAqM;YACrM,uKAAuK;SACxK;QACD,OAAO,EACL,8FAA8F;QAChG,UAAU,EAAE;YACV,kGAAkG;YAClG,8HAA8H;SAC/H;KACF;CACF,CAAC"}

package/dist/rules/url-pattern.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"url-pattern.d.ts","sourceRoot":"","sources":["../../src/rules/url-pattern.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,UAAU,EAAE,IAmCxB,CAAC"}
+{"version":3,"file":"url-pattern.d.ts","sourceRoot":"","sources":["../../src/rules/url-pattern.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,UAAU,EAAE,IAuCxB,CAAC"}

package/dist/rules/url-pattern.js

@@ -31,6 +31,10 @@ new URLPattern({ hostname: ":tenant.example.com" })
         snippet: `const pattern = new URLPattern({ pathname: "/users/:id" });
 const match = pattern.exec(url);
 const id = match?.pathname.groups.id;`,
+        handRolled: [
+            "a hand-written regex per route with named capture groups, and a loop testing each against the path",
+            'pathname.split("/") compared segment by segment to work out which route matched and pull out an id',
+        ],
     },
 };
 //# sourceMappingURL=url-pattern.js.map

package/dist/rules/url-pattern.js.map

@@ -1 +1 @@
-{"version":3,"file":"url-pattern.js","sourceRoot":"","sources":["../../src/rules/url-pattern.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAAS;IAC9B,EAAE,EAAE,YAAY;IAChB,KAAK,EAAE,uBAAuB;IAC9B,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,CAAC,gBAAgB,EAAE,aAAa,EAAE,cAAc,CAAC;IAC3D,UAAU,EAAE,CAAC,YAAY,CAAC;IAC1B,MAAM,EAAE,YAAY;IACpB,KAAK,EAAE;QACL,SAAS,EACP,8XAA8X;QAChY,OAAO,EAAE;;;;;;;;;;0CAU6B;QACtC,MAAM,EAAE,6DAA6D;KACtE;IACD,KAAK,EAAE;QACL,IAAI,EAAE,yEAAyE;QAC/E,MAAM,EAAE;YACN,4LAA4L;YAC5L,8LAA8L;YAC9L,2OAA2O;YAC3O,oHAAoH;SACrH;QACD,OAAO,EAAE;;sCAEyB;KACnC;CACF,CAAC"}
+{"version":3,"file":"url-pattern.js","sourceRoot":"","sources":["../../src/rules/url-pattern.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAAS;IAC9B,EAAE,EAAE,YAAY;IAChB,KAAK,EAAE,uBAAuB;IAC9B,QAAQ,EAAE,YAAY;IACtB,QAAQ,EAAE,CAAC,gBAAgB,EAAE,aAAa,EAAE,cAAc,CAAC;IAC3D,UAAU,EAAE,CAAC,YAAY,CAAC;IAC1B,MAAM,EAAE,YAAY;IACpB,KAAK,EAAE;QACL,SAAS,EACP,8XAA8X;QAChY,OAAO,EAAE;;;;;;;;;;0CAU6B;QACtC,MAAM,EAAE,6DAA6D;KACtE;IACD,KAAK,EAAE;QACL,IAAI,EAAE,yEAAyE;QAC/E,MAAM,EAAE;YACN,4LAA4L;YAC5L,8LAA8L;YAC9L,2OAA2O;YAC3O,oHAAoH;SACrH;QACD,OAAO,EAAE;;sCAEyB;QAClC,UAAU,EAAE;YACV,oGAAoG;YACpG,oGAAoG;SACrG;KACF;CACF,CAAC"}

package/dist/rules/web-animations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"web-animations.d.ts","sourceRoot":"","sources":["../../src/rules/web-animations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,aAAa,EAAE,IAwC3B,CAAC"}
+{"version":3,"file":"web-animations.d.ts","sourceRoot":"","sources":["../../src/rules/web-animations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,eAAO,MAAM,aAAa,EAAE,IA4C3B,CAAC"}

package/dist/rules/web-animations.js

@@ -35,6 +35,10 @@ animation.reverse();`,
   { duration: 240, fill: "both" },
 );
 await animation.finished;`,
+        handRolled: [
+            "a requestAnimationFrame loop interpolating a style property between two values, with its own easing function",
+            "a chain of setTimeout calls stepping an element's style to fake a keyframe sequence",
+        ],
     },
 };
 //# sourceMappingURL=web-animations.js.map

package/dist/rules/web-animations.js.map

@@ -1 +1 @@
-{"version":3,"file":"web-animations.js","sourceRoot":"","sources":["../../src/rules/web-animations.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,aAAa,GAAS;IACjC,EAAE,EAAE,gBAAgB;IACpB,KAAK,EAAE,2BAA2B;IAClC,QAAQ,EAAE,WAAW;IACrB,QAAQ,EAAE,CAAC,SAAS,EAAE,WAAW,EAAE,kBAAkB,CAAC;IACtD,UAAU,EAAE,CAAC,gBAAgB,CAAC;IAC9B,MAAM,EAAE,mBAAmB;IAC3B,KAAK,EAAE;QACL,SAAS,EACP,8aAA8a;QAChb,OAAO,EAAE;;;;;;;;;;;qBAWQ;QACjB,MAAM,EACJ,qEAAqE;KACxE;IACD,KAAK,EAAE;QACL,IAAI,EAAE,kFAAkF;QACxF,MAAM,EAAE;YACN,mOAAmO;YACnO,gNAAgN;YAChN,6MAA6M;YAC7M,oKAAoK;YACpK,kIAAkI;SACnI;QACD,OAAO,EAAE;;;;0BAIa;KACvB;CACF,CAAC"}
+{"version":3,"file":"web-animations.js","sourceRoot":"","sources":["../../src/rules/web-animations.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,aAAa,GAAS;IACjC,EAAE,EAAE,gBAAgB;IACpB,KAAK,EAAE,2BAA2B;IAClC,QAAQ,EAAE,WAAW;IACrB,QAAQ,EAAE,CAAC,SAAS,EAAE,WAAW,EAAE,kBAAkB,CAAC;IACtD,UAAU,EAAE,CAAC,gBAAgB,CAAC;IAC9B,MAAM,EAAE,mBAAmB;IAC3B,KAAK,EAAE;QACL,SAAS,EACP,8aAA8a;QAChb,OAAO,EAAE;;;;;;;;;;;qBAWQ;QACjB,MAAM,EACJ,qEAAqE;KACxE;IACD,KAAK,EAAE;QACL,IAAI,EAAE,kFAAkF;QACxF,MAAM,EAAE;YACN,mOAAmO;YACnO,gNAAgN;YAChN,6MAA6M;YAC7M,oKAAoK;YACpK,kIAAkI;SACnI;QACD,OAAO,EAAE;;;;0BAIa;QACtB,UAAU,EAAE;YACV,8GAA8G;YAC9G,qFAAqF;SACtF;KACF;CACF,CAAC"}