@fxi/zartigl 0.6.0 → 0.7.0

package/dist/engine.d.ts

@@ -1,3 +1,27 @@
+/** Throws unless the index was written for this catalog entry and source. */
+export declare function assertGeoVideoIndexIdentity(source: CatalogGeoVideoArchiveSource, index: GeoVideoIndex, entry: CatalogEntry): void;
+
+/** Particle backdrop off: see BackdropStyle. */
+export declare const BACKDROP_OFF: Readonly<BackdropStyle>;
+
+/**
+ * Solid color under the particle trails, drawn on valid data cells only: it
+ * keeps particles readable over a light basemap. Off by default; an object
+ * without `enabled` is on.
+ */
+declare interface BackdropStyle {
+    enabled: boolean;
+    /** Hex color, `#rgb` or `#rrggbb`. */
+    color: string;
+    opacity: number;
+}
+
+/**
+ * `u_solid` uniform: straight RGB in [0, 1] and opacity. Alpha is 0 when the
+ * backdrop is off, which also skips the draw.
+ */
+export declare function backdropVec4(backdrop: BackdropStyle): [number, number, number, number];
+
 declare interface CatalogEntry {
     id: string;
     aliases?: string[];
@@ -7,22 +31,10 @@ declare interface CatalogEntry {
     tags?: string[];
     kind: "scalar" | "vector";
     sources: CatalogSource[];
-    defaults: {
+    /** Default source, plus the layer's base style. */
+    defaults: LayerStyleInput & {
         sourceId: string;
         querySourceId?: string;
-        palette?: string;
-        renderMode?: "particles" | "raster" | "raster+particles";
-        particles?: {
-            density?: number;
-            speed?: number;
-            fade?: number;
-        };
-        raster?: {
-            opacity?: number;
-            logScale?: boolean;
-            vibrance?: number;
-            colorDomain?: [number, number];
-        };
     };
 }
 
@@ -102,6 +114,12 @@ declare interface CatalogZarrSource extends CatalogSourceBase {
     variables: CatalogVariables;
 }
 
+/**
+ * `vec3 gradeColor(vec3 c, vec4 g)` of `colorGradeVec4`; GLSL ES 1.0 and
+ * 3.0. It contains VIBRANCE_GLSL: include one or the other, never both.
+ */
+export declare const COLOR_GRADE_GLSL: string;
+
 export declare const COLOR_GRADE_OFF: Readonly<ColorGrade>;
 
 export declare const COLOR_GRADE_VIBRANT: Readonly<ColorGrade>;
@@ -124,6 +142,9 @@ export declare interface ColorGrade {
     highlights: number;
 }
 
+/** Style `particles.grade` of a color grade: a preset when it is one. */
+export declare function colorGradeToGrade(input: Partial<ColorGrade>): ParticleGrade;
+
 /** `u_grade` uniform: (exposure, contrast, saturation, highlights). */
 export declare function colorGradeVec4(grade: ColorGrade): [number, number, number, number];
 
@@ -138,14 +159,136 @@ declare interface CoordArrays {
 
 export declare function createColorRampTexture(gl: WebGL2RenderingContext, ramp?: ColorRampInput): WebGLTexture;
 
+/** The frame source decoding `manifest`: scalar or vector by its encoding. */
+export declare function createGeoVideoFrameSource(manifest: GeoVideoManifest, options?: {
+    cacheSize?: number;
+}): GeoVideoScalarSource | GeoVideoVectorSource;
+
 export declare function createProgram(gl: WebGL2RenderingContext, vertSource: string, fragSource: string): WebGLProgram;
 
+export declare function createShader(gl: WebGL2RenderingContext, type: number, source: string): WebGLShader;
+
 /** Trail length in frames for a 0–1 `fade`. */
 export declare function fadeToFrames(fade: number): number;
 
 /** Per-frame trail opacity multiplier for a 0–1 `fade`. */
 export declare function fadeToOpacity(fade: number): number;
 
+/**
+ * One immutable chunk of a GeoVideo archive, independent of the catalog: a
+ * manifest and the range of its encoded samples.
+ */
+export declare interface GeoVideoArchiveChunk extends GeoVideoChunkSpan {
+    /** Stable identity of the chunk content (the index chunk key). */
+    key: string;
+    /** Absolute manifest URL. */
+    manifestUrl: string;
+    /** Encoded samples, when the index lists them. */
+    samples?: number;
+    provisional?: boolean;
+}
+
+/** One decoded time step of an archive. */
+export declare interface GeoVideoArchiveFrame<TFrame = GeoVideoFrameData> {
+    /** Stable identity: archive id, chunk key and step. */
+    key: string;
+    chunk: GeoVideoArchiveChunk;
+    /** Step within the chunk. */
+    step: number;
+    time: number;
+    data: TFrame;
+    grid: GeoVideoGrid;
+    manifest: GeoVideoManifest;
+}
+
+/**
+ * The frames bracketing a time, possibly from two chunks: display
+ * a·(1 − mix) + b·mix. `b` is `a` with mix 0 in discrete mode or on a step.
+ */
+export declare interface GeoVideoArchiveSample<TFrame = GeoVideoFrameData> {
+    time: number;
+    a: GeoVideoArchiveFrame<TFrame>;
+    b: GeoVideoArchiveFrame<TFrame>;
+    mix: number;
+}
+
+/**
+ * Several chunks of a GeoVideo archive as one continuous timeline. Every
+ * sample request is independent: aborting one leaves the decodes another
+ * request needs. Manifests are cached; chunk sources are kept open in a
+ * bounded LRU and released when evicted. The archive answers instants; it
+ * neither drives a clock nor picks other archives (see pairChunkSpan).
+ */
+export declare class GeoVideoArchiveSource<TFrame = GeoVideoFrameData> {
+    readonly id: string;
+    /** Chunks sorted by start, without empty ranges. */
+    readonly chunks: readonly GeoVideoArchiveChunk[];
+    private readonly maxOpenChunks;
+    private readonly frameCacheSize;
+    private readonly prefetchAt;
+    private readonly maxGap;
+    private readonly loadManifest;
+    private readonly createFrameSource;
+    private readonly manifests;
+    private readonly open;
+    constructor(options: GeoVideoArchiveSourceOptions<TFrame>);
+    /** First and last sample of the archive, or null without chunks. */
+    get range(): [number, number] | null;
+    /** The chunk whose sample range holds `time`, or null. */
+    chunkAt(time: number): GeoVideoArchiveChunk | null;
+    /** Every step time of the archive; loads all chunk manifests. */
+    steps(request?: GeoVideoFrameRequest): Promise<Float64Array>;
+    /**
+     * The frames bracketing `time`, decoded; null out of coverage (before the
+     * first step, after the last, or in a gap wider than `maxGap`).
+     */
+    sample(time: number, request?: GeoVideoFrameRequest & {
+        mode?: GeoVideoSampleMode;
+    }): Promise<GeoVideoArchiveSample<TFrame> | null>;
+    /** Open `chunk` and decode its first frame ahead of a request. */
+    prefetch(chunk: GeoVideoArchiveChunk): void;
+    /** Release every open chunk source; later requests reopen them. */
+    release(): void;
+    private chunkIndexAt;
+    private gapLimit;
+    private prefetchAfter;
+    private manifest;
+    /** The open chunk, pinned for a running sample listed in `used`. */
+    private acquire;
+    /** The open chunk, opened when needed, most recently used; not pinned. */
+    private touch;
+    private frame;
+    /** Release least recently used chunks beyond the bound, unless in use. */
+    private trim;
+    private close;
+}
+
+export declare interface GeoVideoArchiveSourceOptions<TFrame> {
+    /** Archive identity, the prefix of every frame key. */
+    id: string;
+    chunks: readonly GeoVideoArchiveChunk[];
+    /** Chunk sources kept open (decoder, video element); at least 2. */
+    maxOpenChunks?: number;
+    /** Decoded frames cached per chunk source. */
+    frameCacheSize?: number;
+    /**
+     * Progress through a chunk past which the next chunk is opened and its
+     * first frame decoded; above 1 disables prefetching.
+     */
+    prefetchAt?: number;
+    /**
+     * Longest gap bridged between the last step of a chunk and the first of
+     * the next one, in ms. By default 1.5 times the largest step interval at
+     * that boundary, and no bridge when both neighbouring chunks hold a
+     * single step (no cadence known). Unbridged gaps are out of coverage.
+     */
+    maxGap?: number;
+    loadManifest?: (url: string) => Promise<GeoVideoManifest>;
+    createFrameSource?: (manifest: GeoVideoManifest, options: {
+        cacheSize: number;
+    }) => GeoVideoFrameReader<TFrame>;
+}
+
 export declare type GeoVideoBounds = [
 west: number,
 south: number,
@@ -159,11 +302,34 @@ north: number
  */
 export declare function geoVideoChunkSources(source: CatalogGeoVideoArchiveSource, index: GeoVideoIndex, entry: CatalogEntry): CatalogGeoVideoSource[];
 
+/** First and last encoded sample of a chunk, UTC milliseconds. */
+export declare interface GeoVideoChunkSpan {
+    start: number;
+    end: number;
+}
+
+/** Scalar values (NaN invalid) or u/v components (NaN invalid). */
+export declare type GeoVideoFrameData = Float32Array | GeoVideoVectorFrame;
+
+/** The part of a frame source an archive reads. */
+export declare interface GeoVideoFrameReader<TFrame> {
+    frame(index: number, request?: GeoVideoFrameRequest): Promise<TFrame>;
+    release(): void;
+}
+
+/** Options of one frame request. */
+export declare interface GeoVideoFrameRequest {
+    /** Abandons this request only; the decode stops once no request needs it. */
+    signal?: AbortSignal;
+}
+
 /**
  * GeoVideo frames read one time step at a time (seek, no playback): video
- * and static mask loading, luma readback, a serial decode queue that
- * cancelAll() aborts, and a small LRU cache of decoded frames. Subclasses
- * turn the luma codes of a frame into values.
+ * and static mask loading, luma readback, a serial decode queue, and a small
+ * LRU cache of decoded frames. Requests for the same step share one decode;
+ * each can be abandoned with its own signal, and the decode is dropped once
+ * no request waits for it. cancelAll() aborts every pending decode.
+ * Subclasses turn the luma codes of a frame into values.
  */
 export declare abstract class GeoVideoFrameSource<TFrame> {
     /** Grid size; the video stacks `planes` grids vertically. */
@@ -179,21 +345,32 @@ export declare abstract class GeoVideoFrameSource<TFrame> {
     private initPromise;
     private presented;
     private primed;
+    /** Serializes seeks: the previous decode, settled or not, runs first. */
     private queue;
-    private epoch;
+    /** LRU of decoded and pending steps. */
     private readonly frames;
+    /** Pending decodes, including those the LRU already evicted. */
+    private readonly pending;
     constructor(manifest: GeoVideoManifest, planes: number, options?: {
         cacheSize?: number;
     });
     /** Codes of the stacked planes and the per-cell mask to frame values. */
     protected abstract decodeCodes(codes: Uint8Array, mask: Uint8Array, threshold: number): TFrame;
     init(): Promise<void>;
-    /** Abort queued frame decodes; frames already decoded stay cached. */
+    /** Abort every pending frame decode; frames already decoded stay cached. */
     cancelAll(): void;
     /** Release the video element and GL context; a later init() reloads them. */
     release(): void;
-    /** One decode per time step, cached. */
-    frame(index: number): Promise<TFrame>;
+    /**
+     * One decode per time step, cached and shared by concurrent requests.
+     * Aborting `request.signal` rejects this request with an AbortError; the
+     * decode goes on while another request waits for it.
+     */
+    frame(index: number, request?: GeoVideoFrameRequest): Promise<TFrame>;
+    private enqueue;
+    /** A request left; drop the decode when it was the last one waiting. */
+    private leave;
+    private drop;
     private load;
     private loadMask;
     private loadVideo;
@@ -205,9 +382,30 @@ export declare abstract class GeoVideoFrameSource<TFrame> {
      * playback would otherwise buffer far beyond the requested frame.
      */
     private primeDecoder;
-    protected decode(index: number, epoch: number): Promise<TFrame>;
+    /**
+     * Seek, read back and decode one step. `signal` aborts it between steps;
+     * a seek already started completes first, keeping the queue serial.
+     */
+    protected decode(index: number, signal: AbortSignal): Promise<TFrame>;
 }
 
+/**
+ * Grid of decoded frame values. `bounds` are the outer cell edges
+ * [west, south, east, north] in degrees, so cell (column i, row j) is
+ * centered at west + (i + 0.5)·dx, north − (j + 0.5)·dy with
+ * dx = (east − west) / width and dy = (north − south) / height; an east
+ * below west crosses the antimeridian (east + 360). Row 0 is the northern
+ * row, values are row-major.
+ */
+export declare interface GeoVideoGrid {
+    width: number;
+    height: number;
+    bounds: GeoVideoBounds;
+    rowOrder: "north-to-south";
+}
+
+export declare function geoVideoGrid(manifest: GeoVideoManifest): GeoVideoGrid;
+
 /** Mutable listing of an archive's published chunks, written by the renderer. */
 export declare interface GeoVideoIndex {
     schemaVersion: 1;
@@ -234,6 +432,12 @@ export declare interface GeoVideoIndexChunk {
     provisional?: boolean;
 }
 
+/**
+ * Catalog-free chunk descriptors of an index, manifest URLs resolved
+ * against the index URL, in index order.
+ */
+export declare function geoVideoIndexChunks(index: GeoVideoIndex, indexUrl: string): GeoVideoArchiveChunk[];
+
 export declare interface GeoVideoManifest {
     schemaVersion: 3;
     id: string;
@@ -283,6 +487,9 @@ declare interface GeoVideoRangeTimeline {
     interpolation: "linear" | "nearest";
 }
 
+/** Interpolate between bracketing steps, or hold the last step at or before. */
+export declare type GeoVideoSampleMode = "interpolate" | "discrete";
+
 declare interface GeoVideoSampleSequenceTimeline {
     kind: "sample-sequence";
     values: string[];
@@ -383,8 +590,34 @@ export declare class GeoVideoVectorSource extends GeoVideoFrameSource<GeoVideoVe
 
 export declare function getPalettes(): PaletteMeta[];
 
+/** Color grade of a style `particles.grade`; an object tunes the vibrant one. */
+export declare function gradeToColorGrade(grade: ParticleGrade | undefined): ColorGrade;
+
+/** Vibrant grade values; each one left out takes the vibrant preset's. */
+declare interface GradeTuning {
+    /** Mid-tone lift [0, 4]. */
+    exposure?: number;
+    /** S-curve strength [0, 1]. */
+    contrast?: number;
+    /** Vibrance-weighted saturation [-1, 1]. */
+    saturation?: number;
+    /** Push of the bright half toward white [0, 1]. */
+    highlights?: number;
+}
+
 export declare function isGeoVideoArchiveSource(source: CatalogSource): source is CatalogGeoVideoArchiveSource;
 
+/** A `#rgb` or `#rrggbb` color. */
+export declare const isHexColor: (value: unknown) => value is string;
+
+/** A partial style: any key left out takes the value below it. */
+declare interface LayerStyleInput {
+    palette?: string;
+    renderMode?: StyleRenderMode;
+    particles?: ParticleStyleInput;
+    raster?: Partial<RasterStyle>;
+}
+
 export declare function loadGeoVideoIndex(url: string, signal?: AbortSignal): Promise<GeoVideoIndex>;
 
 export declare function loadGeoVideoManifest(source: string | GeoVideoManifest, signal?: AbortSignal): Promise<GeoVideoManifest>;
@@ -403,6 +636,18 @@ export declare function nextChunk<T extends CatalogSource>(chunks: readonly T[],
     time: number;
 } | null;
 
+/**
+ * The chunk following the one that ends at `currentEnd` inside `range`, or
+ * with `loop`, the first one inside it, with the time playback resumes at.
+ */
+export declare function nextChunkSpan<T extends GeoVideoChunkSpan>(chunks: readonly T[], currentEnd: number, options?: {
+    range?: readonly [number, number] | null;
+    loop?: boolean;
+}): {
+    chunk: T;
+    time: number;
+} | null;
+
 /**
  * The candidate whose sample range overlaps `chunk` the most: archives
  * sampled at different hours (six-hourly from 00:00, daily at 12:00) still
@@ -410,6 +655,13 @@ export declare function nextChunk<T extends CatalogSource>(chunks: readonly T[],
  */
 export declare function pairChunk<T extends CatalogSource>(chunk: CatalogSource, candidates: readonly T[]): T | null;
 
+/**
+ * The candidate whose sample range overlaps `span` the most: archives
+ * sampled at different hours (six-hourly from 00:00, daily at 12:00) still
+ * pair by calendar period. Null when none overlaps.
+ */
+export declare function pairChunkSpan<T extends GeoVideoChunkSpan>(span: GeoVideoChunkSpan, candidates: readonly T[]): T | null;
+
 export declare interface PaletteMeta {
     id: string;
     label: string;
@@ -417,6 +669,46 @@ export declare interface PaletteMeta {
     colors: string[];
 }
 
+/** Particle trail color grade: a preset, or the vibrant one tuned. */
+declare type ParticleGrade = "off" | "vibrant" | GradeTuning;
+
+declare interface ParticleStyle {
+    /** Particles per device pixel, (0, 0.2]. */
+    density: number;
+    /** Css px per frame for the fastest value of the field, (0, 10]. */
+    speed: number;
+    /** Trail length, [0, 1] (longer when higher). */
+    fade: number;
+    /** Trail color grade; replaced as a whole, not merged. */
+    grade: ParticleGrade;
+    /** Solid color under the trails; replaced as a whole, not merged. */
+    backdrop: BackdropStyle;
+}
+
+/** Partial particle style; a partial backdrop takes the defaults' keys. */
+declare type ParticleStyleInput = Partial<Omit<ParticleStyle, "backdrop">> & {
+    backdrop?: Partial<BackdropStyle>;
+};
+
+/** `float random(uvec3 v)`, an integer hash in [0, 1); GLSL ES 3.0. */
+export declare const RANDOM_GLSL: string;
+
+declare interface RasterStyle {
+    opacity: number;
+    logScale: boolean;
+    /** Vibrance adjustment, [-1, 1]. */
+    vibrance: number;
+    /** Fixed physical-value domain; null follows the data. */
+    colorDomain: [number, number] | null;
+}
+
+/**
+ * Complete backdrop from partial input. Missing or invalid values take the
+ * defaults, opacity is clamped; `enabled` defaults to true when any input is
+ * given, so `{ opacity: 0.2 }` means "on".
+ */
+export declare function resolveBackdrop(input?: Partial<BackdropStyle>): BackdropStyle;
+
 /**
  * Complete grade from partial input. Missing or non-finite values take the
  * vibrant preset, others are clamped to their range; `enabled` defaults to
@@ -430,6 +722,13 @@ export declare function resolveColorRamp(input: ColorRampInput, options?: {
 
 export declare type ScalarColorDomain = [number, number];
 
+/**
+ * Layer style: how a layer looks, with the same keys in the catalog
+ * `defaults`, the engines and story views. Playback (how time moves) is not
+ * part of it, so `particles.speed` is always the particle speed.
+ */
+declare type StyleRenderMode = "particles" | "raster" | "raster+particles";
+
 /**
  * Camera-aware per-frame fade opacity: eases toward a short retention while
  * the camera moves, then back to the configured one. Smoothstep avoids
@@ -467,6 +766,9 @@ declare type VectorFieldSource = Pick<ZarrSource, "init" | "cancelAll" | "getCoo
     getValueDomain?(): number;
 };
 
+/** `vec3 applyVibrance(vec3 c, float v)`; GLSL ES 1.0 and 3.0. */
+export declare const VIBRANCE_GLSL: string;
+
 declare interface ZarrAttrs {
     _ARRAY_DIMENSIONS?: string[];
     units?: string;

package/dist/engine.js

@@ -1,29 +1,82 @@
-import { C as o, a as r, G as s, b as i, T as d, c as l, d as t, e as c, f as G, g as V, h as m, i as n, j as u, k as C, l as f, m as p, n as v, p as x, r as R, o as S, v as T, q as O } from "./geovideo-index-CD5wflJT.js";
-import { G as h } from "./GeoVideoScalarSource-DoQAnyTy.js";
-import { v as k } from "./scalar-color-domain-PEK8Hxg1.js";
+import { D as d, E as i, F as l, G as m, T as u, H as v, b as x, I as g, c as p, J as f, K as G, l as V, B as C, L as b, M as S, q as _, x as O, y as R, A as h, m as A, z as L, N as F, O as T, P as k, o as y, Q as I, C as D, v as B } from "./geovideo-index-CMGVia5M.js";
+import { B as w, C as M, e as N, b as P, d as z, c as H, g as K, i as q, a as J, r as Q } from "./backdrop-DctkJ45Q.js";
+var e = `vec3 applyVibrance(vec3 c, float v) {
+    float mx = max(c.r, max(c.g, c.b));
+    float mn = min(c.r, min(c.g, c.b));
+    float boost = v * (1.0 - (mx - mn));
+    float luma = dot(c, vec3(0.299, 0.587, 0.114));
+    return mix(vec3(luma), c, 1.0 + boost);
+}
+
+vec3 gradeColor(vec3 c, vec4 g) {
+    float m = max(c.r, max(c.g, c.b));
+    if (m > 0.0) {
+        
+        
+        float e = g.x > 1e-3 ? (1.0 - exp(-g.x * m)) / (1.0 - exp(-g.x)) : m;
+        
+        e += g.w * smoothstep(0.5, 1.0, e) * (1.0 - e);
+        c *= e / m;
+    }
+    
+    c = mix(c, c * c * (3.0 - 2.0 * c), g.y);
+    return clamp(applyVibrance(c, g.z), 0.0, 1.0);
+}`, a = `uint pcg(uint v) {
+    uint state = v * 747796405u + 2891336453u;
+    uint word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+    return (word >> 22u) ^ word;
+}
+
+float random(uvec3 v) {
+    return float(pcg(v.x ^ pcg(v.y ^ pcg(v.z))) >> 8u) * (1.0 / 16777216.0);
+}`, o = `vec3 applyVibrance(vec3 c, float v) {
+    float mx = max(c.r, max(c.g, c.b));
+    float mn = min(c.r, min(c.g, c.b));
+    float boost = v * (1.0 - (mx - mn));
+    float luma = dot(c, vec3(0.299, 0.587, 0.114));
+    return mix(vec3(luma), c, 1.0 + boost);
+}`;
+const r = o, n = e, c = a;
 export {
-  o as COLOR_GRADE_OFF,
-  r as COLOR_GRADE_VIBRANT,
-  s as GeoVideoFrameSource,
-  h as GeoVideoScalarSource,
-  i as GeoVideoVectorSource,
-  d as TrailFade,
-  l as colorGradeVec4,
-  t as createColorRampTexture,
-  c as createProgram,
+  w as BACKDROP_OFF,
+  n as COLOR_GRADE_GLSL,
+  M as COLOR_GRADE_OFF,
+  N as COLOR_GRADE_VIBRANT,
+  d as GeoVideoArchiveSource,
+  i as GeoVideoFrameSource,
+  l as GeoVideoScalarSource,
+  m as GeoVideoVectorSource,
+  c as RANDOM_GLSL,
+  u as TrailFade,
+  r as VIBRANCE_GLSL,
+  v as assertGeoVideoIndexIdentity,
+  P as backdropVec4,
+  z as colorGradeToGrade,
+  H as colorGradeVec4,
+  x as createColorRampTexture,
+  g as createGeoVideoFrameSource,
+  p as createProgram,
+  f as createShader,
   G as fadeToFrames,
   V as fadeToOpacity,
-  m as geoVideoChunkSources,
-  n as geoVideoTimelineValues,
-  u as getPalettes,
-  C as isGeoVideoArchiveSource,
-  f as loadGeoVideoIndex,
-  p as loadGeoVideoManifest,
-  v as nextChunk,
-  x as pairChunk,
-  R as resolveColorGrade,
-  S as resolveColorRamp,
-  T as validateGeoVideoIndex,
-  O as validateGeoVideoManifest,
-  k as validateScalarColorDomain
+  C as geoVideoChunkSources,
+  b as geoVideoGrid,
+  S as geoVideoIndexChunks,
+  _ as geoVideoTimelineValues,
+  O as getPalettes,
+  K as gradeToColorGrade,
+  R as isGeoVideoArchiveSource,
+  q as isHexColor,
+  h as loadGeoVideoIndex,
+  A as loadGeoVideoManifest,
+  L as nextChunk,
+  F as nextChunkSpan,
+  T as pairChunk,
+  k as pairChunkSpan,
+  J as resolveBackdrop,
+  Q as resolveColorGrade,
+  y as resolveColorRamp,
+  I as validateGeoVideoIndex,
+  D as validateGeoVideoManifest,
+  B as validateScalarColorDomain
 };