@heroiclands/package-build 23.1.1 → 23.2.1

package/engine/ids.mjs

@@ -134,163 +134,6 @@ export const PACK_BY_TYPE = Object.freeze({
     ),
 });
 
-/**
- * Content types that no longer exist, and what replaced each one.
- *
- * `character` and `creature` were retired in favour of the single `being` they
- * had always compiled into. They are recorded here rather than
- * simply deleted because deleting them is the one change that fails *quietly*:
- * every type not named in {@link PACK_BY_TYPE} falls through to the open item
- * set below, so a note or a link left on the old spelling would be routed to
- * the items pack — a wrong answer, arrived at silently, which is exactly the
- * failure mode the open-set default exists to avoid for real item types.
- *
- * Keeping the names lets {@link assertTypeNotRetired} say what happened and
- * what to write instead. Entries stay for as long as content in the wild might
- * still carry them.
- *
- * @type {Readonly<Record<string, string>>}
- */
-export const RETIRED_TYPES = Object.freeze({
-    character: "being",
-    creature: "being",
-    // The three map spellings, retired in favour of the single `map` whose
-    // subType they became. Recorded rather than deleted for the same
-    // reason as the two above: an unnamed type falls through to the open item
-    // set, so a note or link left on one would be routed to the items pack.
-    battlemap: "map",
-    localmap: "map",
-    regionalmap: "map",
-});
-
-/**
- * Throw if `type` names a retired content type.
- *
- * @param {string} type - The note's declared `type`, or a link's qualifier.
- * @param {string} [where] - What carries it — a file path, a link target —
- *   appended to the message so the reader can go straight to it.
- * @throws {Error} Naming the replacement type.
- */
-export function assertTypeNotRetired(type, where) {
-    const replacement = RETIRED_TYPES[type];
-    if (!replacement) return;
-    throw new Error(
-        `Content type "${type}" was retired in favour of "${replacement}"` +
-            (where ? ` — ${where}` : "") +
-            `. Both compiled to the same document, so the fix is mechanical: ` +
-            `write "${replacement}".`,
-    );
-}
-
-/* -------------------------------------------------------------------- */
-/*  Renamed in favour of another type — the retirement window            */
-/* -------------------------------------------------------------------- */
-
-/**
- * Content types that were **renamed**, and what each is called now.
- *
- * A retired type and a renamed one are different cases, and only the first can
- * be refused. `character` above was retired *outright* — nothing a note wrote
- * made it right, so {@link assertTypeNotRetired} throws. A renamed type has a
- * replacement, the two spellings mean the same thing, and a note carrying the
- * old one compiles into exactly the document it always did: refusing it would
- * fail a build over a note that is not wrong.
- *
- * So these retire in the three steps `package:` took, and this table is
- * the **first**: both spellings resolve, the current one is canonical, and the
- * retired one is *reported* — never refused. The sweep of the content trees and
- * the refusal come after, once no tree writes the old name. That is the same
- * rule `RETIRED_FIELD_ALIASES` states for a renamed *field*, and for the same
- * reason: a consumer must be able to adopt the new toolchain before its content
- * moves, and there are some 31,000 references to move.
- *
- * **Why these three, and why this way round.** The specification renamed
- * `armorgear`, `concoctiongear` and `projectilegear` to `armor`, `concoction`
- * and `projectile`, on the argument that the suffix named the *SoHL document
- * subtype* a note compiled into rather than the thing the note is about. That
- * rename is **reversed**: the gear-suffixed spellings are the vocabulary, and
- * the bare ones are what retires.
- *
- * Nothing had adopted the bare spellings, which is what makes the reversal
- * cheap and the direction obvious: across all five content trees, **every note
- * still authors the suffix** — 331 `armorgear` and 18 `projectilegear` in
- * `sohl`, 71 `concoctiongear` in `thalorna`, and not one note anywhere writes
- * `armor`, `concoction` or `projectile`. The rename produced 349 warnings and
- * zero adopters.
- *
- * `weapongear` never moved, and the reversal restores the consistency its
- * staying put had broken: all five gear types spell the suffix again.
- *
- * **Keyed by the retired spelling**, which is the opposite of
- * `RETIRED_FIELD_ALIASES`. The direction follows the operation: a field alias
- * is scoped by the schema that declares the *current* name, so that is what a
- * reader asks with; a type alias is applied to a value read off a note, so what
- * a reader has in hand is the retired spelling and what it needs is the
- * replacement.
- *
- * **The address is not normalised.** A note's canonical address — and therefore
- * its document id — carries its `type` as authored, so both spellings keep the
- * addresses they already publish and a tree that has not swept compiles
- * byte-identically. Renaming the type in a note *is* an address move, which is
- * the sweep's business and not this table's.
- *
- * @type {Readonly<Record<string, string>>}
- */
-export const RENAMED_TYPES = Object.freeze({
-    armor: "armorgear",
-    concoction: "concoctiongear",
-    projectile: "projectilegear",
-});
-
-/**
- * The current spelling of a content type: itself, or what it was renamed to.
- *
- * Every table keyed by note type is keyed by the **current** name, and every
- * lookup goes through this — which is the whole of the window's behaviour, in
- * one function, so no two readers can disagree about which vocabulary a note
- * is held to.
- *
- * A non-string passes through untouched: callers hand this whatever the
- * frontmatter carried, and inventing a type for a number would hide the
- * missing-`type:` finding that belongs to the linter.
- *
- * @param {any} type - The type as authored, or as a link spells it.
- * @returns {any} The current spelling.
- */
-export function currentType(type) {
-    if (typeof type !== "string") return type;
-    return RENAMED_TYPES[type] ?? type;
-}
-
-/**
- * What a note declaring a renamed type is told, in one place.
- *
- * Shared by every reporter, because an author meets whichever runs first and
- * they should read the same. It names the type to write rather than a value to
- * correct — no value makes the retired spelling right — and it says the note
- * compiles either way, so a reader knows this is a rename to schedule rather
- * than a build to unbreak.
- *
- * @param {string} retired - The spelling the note used.
- * @param {string} current - What to write instead.
- * @param {string} [where] - What carries it — a file path, a link target —
- *   appended to the message. Omit it where the caller emits through a
- *   diagnostic, whose locator already starts the line.
- * @returns {string} The message, unpunctuated at the end as a finding is.
- */
-export function renamedTypeMessage(retired, current, where) {
-    return (
-        `content type "${retired}" was renamed to "${current}" — the suffix ` +
-        `named a SoHL document subtype rather than the thing the note is ` +
-        `about` +
-        (where ? ` — ${where}` : "") +
-        `. Both spellings compile to the same document, so the note is not ` +
-        `wrong; write "${current}", and move every \`(type, shortcode)\` ` +
-        `reference and wikilink to it in the same change. "${retired}" is ` +
-        `refused in a later release`
-    );
-}
-
 /** Where every other content type compiles: the items pack. */
 export const ITEM_PACK = Object.freeze({ pack: "items", docType: "Item" });
 
@@ -313,18 +156,9 @@ export const ITEM_PACK = Object.freeze({ pack: "items", docType: "Item" });
  *
  * @param {string} type - The target note's `type`.
  * @returns {{pack: string, docType: string}} The pack and document type.
- * @throws {Error} If `type` names a retired content type — see
- *   {@link RETIRED_TYPES}. The open-set default would otherwise route it to the
- *   items pack and say nothing.
  */
 export function packForType(type) {
-    assertTypeNotRetired(type);
-    // Through {@link currentType} like every other type-keyed lookup, so the
-    // rule holds without exception. None of today's renamed types is named in
-    // `PACK_BY_TYPE` — all three are items and take the default — but a router
-    // that read the authored spelling would be the one table left to remember
-    // when the next rename lands.
-    return PACK_BY_TYPE[currentType(type)] ?? ITEM_PACK;
+    return PACK_BY_TYPE[type] ?? ITEM_PACK;
 }
 
 /**

package/engine/index-records.mjs

@@ -110,15 +110,17 @@ export function noteFile(contentBase, record) {
 }
 
 /**
- * The note's own frontmatter, as authored, from an index record.
+ * The note's frontmatter from an index record, without the keys the index
+ * derives.
  *
  * The inverse of the record's spread, and exact rather than best-effort: a
  * record is the note's frontmatter plus {@link DERIVED_KEYS}, and a note that
  * authors one of those keys fails the walk — so removing them cannot remove
  * anything the note wrote. That enforced pairing is what lets a pass read the
- * corpus from the index and still lint, route or compile what the *author*
- * typed, rather than reasoning about `address:` and `anchors:` as though
- * someone had written them.
+ * corpus from the index without reasoning about `address:` and `anchors:` as
+ * though someone had written them. The record's `data.culture` is the note's
+ * resolved culture, so a pass reading the frontmatter sees an inherited culture
+ * as well as a written one.
  *
  * Lives beside the list it is the inverse of, so the two cannot drift.
  *

package/engine/index.mjs

@@ -69,9 +69,6 @@ export * as contentPackage from "./content-package.mjs";
 /** Which content package a note belongs to, and refusing one that says so. */
 export * as notePackage from "./note-package.mjs";
 
-/** Frontmatter fields a note may no longer declare, and the refusal of them. */
-export * as retiredFields from "./retired-fields.mjs";
-
 /** Schema fields a note may never declare, because play writes them. */
 export * as runtimeOnlyFields from "./runtime-only-fields.mjs";
 

package/engine/infobox-render.mjs

@@ -36,7 +36,12 @@
 
 import { encodeAddresses } from "./address-values.mjs";
 import { sectionHolds } from "./infobox.mjs";
-import { absolutePageUrl, escapeTypst, escapeTypstString } from "./pdf-render.mjs";
+import {
+    absolutePageUrl,
+    crossBookReference,
+    escapeTypst,
+    escapeTypstString,
+} from "./pdf-render.mjs";
 
 /**
  * How many cells an attribute grid packs into a row.
@@ -239,12 +244,19 @@ export function sectionHasContent(section) {
  * @param {Map<string, string>} links - Address slug → the book's anchor.
  * @param {(anchor: string) => string} labelFor - The anchor's Typst label.
  * @param {string} [site] - The absolute address this book's pages are served at.
+ * @param {{get: (key: string) => (object|undefined)}} [elsewhere] - The notes
+ *   another book is home to. One of them is not a link — a PDF link cannot
+ *   leave its file — and is set as
+ *   {@link module:engine/pdf-render.crossBookReference}.
  * @returns {string} Typst markup.
  */
-export function linkToTypst(value, links, labelFor, site) {
+export function linkToTypst(value, links, labelFor, site, elsewhere) {
     const text = escapeTypst(value?.text ?? "");
-    const anchor = value?.address ? links?.get(encodeAddresses(value.address)) : undefined;
+    const address = value?.address ? encodeAddresses(value.address) : undefined;
+    const anchor = address ? links?.get(address) : undefined;
     if (anchor) return `#link(<${labelFor(anchor)}>)[${text}]`;
+    const away = address ? elsewhere?.get(address) : undefined;
+    if (away) return crossBookReference(text, away);
     if (value?.url)
         return `#link("${escapeTypstString(absolutePageUrl(value.url, site))}")[${text}]`;
     return text;

package/engine/infobox.mjs

@@ -114,11 +114,10 @@
 
 import { isAddressTuple, parseAddress, renderAddress } from "./address.mjs";
 import { getFrontmatter } from "./frontmatter.mjs";
-import { currentType } from "./ids.mjs";
 import { NOTE_VOCABULARY, dataFields } from "./note-vocabulary.mjs";
-import { readAliasedField } from "./retired-fields.mjs";
 import { subtypeRow } from "./document-subtypes.mjs";
 import { authoredKey } from "./system-block.mjs";
+import { cultureNamesItself } from "./culture-choice.mjs";
 import { formatDateInCalendar, formatNoteDate, parseNoteDate } from "./note-dates.mjs";
 import { displayBeingHeight, displayBeingWeight } from "./being-measurements.mjs";
 import {
@@ -317,6 +316,7 @@ export const NOTE_FIELD_PRESENTATION = Object.freeze({
     // Scene itself, not a fact a summary row can carry.
     "map.scene": Object.freeze({ withheld: "canvas machinery, not a summary row" }),
     "map.fixup": Object.freeze({ withheld: "canvas machinery, not a summary row" }),
+    "map.thumbnail": Object.freeze({ withheld: "an image, which the box never carries" }),
 
     assocSkill: Object.freeze({ label: "Skill" }),
     assocAffiliation: Object.freeze({ label: "Affiliation" }),
@@ -385,7 +385,7 @@ export const NOTE_FIELD_PRESENTATION = Object.freeze({
  */
 export function overlayFor(presentation, type, name) {
     const key = authoredKey(name);
-    return presentation?.[`${currentType(type)}.${key}`] ?? presentation?.[key] ?? {};
+    return presentation?.[`${type}.${key}`] ?? presentation?.[key] ?? {};
 }
 
 /** What a composed group's row is called. @type {Readonly<Record<string, string>>} */
@@ -622,9 +622,9 @@ export const MEMBERSHIPS_SECTION = Object.freeze({ id: "affiliations", label: "A
  * Each entry is the line a reader meets — `War Chief, Hárár (5), of Vrystwald
  * Tribes` — with the body's name as the link and the standing before it as the
  * entry's `lead`, drawn as plain text. The rung's title is read from the body's
- * own ladder, carried on the reference as its `standings` digest, so a renamed
+ * own ladder, carried on the reference as its `standings` digest, so renaming a
  * rung renames every line pointing at it. A body that publishes no page keeps
- * its name as plain text, and a membership in the list form is the name alone.
+ * its name as plain text, and a membership stating no standing is the name alone.
  *
  * The entries are a `list` section of their own rather than one `links` row,
  * because a line already holds commas and a `links` row joins its values with
@@ -916,7 +916,7 @@ function declaredKeyRows(fields, raw) {
  *
  * The declared string is appended **verbatim**, which is what lets a symbol
  * hug its number (`160d`) and a word stand off it (`1.1 lbs`). The row's kind
- * becomes `text`: a number with a unit on it is no longer a number, and saying
+ * becomes `text`: a number with a unit on it is not a number, and saying
  * otherwise would invite a medium to format it as one.
  *
  * @param {string} kind - The row's kind.
@@ -960,7 +960,8 @@ export function linkValue(ref, resolve, hint) {
  * order, minus what {@link NOTE_FIELD_PRESENTATION} withholds and minus every
  * field the note left empty. A being's top-level `subType` adds its profile
  * type. A type that declares no `data:` fields still gets the box, because
- * `Name` is a fact about every note.
+ * `Name` is a fact about every note. `data.culture` is the resolved culture,
+ * inherited ones included, and is left out where it names the note itself.
  *
  * @param {object} fm - The note's frontmatter.
  * @param {object} [options] - Options.
@@ -1022,12 +1023,10 @@ function noteBox(
     for (const field of dataFields(fm?.type, vocabulary) ?? []) {
         const overlay = overlayFor(presentation, fm?.type, field.name);
         if (overlay.withheld) continue;
-        // The retired spelling underneath, so a note part-way through a rename
-        // still shows its value rather than losing the row with nothing said.
-        // The current name wins, which is the whole of the retirement window's
-        // behaviour and is `readAliasedField`'s answer, not a second one.
-        const own = getFrontmatter(data, field.name, undefined);
-        let raw = own !== undefined ? own : readAliasedField(fm, field.name, { inData: true });
+        let raw = getFrontmatter(data, field.name, undefined);
+        // A culture note resolves to itself, and a row linking it to itself
+        // says nothing.
+        if (field.name === "culture" && cultureNamesItself(fm, raw, { contentPackage })) continue;
         if (
             ((fm?.type === "being" && ["born", "died"].includes(field.name)) ||
                 (fm?.type === "place" && field.name === "present")) &&
@@ -1333,7 +1332,7 @@ export function buildInfoboxes(fm, options) {
             sections: [],
         };
         if (available && provider) {
-            const type = currentType(fm.type);
+            const type = fm.type;
             const ctx = {
                 block: map.block,
                 resolve,

package/engine/item-compiler.mjs

@@ -57,7 +57,6 @@ import { itemDocEntryId, itemDocPointer } from "./item-docs.mjs";
 // configuration, so the types this pass claims and the builders it compiles
 // them with are one table — the consuming repository's, not this package's.
 import { itemTypes, itemBuilder, itemArt, itemFields } from "./item-registry.mjs";
-import { currentType } from "./ids.mjs";
 // Which Foundry Item subtype a note's `type` compiles into. Looked up in the
 // system's declared map, never inferred from the type itself.
 import { documentSubtype, subtypeRow } from "./document-subtypes.mjs";
@@ -198,10 +197,7 @@ export class SystemItemCompiler extends BasePackCompiler {
      * @returns {boolean} True for a whitelisted item type.
      */
     selects(fm) {
-        // Through {@link currentType}: the registry is keyed by the current
-        // spelling, and a note still on a renamed one compiles unchanged
-        // during the retirement window.
-        if (!fm.type || !itemTypes().has(currentType(fm.type))) return false;
+        if (!fm.type || !itemTypes().has(fm.type)) return false;
         const map = /** @type {typeof SystemItemCompiler} */ (this.constructor).documentSubtypes;
         const row = subtypeRow(/** @type {never} */ (map), fm.type);
         return !row || row.document === "Item";
@@ -382,10 +378,8 @@ export class SystemItemCompiler extends BasePackCompiler {
         });
 
         const effects = blockProperty(fm, system, "effects");
-        // Read through the system block like every other item field. There is
-        // one spelling: `packFolder` names a folder note by its address, the
-        // `folder:` id spelling having been retired with the per-pack YAML it
-        // resolved against.
+        // Read through the system block like every other item field.
+        // `packFolder` names a folder note by its address.
         const folder = this.folderResolver(blockDataProperty(fm, system, "packFolder", null), {
             isAddress: true,
         });
@@ -415,7 +409,7 @@ export class SystemItemCompiler extends BasePackCompiler {
 
     /** @inheritdoc */
     onCompiled(fm) {
-        this.counts[currentType(fm.type)]++;
+        this.counts[fm.type]++;
     }
 
     /** @inheritdoc */

package/engine/item-docs.mjs

@@ -22,10 +22,8 @@
  * which {@link sohl.utils.descriptionLinkTarget} recognises and
  * Display Description follows.
  *
- * The prose then exists once. Previously every actor carrying an item carried
- * its own copy of that item's description: 7.59 MB across the actors pack, of
- * which only 133 KB was distinct text. Nothing about actors changes —
- * they embed whatever the item carries, and what the item carries is now a link.
+ * The prose then exists once, not as a copy on every actor carrying the item.
+ * Actors embed whatever the item carries, and what the item carries is now a link.
  *
  * **Two passes, no shared state.** The items pass writes the pointer; the
  * journals pass writes the entry it points at. Neither can see the other's
@@ -106,7 +104,7 @@ export function itemDocEntryId(itemId) {
  *   item beats a bare UUID.
  * @param {string} pageId - The id of the selected entry page, from
  *   {@link journalPageId}.
- * @param {object} [fm] - The source note, used to route GM-only prose.
+ * @param {object} [fm] - The source note, which routes GM-only prose.
  * @returns {string} The pointer to store in `system.docHtml`.
  */
 export function itemDocPointer(packageId, itemId, name, pageId, fm) {

package/engine/item-registry.mjs

@@ -40,7 +40,6 @@
  * @module
  */
 
-import { currentType } from "./ids.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
 import { resolveImg } from "./helpers.mjs";
 
@@ -51,10 +50,8 @@ import { resolveImg } from "./helpers.mjs";
  *
  * **Derived, never authored.** These are the keys of the consuming
  * repository's `itemBuilders` registry, so the whitelist and the builder table
- * are the same list and cannot drift apart. They already had: `trait` was
- * whitelisted long after the item type was retired, with no builder
- * behind it, so every `type: trait` note passed the gate and then failed to
- * compile.
+ * are the same list and cannot drift apart. A whitelist naming a type with no builder would
+ * let every note of that type pass the gate and then fail to compile.
  *
  * An accessor rather than a hoisted constant, so that importing this module
  * needs no configuration.
@@ -84,11 +81,6 @@ export function itemTypes() {
  */
 function lookup(what, table, type, system) {
     const config = loadPackConfig();
-    // The registry is keyed by the current spelling of a note type, and a note
-    // still on a renamed one resolves through it unchanged. One place, because
-    // every type-keyed table this module reaches — builders, art, fields — is
-    // indexed here.
-    type = currentType(type);
     if (system !== undefined) {
         const perSystem = /** @type {Record<string, Record<string, unknown>>} */ (
             config[`${table}BySystem`]

package/engine/journals.mjs

@@ -796,15 +796,11 @@ export class Journals extends BasePackCompiler {
         // sits under the same heading a reader found the item under.
         //
         // An address is resolved wherever it is written, including here — and
-        // resolving it *here* is what cures the defect this comment used to
-        // describe. A folder note has one definition and one address, so the
+        // resolving it *here* keeps the folders agreeing. A folder note has one definition and one address, so the
         // journals pack materialises the very folder the items pack does, by
         // the same id. There is no second folder file left to disagree
         // with the first, and so no arrangement to assume: the mirroring
         // failure is unrepresentable rather than merely reported.
-        //
-        // The id spelling used to cross packs verbatim here, on the assumption
-        // both declared it — the arrangement retired with the YAML.
         const { value: authoredFolder } = folderField(fm);
         const folder = this.folderResolver(authoredFolder, { isAddress: true });
 

package/engine/literature-notes.mjs

@@ -13,7 +13,9 @@
 
 /**
  * A work a people tells, sings or writes: the `literature` lore subType and the
- * four optional facts such a note may state about itself.
+ * three optional facts only such a note may state about itself. Whose work it
+ * is, `data.culture`, is a field every lore note but a culture note may state,
+ * declared in `culture-choice.mjs`.
  *
  * `DataFieldSpec` declares the keys a type accepts, not the subType that may
  * write them, so {@link checkLiteratureNote} scopes these keys to `literature`
@@ -23,7 +25,6 @@
  */
 
 import { isAddressTuple, parseAddress, renderAddress } from "./address.mjs";
-import { checkCultureChoice } from "./culture-choice.mjs";
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 
 /** The `lore` subType whose notes are works of literature. */
@@ -66,20 +67,11 @@ export function checkLanguageChoice(note, { index } = {}) {
 }
 
 /**
- * The fields a `literature` note may state. Every one is optional.
+ * The fields only a `literature` note may state. Every one is optional.
  *
  * @type {ReadonlyArray<object>}
  */
 export const LITERATURE_FIELDS = Object.freeze([
-    {
-        name: "culture",
-        shape: "an Address",
-        kind: "address",
-        ref: "lore",
-        accepts: ["lore"],
-        check: checkCultureChoice,
-        describe: "The people whose work this is, as a culture lore note.",
-    },
     {
         name: "form",
         shape: "string",

package/engine/macros.mjs

@@ -264,8 +264,7 @@ export function buildMacroEntry(fm, { command, folder = null, stats = defaultSta
         // into chat instead of running.
         type: resolveMacroType(fm, name),
         author: null,
-        // Nullish, not `||`: a macro note that names no art gets the
-        // shared default, one that writes `icon: ""` ships blank on purpose.
+        // A macro note that names no art gets the shared default.
         img: (img === undefined ? null : img) ?? DEFAULT_MACRO_IMG,
         scope: resolveMacroScope(fm, name),
         command,

package/engine/map-graphviz.mjs

@@ -1,4 +1,15 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
 
 /** Render DOT maps with the Graphviz runtime installed by npm. */
 

package/engine/markdown-expressions.mjs

@@ -1,4 +1,15 @@
-/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
 
 import Handlebars from "handlebars";