@graphysdk/theme-halloween 0.0.0-stage → 0.1.0

package/dist/night.d.ts

@@ -0,0 +1,10 @@
+export interface NightColors {
+    top: string;
+    bottom: string;
+    moon: string;
+    bat: string;
+    star: string;
+    web: string;
+}
+/** The night as a data URI, for the graph's `fill`. */
+export declare const buildNight: (colors: NightColors) => string;

package/dist/renderer/area.d.ts

@@ -0,0 +1,5 @@
+import { ResolvedGeomRenderer } from '@graphysdk/react';
+/** Each area as a drift of mist in its colour, densest at its glowing upper edge. */
+export declare const halloweenArea: ResolvedGeomRenderer;
+/** A filled radar as a drift of mist. */
+export declare const halloweenRadarArea: ResolvedGeomRenderer;

package/dist/renderer/bar.d.ts

@@ -0,0 +1,71 @@
+import { ResolvedGeomRenderer } from '@graphysdk/react';
+import { BarBox } from './utils/bar-box';
+import { Point } from './utils/box-path';
+/** What a headstone is made of, in its own across-and-along measure. */
+export interface HeadstoneShape {
+    plinth: number;
+    left: number;
+    right: number;
+    /** Where the square shoulders sit, along the stone. */
+    shoulder: number;
+    /** How far in from each side the arch begins. */
+    step: number;
+}
+/**
+ * The parts of a headstone for a column that stands alone on the baseline, or `null` for a bar laid
+ * as a plain slab: a course of a stack, a bar along a horizontal axis, one below zero, or one too
+ * short to carve. The crown of the arch is the stone's full length: the value.
+ */
+export declare const shapeHeadstone: (box: BarBox) => HeadstoneShape | null;
+/** The upright stone's outline: up one side, in at the shoulder, over the arch, out and down the other. */
+export declare const traceHeadstone: (box: BarBox, shape: HeadstoneShape) => Point[][];
+interface Carving {
+    text: string;
+    fontSize: number;
+    /** Where the figures stand, along the stone. */
+    baseline: number;
+    /** The figures' middle, across the stone. */
+    across: number;
+}
+/**
+ * Where a stone's value is carved: under the cross on a headstone, in the middle of a plain slab, or
+ * `null` when the figures will not fit at a legible size.
+ */
+export declare const fitCarving: (box: BarBox, shape: HeadstoneShape | null, text: string) => Carving | null;
+/** The inks a stone's carving is cut in: the cut itself, and its lip a pixel below it. */
+export declare const readCarvingInks: (color: string) => {
+    groove: string;
+    lip: string;
+    isPale: boolean;
+};
+/** The object a graph's columns are drawn as, chosen once for the whole graph from the room its bars have. */
+export type GraveObject = 'headstone' | 'candle' | 'railing';
+/** A column at least this broad, in pixels, has room for a headstone that looks like one. */
+export declare const HEADSTONE_BREADTH = 44;
+/** A column at least this broad, and narrower than a headstone's, is a candle; any narrower, a railing post. */
+export declare const CANDLE_BREADTH = 14;
+/**
+ * The object every column of a graph is drawn as, from the breadth its columns have: a headstone where
+ * there is room for one, a candle where the bars are slender, and an iron railing where they are packed
+ * close. Chosen for the graph, never for a bar, so a change of object never reads as a change of meaning.
+ */
+export declare const chooseGraveObject: (breadth: number) => GraveObject;
+/**
+ * The breadth a layer's columns are given: the broadest of them, which every column of a dodged or a
+ * plain graph shares, so a single bar drawn on its own when hovered measures the same as the whole graph.
+ */
+export declare const readColumnBreadth: (boxes: ReadonlyArray<BarBox | null>) => number;
+/**
+ * Each column is one object of the churchyard, the same object for every column of a graph, chosen by
+ * how much room the columns have: a headstone where they are broad, a wax candle where they are
+ * slender, and a wrought-iron railing post where they are packed close. A headstone stands on a low
+ * plinth across its band, its upright kept to a stone's proportions, its arch's crown exactly the
+ * value, with its thickness, grain and an inscription cut into it. A candle's wax ends exactly at the
+ * value, its drips run down from the rim, and only its wick and flame stand above it. A railing post's
+ * spear tip is exactly the value, and a low rail joins it to the posts beside it. A stack is a pile of
+ * plain carved courses, and a horizontal bar a plain ledger slab, at every density. On the graph's
+ * intro each object rises up through its own fixed rectangle from below its foot, like a ghost through
+ * the floor.
+ */
+export declare const halloweenBar: ResolvedGeomRenderer;
+export {};

package/dist/renderer/candle.d.ts

@@ -0,0 +1,41 @@
+import { ReactNode } from 'react';
+import { BarBox } from './utils/bar-box';
+/** Where a candle stands in its bar, in the bar's own across-and-along measure. */
+export interface CandleShape {
+    left: number;
+    right: number;
+    /** The top of the dish, where the wax begins. */
+    dish: number;
+    /** The top of the wax: the bar's whole length, its value. */
+    top: number;
+    wick: number;
+    /** The flame's foot and tip, both above the value. */
+    flameFoot: number;
+    flameTip: number;
+}
+/** The candle that stands in a column's rectangle, its wax ending exactly at the value. */
+export declare const shapeCandle: (box: BarBox) => CandleShape;
+interface CandleWaxProps {
+    box: BarBox;
+    candleKey: string;
+    color: string;
+    fillOpacity: number;
+    /** The wax's gradient, which runs through `color` at its middle. */
+    waxId: string;
+}
+/** The candle's dish, wax and drips, all inside its bar's rectangle. */
+export declare const CandleWax: ({ box, candleKey, color, fillOpacity, waxId }: CandleWaxProps) => ReactNode;
+interface CandleFlameProps {
+    box: BarBox;
+    /** The candlelight's soft glow, a radial gradient fading to nothing. */
+    haloId: string;
+    /** Whether the flame flickers: only on a graph that animates, and never for reduced motion. */
+    isFlickering: boolean;
+}
+/** The glow round every flame of a layer, written once into its definitions. */
+export declare const CandleHalo: ({ id }: {
+    id: string;
+}) => ReactNode;
+/** The wick and the flame, above the top of the wax: the one thing drawn past a bar's value. */
+export declare const CandleFlame: ({ box, haloId, isFlickering }: CandleFlameProps) => ReactNode;
+export {};

package/dist/renderer/ghost.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode, Ref } from 'react';
+interface GhostProps {
+    x: number;
+    y: number;
+    /** The colour of the line the ghost rides, which its outline and its halo take. */
+    color: string;
+    ghostRef?: Ref<SVGGElement>;
+}
+/** A ghost hovering over and just behind (`x`, `y`), its hem clear of the point. */
+export declare const Ghost: ({ x, y, color, ghostRef }: GhostProps) => ReactNode;
+export {};

package/dist/renderer/line.d.ts

@@ -0,0 +1,9 @@
+import { ResolvedGeomRenderer } from '@graphysdk/react';
+/**
+ * A line is a glowing trail with a lit bead on each reading and a little ghost hovering over its last
+ * one. On the graph's intro the trail draws in from its first reading with the ghost riding its head,
+ * and each bead lights as the ghost passes.
+ */
+export declare const halloweenLine: ResolvedGeomRenderer;
+/** A radar's outline as a glowing trail, closed, with a bead on each reading and no ghost. */
+export declare const halloweenRadarLine: ResolvedGeomRenderer;

package/dist/renderer/motion.d.ts

@@ -0,0 +1,34 @@
+import { CSSProperties, ReactNode } from 'react';
+import { LayerIntroPlan } from '@graphysdk/react';
+/** The class names the keyframes below are played through. */
+export declare const MOTION_CLASSES: {
+    /** A pile of pumpkins rises into its bar from below its foot, like a ghost through the floor. */
+    readonly rise: "halloween-rise";
+    /** A lantern lights up: it swells from a spark to its own size. */
+    readonly light: "halloween-light";
+    /** A rose window's panes light up one after another, as the moon comes up behind them. */
+    readonly kindle: "halloween-kindle";
+    /** A candle's flame flickers, for as long as the graph is shown. */
+    readonly flicker: "halloween-flicker";
+};
+/** The keyframes, written once into each layer that plays any. */
+export declare const MotionKeyframes: () => ReactNode;
+/** How long a pile takes to rise, or a lantern to light, and how long it waits first, from the layer's intro plan. */
+export declare const readEntranceTiming: (intro: LayerIntroPlan | null | undefined, key: string) => {
+    duration: number;
+    delay: number;
+} | null;
+/** The custom properties one animated shape reads its timing and starting offset from. */
+export declare const toMotionStyle: (timing: {
+    duration: number;
+    delay: number;
+}, from?: {
+    x: number;
+    y: number;
+}) => CSSProperties;
+/**
+ * Whether a layer's ambient motion (a candle's flicker) plays: only on a graph that plays its intro,
+ * which the engine never asks of a graph drawn with `animation={false}` or for a viewer who prefers
+ * reduced motion. Settled when the layer first mounts, so the flicker carries on once the intro ends.
+ */
+export declare const usePlaysMotion: (intro: LayerIntroPlan | null | undefined) => boolean;

package/dist/renderer/plugins.d.ts

@@ -0,0 +1,8 @@
+import { ResolvedGeomRenderer } from '@graphysdk/react';
+/**
+ * Every built-in geom the Halloween theme repaints, under each coordinate system it is drawn in. A
+ * tile keeps the built-in renderer, rounded and parted by the stylesheet, since a heatmap reads from
+ * its colours and its labels. Positions, scales and axes come from the compiled layer unchanged, and
+ * colour and opacity come from the stylesheet.
+ */
+export declare const halloweenPlugins: readonly ResolvedGeomRenderer[];

package/dist/renderer/point.d.ts

@@ -0,0 +1,8 @@
+import { ResolvedGeomRenderer } from '@graphysdk/react';
+/**
+ * Scatter and bubble: a little jack-o'-lantern whose body is centred on each reading, so the reading
+ * is the middle of the pumpkin, not its stem. On the graph's intro each lantern lights up in turn.
+ */
+export declare const halloweenPoint: ResolvedGeomRenderer;
+/** A radar's vertices as lanterns. */
+export declare const halloweenRadarPoint: ResolvedGeomRenderer;

package/dist/renderer/pumpkin.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from 'react';
+/** Candlelight showing through a carved face. */
+export declare const CANDLELIGHT = "#FFE9A3";
+/** The dark inside a pumpkin, seen through a face carved into a pale one. */
+export declare const HOLLOW = "#2A1533";
+/** The colour a face carved into a pumpkin of `color` shows. */
+export declare const readFaceColor: (color: string) => string;
+/** The colour a pumpkin's ribs are drawn in: its own colour, deeper. */
+export declare const readRibColor: (color: string) => string;
+/**
+ * A body lit from inside: brightest just below its middle, where the candle sits, and deepening to
+ * its edge. Measured on each shape it fills, so one gradient serves every pumpkin of a colour.
+ */
+export declare const PumpkinGlow: ({ id, color }: {
+    id: string;
+    color: string;
+}) => ReactNode;
+interface PumpkinProps {
+    cx: number;
+    cy: number;
+    width: number;
+    height: number;
+    color: string;
+    /** The `url()` of the pumpkin's glow gradient. */
+    fill: string;
+    /** Whether to draw its stem: a pumpkin piled under another has its stem hidden. */
+    hasStem?: boolean;
+}
+/** A carved pumpkin centred on (`cx`, `cy`), filling a box `width` by `height`. */
+export declare const Pumpkin: ({ cx, cy, width, height, color, fill, hasStem }: PumpkinProps) => ReactNode;
+export {};

package/dist/renderer/railing.d.ts

@@ -0,0 +1,45 @@
+import { ReactNode } from 'react';
+import { BarBox } from './utils/bar-box';
+export declare const RAIL_IRON = "#5B4E66";
+/** Where a post stands in its bar, in the bar's own across-and-along measure. */
+export interface PostShape {
+    left: number;
+    right: number;
+    /** The foot of the spear's head, where the post ends. */
+    neck: number;
+    headHalf: number;
+    /** The spear's tip: the bar's whole length, its value. */
+    tip: number;
+}
+/** The post that stands in a column's rectangle, its spear's tip exactly on the value. */
+export declare const shapePost: (box: BarBox) => PostShape;
+interface PostProps {
+    box: BarBox;
+    color: string;
+    fillOpacity: number;
+    /** The paint's gradient across the post, which runs through `color` at its middle. */
+    paintId: string;
+}
+/** The iron post and its spear-point finial, inside its bar's rectangle. */
+export declare const RailingPost: ({ box, color, fillOpacity, paintId }: PostProps) => ReactNode;
+/** The posts either side of one along the fence: how far away each is, and where its spear begins. */
+export interface RailNeighbours {
+    before: {
+        gap: number;
+        neck: number;
+    } | null;
+    after: {
+        gap: number;
+        neck: number;
+    } | null;
+}
+interface RailProps {
+    box: BarBox;
+    neighbours: RailNeighbours;
+}
+/**
+ * The rails through a post, each reaching halfway to the post beside it, where that post draws the other
+ * half. A rail runs only between two posts that both stand clear above it.
+ */
+export declare const RailingRail: ({ box, neighbours }: RailProps) => ReactNode;
+export {};

package/dist/renderer/slice.d.ts

@@ -0,0 +1,45 @@
+import { ResolvedGeomRenderer } from '@graphysdk/react';
+/** Carved stone: the tracery, the rim, the boss and a donut's roundel. */
+export declare const TRACERY_STONE = "#A39A8C";
+interface Centre {
+    x: number;
+    y: number;
+}
+interface Sector {
+    startAngle: number;
+    endAngle: number;
+    innerRadius: number;
+    outerRadius: number;
+}
+/**
+ * A mullion's width for a window of `radius` whose panes are `sectors`: a share of the radius, held
+ * between a least and a most in pixels, and thinner where the typical pane is narrow or shallow, so the
+ * stone never crowds out a rose's thin petals or a radial bar's bands. Measured on every pane of the
+ * layer, so a hovered pane is traced exactly as it is drawn.
+ */
+export declare const readMullionWidth: (radius: number, sectors?: readonly Sector[]) => number;
+/**
+ * A pointed Gothic lancet filling a piece of glass: straight sides along the piece's radii, its foot on
+ * the piece's inner arc and a pointed arch for a head, whose tip touches the piece's outer arc. It lies
+ * wholly inside the piece, so it is leading within the pane and never moves the pane's edge.
+ */
+export declare const buildLancet: (piece: Sector, panelRadius: number, centre: Centre) => string;
+/**
+ * The pieces of glass a pane is leaded into, as sectors of the pane's own sector: whole rings out from
+ * the middle, each split across into more pieces than the ring inside it, as a real window's are.
+ * Every piece lies inside the pane, so the leading between them never reaches past its slice.
+ */
+export declare const splitPane: (sector: Sector, panelRadius: number, hasLancets?: boolean) => Array<Sector & {
+    isLancet: boolean;
+}>;
+/** A quatrefoil of four lobes, each a circle, centred on `centre` and reaching `radius` from it. */
+export declare const buildQuatrefoil: (centre: Centre, radius: number) => string;
+/**
+ * Pie, donut, rose and radial bar as a church's rose window lit from behind by the moon. Each slice
+ * keeps its own honest sector as a pane of stained glass in its group's colour, glowing at its heart
+ * and leaded into pieces inside its own edge. The stone tracery is drawn centred on every slice's
+ * outline, so it takes as much from one pane as from its neighbour. A pie's mullions meet at a stone
+ * boss; a donut's hole is the window's carved stone roundel.
+ */
+export declare const halloweenSlice: ResolvedGeomRenderer;
+export {};

package/dist/renderer/utils/bar-box.d.ts

@@ -0,0 +1,27 @@
+import { MainAxis, Observation, XYPoint } from '@graphysdk/react';
+import { PixelRect, PixelSize } from './projections';
+export type Edge = 'top' | 'right' | 'bottom' | 'left';
+export interface BarBox {
+    /** The bar's rectangle in panel pixels, drawn in from any edge it shares with a neighbour in its stack. */
+    rect: PixelRect;
+    /** The edge the value ends at. */
+    valueEdge: Edge;
+    /** Whether the bar ends its stack, so its value's edge is the one a reader measures. */
+    endsStack: boolean;
+    /** Whether the bar starts its stack, so its foot stands on the baseline. */
+    startsStack: boolean;
+    /** Whether the bar stands upright, so its breadth runs across the page. */
+    isColumn: boolean;
+    /** Across the band. */
+    breadth: number;
+    /** Along the value, from the foot. */
+    length: number;
+    /** The middle of the foot, where the bar grows from. */
+    foot: XYPoint;
+    /** The way the bar grows from its foot, one pixel long. */
+    growth: XYPoint;
+    /** A point `across` the band from one side and `along` the value from the foot, in panel pixels. */
+    at: (across: number, along: number) => XYPoint;
+}
+/** A bar's box in panel pixels, or `null` for a bar with no area to draw. */
+export declare const readBarBox: (observation: Observation, mainAxis: MainAxis, panel: PixelSize, stackGap: number) => BarBox | null;

package/dist/renderer/utils/box-path.d.ts

@@ -0,0 +1,7 @@
+import { BarBox } from './bar-box';
+/** A point in a bar's own measure: `across` its band from one side, `along` its value from its foot. */
+export type Point = [across: number, along: number];
+/** A rectangle in a bar's measure, from `across` and `along` corners. */
+export declare const traceBlock: (left: number, right: number, foot: number, top: number) => Point[][];
+/** A traced outline in panel pixels: `M` at the first point, `L` to a single point, `C` through three. */
+export declare const toPath: (box: BarBox, segments: Point[][], isClosed?: boolean) => string;

package/dist/renderer/utils/ink.d.ts

@@ -0,0 +1,17 @@
+/** `color` moved `amount` of the way to `target`; a colour either cannot read is returned as it is. */
+export declare const mixColors: (color: string, target: string, amount: number) => string;
+/** An id a `url()` can name: React's own holds characters one cannot. */
+export declare const useDefId: (prefix: string) => string;
+/** Ids for one definition per colour under one prefix, for shapes that share a gradient or a pattern. */
+export declare const useColorIds: (prefix: string) => ((color: string) => string);
+/** A number from a string, so a shape's details fall the same way every time it is drawn. */
+export declare const hashSeed: (text: string) => number;
+/** Numbers in `[0, 1)` from a seed, the same run of them for the same seed. */
+export declare const createRandom: (seed: number) => (() => number);
+/** How bright a colour looks, from 0 for black to 1 for white; a colour that cannot be read counts as mid-grey. */
+export declare const measureLuminance: (color: string) => number;
+/**
+ * `color` with its saturation scaled by `factor` and its hue and lightness kept, as coloured glass
+ * shows a stone's own hue more richly; a colour that cannot be read is returned as it is.
+ */
+export declare const saturateColor: (color: string, factor: number) => string;

package/dist/renderer/utils/paint.d.ts

@@ -0,0 +1,21 @@
+import { Observation, SceneLayerFor, StyleState } from '@graphysdk/react';
+/** What a filled shape is drawn with. */
+export interface ShapePaint {
+    color: string;
+    opacity: number;
+    fillOpacity: number;
+    /** The edge that parts it from its neighbours, or rules it when hovered. */
+    edge: string;
+    edgeWidth: number;
+}
+/** What a line is drawn with. Its rails take `color`; the ground shows between them. */
+export interface LinePaint {
+    color: string;
+    opacity: number;
+    width: number;
+    dashArray: string | undefined;
+}
+export type ReadShapePaint = (observation: Observation, state?: StyleState) => ShapePaint;
+export type ReadLinePaint = (observation: Observation, state?: StyleState) => LinePaint;
+export declare const useShapePaint: (layer: SceneLayerFor<"bar" | "point" | "tile" | "area">) => ReadShapePaint;
+export declare const useLinePaint: (layer: SceneLayerFor<"line">) => ReadLinePaint;

package/dist/renderer/utils/paths.d.ts

@@ -0,0 +1,7 @@
+import { PixelSize } from './projections';
+/**
+ * A path written in the unit square, in the panel's pixels. A shape is measured in pixels on every
+ * side, which a path stretched by a transform is not. Reads the commands a line or an area is written
+ * in; an arc is not one of them.
+ */
+export declare const scalePathToPanel: (path: string, panel: PixelSize) => string;

package/dist/renderer/utils/projections.d.ts

@@ -0,0 +1,16 @@
+import { Observation, XYPoint } from '@graphysdk/react';
+export interface PixelSize {
+    width: number;
+    height: number;
+}
+export interface PixelRect extends PixelSize {
+    x: number;
+    y: number;
+}
+/** Where an observation is drawn in the panel, in pixels; `null` for one missing a position. */
+export type Projection = (observation: Observation, panel: PixelSize) => XYPoint | null;
+export declare const projectCartesian: Projection;
+export declare const projectPolar: Projection;
+/** The whole panel, for a shape that may reach any part of it. */
+export declare const toPanelBounds: (panel: PixelSize) => PixelRect;
+export declare const toClosedPath: (points: XYPoint[]) => string;

package/dist/renderer/utils/trace.d.ts

@@ -0,0 +1,19 @@
+import { Observation, SceneLayer, XYPoint } from '@graphysdk/react';
+import { PixelSize, Projection } from './projections';
+/** One group's path in panel pixels, with the observation its paint is read for. */
+export interface Trace {
+    key: string;
+    path: string;
+    observation: Observation;
+}
+/** One trace per group, from whatever turns a group's observations into its path. */
+export declare const readTraces: (layer: SceneLayer, buildPath: (observations: Observation[]) => string | null) => Trace[];
+/** A radar group's vertices in panel pixels, in angular order so its outline never crosses itself. */
+export declare const readRadarPoints: (observations: Observation[], panel: PixelSize) => XYPoint[];
+export declare const buildRadarPath: (observations: Observation[], panel: PixelSize) => string | null;
+/** Each reading of every group in panel pixels, with the observation it is read from. */
+export declare const readReadings: (layer: SceneLayer, panel: PixelSize, project: Projection) => Array<{
+    key: string;
+    observation: Observation;
+    point: XYPoint;
+}>;

package/dist/styles.d.ts

@@ -0,0 +1,47 @@
+import { Stylesheet } from '@graphysdk/react';
+export declare const HALLOWEEN_COLORS: {
+    readonly sky: "#24132F";
+    readonly ground: "#130A1A";
+    readonly raised: "#2C1A38";
+    readonly text: "#F1E8D6";
+    readonly secondary: "#BCA9CC";
+    readonly moon: "#F6EBC8";
+    readonly shadow: "#0A0510";
+    readonly grid: "rgba(241, 232, 214, 0.1)";
+    readonly baseline: "rgba(241, 232, 214, 0.55)";
+    readonly silk: "rgba(241, 232, 214, 0.85)";
+    readonly tag: "#EFE4CC";
+    readonly tagInk: "#2A1533";
+};
+/** Candlelight, kept for what the night itself lights: a pinned value and a comment. Groups never take it. */
+export declare const HALLOWEEN_HUES: {
+    readonly candle: "#FFD24A";
+};
+/**
+ * The stones of a churchyard, which groups are told apart by: a headstone is stone, so a group is a
+ * material, not a bright. Pale marble, dark slate, buff sandstone, moss-weathered stone, rose granite
+ * and grey granite.
+ */
+export declare const HALLOWEEN_STONES: {
+    readonly marble: "#E6E1D8";
+    readonly slate: "#56637A";
+    readonly sandstone: "#C9A677";
+    readonly moss: "#6E8058";
+    readonly rose: "#D6B3B0";
+    readonly granite: "#949089";
+};
+/**
+ * The order groups take their stones in, set by lightness so neighbours part even for a reader who
+ * sees no hue at all: marble and slate are the lightest and nearly the darkest, so a two-group graph is
+ * always clear, and each stone after differs from the one before it by at least fifteen steps of
+ * lightness, for every kind of colour vision. Every stone stays well clear of the night behind it.
+ */
+export declare const HALLOWEEN_PALETTE: readonly string[];
+/** For a colour that stands for a number: from embers in the dark up to candlelight, lighter as it rises. */
+export declare const HALLOWEEN_COLORMAP: readonly string[];
+/**
+ * The Halloween look: a moonlit night inside the graph with no frame round it, a faint grid, a bone
+ * baseline, a goal line spun as a spider's thread, a shaded period as a drift of mist, and notes
+ * written on paper tags. Titles are set in Creepster and everything else in Nunito.
+ */
+export declare const halloweenStyles: Stylesheet;

package/fonts.css

@@ -0,0 +1,2 @@
+/* Creepster for the titles, Cinzel for the numbers carved into the headstones, and Nunito for everything else, the faces the theme's stylesheet names. Import this once, before the first graph is measured. */
+@import url('https://fonts.googleapis.com/css2?family=Cinzel:wght@600;700&family=Creepster&family=Nunito:wght@400;600;700;800&display=swap');

package/licenses/PolyForm-Free-Trial-1.0.0.md

@@ -0,0 +1,93 @@
+# PolyForm Free Trial License 1.0.0
+
+<https://polyformproject.org/licenses/free-trial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software
+to do everything you might do with the software that would
+otherwise infringe the licensor's copyright in it for any
+permitted purpose. However, you may only make changes or
+new works based on the software according to [Changes and New
+Works License](#changes-and-new-works-license), and you may
+not distribute copies of the software.
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## Free Trial
+
+Use to evaluate whether the software suits a particular
+application for less than 32 consecutive calendar days, on
+behalf of you or your company, is use for a permitted purpose.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else. These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+If you violate any of these terms, or do anything with the
+software not covered by your licenses, all your licenses
+end immediately.
+
+## No Liability
+
+_**As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.**_
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization. **Control**
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise. Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.