@chaffjs/lang-en 0.15.0 → 0.17.0

package/lexicons/spelling-ize.yaml

@@ -0,0 +1,273 @@
+# -ise and -ize (organise / organize, organisation / organization). pattern is -ise, instead_of -ize.
+# Compared apart from spelling-variant: British writing uses both, and Oxford spelling writes -ize with colour.
+id: spelling-ize
+language: en
+entries:
+  - pattern: organise
+    instead_of: organize
+  - pattern: organises
+    instead_of: organizes
+  - pattern: organised
+    instead_of: organized
+  - pattern: organising
+    instead_of: organizing
+  - pattern: organisation
+    instead_of: organization
+  - pattern: organisations
+    instead_of: organizations
+  - pattern: organiser
+    instead_of: organizer
+  - pattern: organisers
+    instead_of: organizers
+  - pattern: recognise
+    instead_of: recognize
+  - pattern: recognises
+    instead_of: recognizes
+  - pattern: recognised
+    instead_of: recognized
+  - pattern: recognising
+    instead_of: recognizing
+  - pattern: realise
+    instead_of: realize
+  - pattern: realises
+    instead_of: realizes
+  - pattern: realised
+    instead_of: realized
+  - pattern: realising
+    instead_of: realizing
+  - pattern: realisation
+    instead_of: realization
+  - pattern: prioritise
+    instead_of: prioritize
+  - pattern: prioritises
+    instead_of: prioritizes
+  - pattern: prioritised
+    instead_of: prioritized
+  - pattern: prioritising
+    instead_of: prioritizing
+  - pattern: prioritisation
+    instead_of: prioritization
+  - pattern: minimise
+    instead_of: minimize
+  - pattern: minimises
+    instead_of: minimizes
+  - pattern: minimised
+    instead_of: minimized
+  - pattern: minimising
+    instead_of: minimizing
+  - pattern: maximise
+    instead_of: maximize
+  - pattern: maximises
+    instead_of: maximizes
+  - pattern: maximised
+    instead_of: maximized
+  - pattern: maximising
+    instead_of: maximizing
+  - pattern: optimise
+    instead_of: optimize
+  - pattern: optimises
+    instead_of: optimizes
+  - pattern: optimised
+    instead_of: optimized
+  - pattern: optimising
+    instead_of: optimizing
+  - pattern: optimisation
+    instead_of: optimization
+  - pattern: optimisations
+    instead_of: optimizations
+  - pattern: customise
+    instead_of: customize
+  - pattern: customises
+    instead_of: customizes
+  - pattern: customised
+    instead_of: customized
+  - pattern: customising
+    instead_of: customizing
+  - pattern: customisation
+    instead_of: customization
+  - pattern: customisable
+    instead_of: customizable
+  - pattern: standardise
+    instead_of: standardize
+  - pattern: standardises
+    instead_of: standardizes
+  - pattern: standardised
+    instead_of: standardized
+  - pattern: standardising
+    instead_of: standardizing
+  - pattern: standardisation
+    instead_of: standardization
+  - pattern: summarise
+    instead_of: summarize
+  - pattern: summarises
+    instead_of: summarizes
+  - pattern: summarised
+    instead_of: summarized
+  - pattern: summarising
+    instead_of: summarizing
+  - pattern: emphasise
+    instead_of: emphasize
+  - pattern: emphasises
+    instead_of: emphasizes
+  - pattern: emphasised
+    instead_of: emphasized
+  - pattern: emphasising
+    instead_of: emphasizing
+  - pattern: authorise
+    instead_of: authorize
+  - pattern: authorises
+    instead_of: authorizes
+  - pattern: authorised
+    instead_of: authorized
+  - pattern: authorising
+    instead_of: authorizing
+  - pattern: authorisation
+    instead_of: authorization
+  - pattern: authorisations
+    instead_of: authorizations
+  - pattern: categorise
+    instead_of: categorize
+  - pattern: categorises
+    instead_of: categorizes
+  - pattern: categorised
+    instead_of: categorized
+  - pattern: categorising
+    instead_of: categorizing
+  - pattern: categorisation
+    instead_of: categorization
+  - pattern: finalise
+    instead_of: finalize
+  - pattern: finalises
+    instead_of: finalizes
+  - pattern: finalised
+    instead_of: finalized
+  - pattern: finalising
+    instead_of: finalizing
+  - pattern: utilise
+    instead_of: utilize
+  - pattern: utilises
+    instead_of: utilizes
+  - pattern: utilised
+    instead_of: utilized
+  - pattern: utilising
+    instead_of: utilizing
+  - pattern: utilisation
+    instead_of: utilization
+  - pattern: apologise
+    instead_of: apologize
+  - pattern: apologises
+    instead_of: apologizes
+  - pattern: apologised
+    instead_of: apologized
+  - pattern: apologising
+    instead_of: apologizing
+  - pattern: criticise
+    instead_of: criticize
+  - pattern: criticises
+    instead_of: criticizes
+  - pattern: criticised
+    instead_of: criticized
+  - pattern: criticising
+    instead_of: criticizing
+  - pattern: specialise
+    instead_of: specialize
+  - pattern: specialises
+    instead_of: specializes
+  - pattern: specialised
+    instead_of: specialized
+  - pattern: specialising
+    instead_of: specializing
+  - pattern: specialisation
+    instead_of: specialization
+  - pattern: visualise
+    instead_of: visualize
+  - pattern: visualises
+    instead_of: visualizes
+  - pattern: visualised
+    instead_of: visualized
+  - pattern: visualising
+    instead_of: visualizing
+  - pattern: visualisation
+    instead_of: visualization
+  - pattern: visualisations
+    instead_of: visualizations
+  - pattern: initialise
+    instead_of: initialize
+  - pattern: initialises
+    instead_of: initializes
+  - pattern: initialised
+    instead_of: initialized
+  - pattern: initialising
+    instead_of: initializing
+  - pattern: initialisation
+    instead_of: initialization
+  - pattern: normalise
+    instead_of: normalize
+  - pattern: normalises
+    instead_of: normalizes
+  - pattern: normalised
+    instead_of: normalized
+  - pattern: normalising
+    instead_of: normalizing
+  - pattern: normalisation
+    instead_of: normalization
+  - pattern: synchronise
+    instead_of: synchronize
+  - pattern: synchronises
+    instead_of: synchronizes
+  - pattern: synchronised
+    instead_of: synchronized
+  - pattern: synchronising
+    instead_of: synchronizing
+  - pattern: synchronisation
+    instead_of: synchronization
+  - pattern: modernise
+    instead_of: modernize
+  - pattern: modernises
+    instead_of: modernizes
+  - pattern: modernised
+    instead_of: modernized
+  - pattern: modernising
+    instead_of: modernizing
+  - pattern: modernisation
+    instead_of: modernization
+  - pattern: digitise
+    instead_of: digitize
+  - pattern: digitises
+    instead_of: digitizes
+  - pattern: digitised
+    instead_of: digitized
+  - pattern: digitising
+    instead_of: digitizing
+  - pattern: digitisation
+    instead_of: digitization
+  - pattern: localise
+    instead_of: localize
+  - pattern: localises
+    instead_of: localizes
+  - pattern: localised
+    instead_of: localized
+  - pattern: localising
+    instead_of: localizing
+  - pattern: localisation
+    instead_of: localization
+  - pattern: centralise
+    instead_of: centralize
+  - pattern: centralises
+    instead_of: centralizes
+  - pattern: centralised
+    instead_of: centralized
+  - pattern: centralising
+    instead_of: centralizing
+  - pattern: centralisation
+    instead_of: centralization
+  - pattern: characterise
+    instead_of: characterize
+  - pattern: characterises
+    instead_of: characterizes
+  - pattern: characterised
+    instead_of: characterized
+  - pattern: characterising
+    instead_of: characterizing
+  - pattern: characterisation
+    instead_of: characterization

package/lexicons/spelling-variant.yaml

@@ -0,0 +1,260 @@
+# British and American spellings of the same word (colour / color, centre / center, travelled / traveled, analyse / analyze).
+# pattern is the British spelling, instead_of the American. Neither is wrong: spelling-consistency points at whichever the
+# document uses less. -ise / -ize is in spelling-ize, compared on its own, since Oxford spelling writes colour and organize.
+# Words with another meaning in one variety are left out: meter (a device), check (a verb), tire (a verb), program, license,
+# practice, judgment (a court's), dialog and analog (in software and electronics), analyses (the plural of analysis).
+id: spelling-variant
+language: en
+entries:
+  - pattern: colour
+    instead_of: color
+  - pattern: colours
+    instead_of: colors
+  - pattern: coloured
+    instead_of: colored
+  - pattern: colouring
+    instead_of: coloring
+  - pattern: colourful
+    instead_of: colorful
+  - pattern: colourless
+    instead_of: colorless
+  - pattern: favour
+    instead_of: favor
+  - pattern: favours
+    instead_of: favors
+  - pattern: favoured
+    instead_of: favored
+  - pattern: favouring
+    instead_of: favoring
+  - pattern: favourable
+    instead_of: favorable
+  - pattern: favourite
+    instead_of: favorite
+  - pattern: favourites
+    instead_of: favorites
+  - pattern: honour
+    instead_of: honor
+  - pattern: honours
+    instead_of: honors
+  - pattern: honoured
+    instead_of: honored
+  - pattern: honouring
+    instead_of: honoring
+  - pattern: honourable
+    instead_of: honorable
+  - pattern: labour
+    instead_of: labor
+  - pattern: labours
+    instead_of: labors
+  - pattern: laboured
+    instead_of: labored
+  - pattern: labouring
+    instead_of: laboring
+  - pattern: behaviour
+    instead_of: behavior
+  - pattern: behaviours
+    instead_of: behaviors
+  - pattern: behavioural
+    instead_of: behavioral
+  - pattern: neighbour
+    instead_of: neighbor
+  - pattern: neighbours
+    instead_of: neighbors
+  - pattern: neighbourhood
+    instead_of: neighborhood
+  - pattern: neighbourhoods
+    instead_of: neighborhoods
+  - pattern: neighbouring
+    instead_of: neighboring
+  - pattern: humour
+    instead_of: humor
+  - pattern: humours
+    instead_of: humors
+  - pattern: rumour
+    instead_of: rumor
+  - pattern: rumours
+    instead_of: rumors
+  - pattern: rumoured
+    instead_of: rumored
+  - pattern: harbour
+    instead_of: harbor
+  - pattern: harbours
+    instead_of: harbors
+  - pattern: endeavour
+    instead_of: endeavor
+  - pattern: endeavours
+    instead_of: endeavors
+  - pattern: endeavoured
+    instead_of: endeavored
+  - pattern: endeavouring
+    instead_of: endeavoring
+  - pattern: flavour
+    instead_of: flavor
+  - pattern: flavours
+    instead_of: flavors
+  - pattern: flavoured
+    instead_of: flavored
+  - pattern: flavouring
+    instead_of: flavoring
+  - pattern: vapour
+    instead_of: vapor
+  - pattern: vapours
+    instead_of: vapors
+  - pattern: savour
+    instead_of: savor
+  - pattern: savours
+    instead_of: savors
+  - pattern: savoury
+    instead_of: savory
+  - pattern: centre
+    instead_of: center
+  - pattern: centres
+    instead_of: centers
+  - pattern: centred
+    instead_of: centered
+  - pattern: theatre
+    instead_of: theater
+  - pattern: theatres
+    instead_of: theaters
+  - pattern: fibre
+    instead_of: fiber
+  - pattern: fibres
+    instead_of: fibers
+  - pattern: litre
+    instead_of: liter
+  - pattern: litres
+    instead_of: liters
+  - pattern: kilometre
+    instead_of: kilometer
+  - pattern: kilometres
+    instead_of: kilometers
+  - pattern: centimetre
+    instead_of: centimeter
+  - pattern: centimetres
+    instead_of: centimeters
+  - pattern: millimetre
+    instead_of: millimeter
+  - pattern: millimetres
+    instead_of: millimeters
+  - pattern: calibre
+    instead_of: caliber
+  - pattern: sombre
+    instead_of: somber
+  - pattern: analyse
+    instead_of: analyze
+  - pattern: analysed
+    instead_of: analyzed
+  - pattern: analysing
+    instead_of: analyzing
+  - pattern: analyser
+    instead_of: analyzer
+  - pattern: analysers
+    instead_of: analyzers
+  - pattern: paralyse
+    instead_of: paralyze
+  - pattern: paralysed
+    instead_of: paralyzed
+  - pattern: paralysing
+    instead_of: paralyzing
+  - pattern: catalyse
+    instead_of: catalyze
+  - pattern: catalysed
+    instead_of: catalyzed
+  - pattern: catalysing
+    instead_of: catalyzing
+  - pattern: defence
+    instead_of: defense
+  - pattern: defences
+    instead_of: defenses
+  - pattern: offence
+    instead_of: offense
+  - pattern: offences
+    instead_of: offenses
+  - pattern: pretence
+    instead_of: pretense
+  - pattern: pretences
+    instead_of: pretenses
+  - pattern: travelled
+    instead_of: traveled
+  - pattern: travelling
+    instead_of: traveling
+  - pattern: traveller
+    instead_of: traveler
+  - pattern: travellers
+    instead_of: travelers
+  - pattern: cancelled
+    instead_of: canceled
+  - pattern: cancelling
+    instead_of: canceling
+  - pattern: labelled
+    instead_of: labeled
+  - pattern: labelling
+    instead_of: labeling
+  - pattern: modelled
+    instead_of: modeled
+  - pattern: modelling
+    instead_of: modeling
+  - pattern: signalled
+    instead_of: signaled
+  - pattern: signalling
+    instead_of: signaling
+  - pattern: fuelled
+    instead_of: fueled
+  - pattern: fuelling
+    instead_of: fueling
+  - pattern: totalled
+    instead_of: totaled
+  - pattern: totalling
+    instead_of: totaling
+  - pattern: catalogue
+    instead_of: catalog
+  - pattern: catalogues
+    instead_of: catalogs
+  - pattern: catalogued
+    instead_of: cataloged
+  - pattern: grey
+    instead_of: gray
+  - pattern: greys
+    instead_of: grays
+  - pattern: greyer
+    instead_of: grayer
+  - pattern: greyest
+    instead_of: grayest
+  - pattern: aluminium
+    instead_of: aluminum
+  - pattern: enrol
+    instead_of: enroll
+  - pattern: enrols
+    instead_of: enrolls
+  - pattern: enrolment
+    instead_of: enrollment
+  - pattern: enrolments
+    instead_of: enrollments
+  - pattern: fulfil
+    instead_of: fulfill
+  - pattern: fulfils
+    instead_of: fulfills
+  - pattern: fulfilment
+    instead_of: fulfillment
+  - pattern: instalment
+    instead_of: installment
+  - pattern: instalments
+    instead_of: installments
+  - pattern: acknowledgement
+    instead_of: acknowledgment
+  - pattern: acknowledgements
+    instead_of: acknowledgments
+  - pattern: ageing
+    instead_of: aging
+  - pattern: manoeuvre
+    instead_of: maneuver
+  - pattern: manoeuvres
+    instead_of: maneuvers
+  - pattern: paediatric
+    instead_of: pediatric
+  - pattern: paediatrics
+    instead_of: pediatrics
+  - pattern: anaesthesia
+    instead_of: anesthesia
+  - pattern: oestrogen
+    instead_of: estrogen

package/lexicons/stock-transition.yaml

@@ -0,0 +1,17 @@
+# Sentence openers that glue without saying how. Words that carry the argument (However, Therefore, Thus) are not here.
+# "In addition," keeps its comma: "In addition to X" opens a phrase, not a transition.
+id: stock-transition
+language: en
+entries:
+  - pattern: Additionally
+  - pattern: Moreover
+  - pattern: Furthermore
+  - pattern: In addition,
+  - pattern: Notably
+  - pattern: Importantly
+  - pattern: Crucially
+  - pattern: Ultimately
+  - pattern: Overall,
+  - pattern: In conclusion
+  - pattern: In summary
+  - pattern: That said

package/lexicons/vague-clause-pointer.yaml

@@ -0,0 +1,10 @@
+# Pointing at a clause by where it is instead of by its number (JIS Z 8301:2019 10.6 avoids "the clause below").
+# instead_of names the kind in the message. Only a document that numbers its clauses or chapters (a numbered article
+# or chapter in its structure tree) is checked. Matched in any case.
+id: vague-clause-pointer
+language: en
+entries:
+  - { pattern: the above clause, instead_of: clause }
+  - { pattern: the clause above, instead_of: clause }
+  - { pattern: the below clause, instead_of: clause }
+  - { pattern: the clause below, instead_of: clause }

package/lexicons/vague-figure-pointer.yaml

@@ -0,0 +1,14 @@
+# Pointing at a figure or a table by where it is instead of by its number (JIS Z 8301:2019 10.6 avoids "the figure
+# above"). instead_of names the kind it points at, as figure-label names it (Figure, Table). Only a document that
+# numbers that kind is checked. Matched in any case.
+id: vague-figure-pointer
+language: en
+entries:
+  - { pattern: the above figure, instead_of: Figure }
+  - { pattern: the figure above, instead_of: Figure }
+  - { pattern: the below figure, instead_of: Figure }
+  - { pattern: the figure below, instead_of: Figure }
+  - { pattern: the above table, instead_of: Table }
+  - { pattern: the table above, instead_of: Table }
+  - { pattern: the below table, instead_of: Table }
+  - { pattern: the table below, instead_of: Table }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chaffjs/lang-en",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "English language adapter for chaff",
   "license": "MIT",
   "author": "isamu",

package/src/citation.ts

@@ -52,17 +52,18 @@ export const listMembers = (rest: string, plural: boolean): ListMember[] =>
  */
 const TAG = "(?<tag>[A-Z][A-Z0-9]{1,30})";
 /**
- * "[HTTP-CACHING]" is written like a contract's placeholder "[BUYER-1]". Only the document tells them apart, by listing
- * the tag or not, so this tag is a candidate that the core checks against the document (attrs.citedTag).
+ * "[HTTP-CACHING]" is written like a contract's placeholder "[BUYER-1]", and a numbered citation "[19]" like a blank to
+ * fill in. Only the document tells them apart, by listing the tag or not, so this tag is a candidate that the core checks
+ * against the document (attrs.citedTag).
  */
-const HYPHENATED_TAG = "(?<tag>[A-Z][A-Z0-9]{0,30}(?:-[A-Z0-9]{1,30}){1,4})";
+const LISTED_TAG = "(?<tag>\\d{1,3}|[A-Z][A-Z0-9]{0,30}(?:-[A-Z0-9]{1,30}){1,4})";
 const tagAfter = (tag: string): RegExp => new RegExp(`^\\[${tag}\\]`, "u");
 /** "[HTTP], Section 12.1": the tag written just before the reference. */
 const tagBefore = (tag: string): RegExp => new RegExp(`\\[${tag}\\],?\\s?$`, "u");
 const TAG_AFTER = tagAfter(TAG);
 const TAG_BEFORE = tagBefore(TAG);
-const HYPHENATED_AFTER = tagAfter(HYPHENATED_TAG);
-const HYPHENATED_BEFORE = tagBefore(HYPHENATED_TAG);
+const LISTED_AFTER = tagAfter(LISTED_TAG);
+const LISTED_BEFORE = tagBefore(LISTED_TAG);
 const TAG_REACH = 40;
 
 const tagEndingAt = (pattern: RegExp, text: string, start: number): string | undefined =>
@@ -120,9 +121,12 @@ export const citedDocumentAfter = (text: string, end: number): string | undefine
   return words.length === 1 && SELF.has(name) ? undefined : name;
 };
 
-/** A hyphenated tag right after a reference ("Section 4.2.3 of [HTTP-CACHING]") or just before it ("[HTTP-CACHING], Section 4"). */
-export const hyphenatedTagAround = (text: string, start: number, end: number): string | undefined => {
+/**
+ * A tag that names another document only if this document lists it, right after a reference ("Section 4.2.3 of
+ * [HTTP-CACHING]", "Section 4.2.2.17 of [19]") or just before it ("[HTTP-CACHING], Section 4", "[23], Section 2.17").
+ */
+export const listedTagAround = (text: string, start: number, end: number): string | undefined => {
   const named = afterOf(text, end);
-  const following = named === undefined ? undefined : HYPHENATED_AFTER.exec(named)?.groups?.["tag"];
-  return following ?? tagEndingAt(HYPHENATED_BEFORE, text, start);
+  const following = named === undefined ? undefined : LISTED_AFTER.exec(named)?.groups?.["tag"];
+  return following ?? tagEndingAt(LISTED_BEFORE, text, start);
 };

package/src/code-citation.ts

@@ -0,0 +1,52 @@
+import type { Lexicon, LexiconEntry } from "chaffjs/plugin";
+import { escapeRegExp } from "./regexp.ts";
+
+// "35 CFR §122", "42 U.S.C. § 1983", "RFC 1122, Section 3.3.4.2": a section of a code or a numbered document named
+// right before the reference, not of this document. Which names are codes is the lexicon's (document-kind).
+
+/** Built once from the lexicon; each pattern is undefined when the lexicon names no code of its shape. */
+export type CodeVocabulary = {
+  readonly before: RegExp | undefined;
+  readonly numberedBefore: RegExp | undefined;
+  /** The name of a code that takes a title number, at the start of the text and ending at a word boundary. */
+  readonly titled: RegExp | undefined;
+};
+
+/** The code's title number ("35 CFR"), then the name, then at most a second "§" ("§§ 1981 and 1983") up to the reference. */
+const TITLE_NUMBER = String.raw`(?:\d{1,3}\s+)?`;
+const SECOND_SIGN = String.raw`\s*(?:§\s*)?$`;
+/** The document's own number after its name, then a comma, an opening parenthesis or a space up to the reference. */
+const OWN_NUMBER = String.raw`\s+\d{1,5}`;
+const NUMBER_TO_REFERENCE = String.raw`(?:,\s*|\s*\(\s*|\s+)(?:§\s*)?$`;
+const NOT_INSIDE_A_WORD = String.raw`(?<![\p{L}\p{N}_.])`;
+const WORD_ENDS = String.raw`(?![\p{L}\p{N}_])`;
+
+/** "35 CFR " is a few characters. Only this much before a reference is read, however long the line. */
+const REACH = 40;
+
+const namesOf = (entries: readonly LexiconEntry[]): string | undefined => {
+  const names = entries.map((entry) => entry.pattern).toSorted((left, right) => right.length - left.length);
+  return names.length === 0 ? undefined : `(?:${names.map(escapeRegExp).join("|")})`;
+};
+
+/** An entry with position "before" is a name written before its own number ("RFC 1122"); the others follow a title number. */
+export const codeVocabulary = (lexicons: Readonly<Record<string, Lexicon>>): CodeVocabulary => {
+  const entries = lexicons["document-kind"] ?? [];
+  const titled = namesOf(entries.filter((entry) => entry.position !== "before"));
+  const numbered = namesOf(entries.filter((entry) => entry.position === "before"));
+  return {
+    before: titled === undefined ? undefined : new RegExp(String.raw`${NOT_INSIDE_A_WORD}(?<code>${TITLE_NUMBER}${titled})${SECOND_SIGN}`, "u"),
+    numberedBefore:
+      numbered === undefined ? undefined : new RegExp(String.raw`${NOT_INSIDE_A_WORD}(?<code>${numbered}${OWN_NUMBER})${NUMBER_TO_REFERENCE}`, "u"),
+    titled: titled === undefined ? undefined : new RegExp(String.raw`^${titled}${WORD_ENDS}`, "u"),
+  };
+};
+
+/** The code named right before the reference at `start`, or undefined when none is. */
+export const citedCodeBefore = (text: string, start: number, vocabulary: CodeVocabulary): string | undefined => {
+  const before = text.slice(Math.max(0, start - REACH), start);
+  return vocabulary.before?.exec(before)?.groups?.["code"] ?? vocabulary.numberedBefore?.exec(before)?.groups?.["code"];
+};
+
+/** "40 CFR § 163.25" at the start of a heading: the text after the number starts with a code named after a title number. */
+export const titledCodeAt = (rest: string, vocabulary: CodeVocabulary): boolean => vocabulary.titled?.test(rest) === true;

package/src/definitions.ts

@@ -37,7 +37,9 @@ export const definitions = (text: string): Mention[] =>
       const term = match.groups?.["term"];
       if (term === undefined) return [];
       const end = match.index + match[0].length;
-      const namesAParty = match[0].startsWith("(") && APPLIES.test(text);
-      return [{ start: match.index, end, attrs: { term, ...(isPointer(text, end) || namesAParty ? { scope: "local" } : {}) } }];
+      const inline = match[0].startsWith("(");
+      const namesAParty = inline && APPLIES.test(text);
+      const scope = isPointer(text, end) || namesAParty ? { scope: "local" } : {};
+      return [{ start: match.index, end, attrs: { term, ...scope, ...(inline ? { placement: "inline" } : {}) } }];
     }),
   );