@honua/app-platform 0.0.20-alpha.0

package/expr/expression.js

@@ -0,0 +1,663 @@
+/**
+ * Type-safe MapLibre expression builder for the Honua SDK.
+ *
+ * Builds MapLibre Style Spec v8 JSON expressions with TypeScript type checking.
+ * Call `.toJSON()` on any expression to get the serializable JSON array.
+ *
+ * @example
+ * ```ts
+ * import { expr } from "@honua/sdk";
+ *
+ * const fill = expr.step(
+ *   expr.get("population"),
+ *   "#f7fbff",
+ *   [10_000, "#6baed6"],
+ *   [100_000, "#08306b"],
+ * );
+ * ```
+ *
+ * @module
+ */
+// ── Core Expr class ──────────────────────────────────────────
+/**
+ * A type-safe wrapper around a MapLibre style expression.
+ *
+ * The type parameter `T` tracks the expression's return type at compile time.
+ * Call `.toJSON()` to serialize to the MapLibre JSON expression format.
+ */
+export class Expr {
+    #json;
+    constructor(json) {
+        this.#json = json;
+    }
+    /** Serialize to the MapLibre JSON expression format. */
+    toJSON() {
+        return this.#json;
+    }
+}
+// ── Internal helpers ─────────────────────────────────────────
+function r(input) {
+    return input instanceof Expr ? input.toJSON() : input;
+}
+// ── Lookup ───────────────────────────────────────────────────
+/** Get a feature property value, or a property from a specified object. */
+export function get(property, object) {
+    return object !== undefined
+        ? new Expr(["get", property, r(object)])
+        : new Expr(["get", property]);
+}
+/** Test whether a feature property exists. */
+export function has(property, object) {
+    return object !== undefined ? new Expr(["has", property, r(object)]) : new Expr(["has", property]);
+}
+/** Get an element from an array by index. */
+export function at(index, array) {
+    return new Expr(["at", r(index), r(array)]);
+}
+/** Test whether a value is in an array or a substring is in a string. */
+export function contains(needle, haystack) {
+    return new Expr(["in", r(needle), r(haystack)]);
+}
+/** Find the first index of a value in an array or substring in a string. Returns -1 if not found. */
+export function indexOf(needle, haystack, fromIndex) {
+    return fromIndex !== undefined
+        ? new Expr(["index-of", r(needle), r(haystack), r(fromIndex)])
+        : new Expr(["index-of", r(needle), r(haystack)]);
+}
+/** Extract a subarray or substring. Negative indices count from the end. */
+export function slice(input, start, end) {
+    return end !== undefined
+        ? new Expr(["slice", r(input), r(start), r(end)])
+        : new Expr(["slice", r(input), r(start)]);
+}
+/** Get the length of an array or string. */
+export function length(input) {
+    return new Expr(["length", r(input)]);
+}
+// ── Feature data ─────────────────────────────────────────────
+/** Get the feature's id. */
+export function id() {
+    return new Expr(["id"]);
+}
+/** Get the feature's geometry type ("Point", "LineString", or "Polygon"). */
+export function geometryType() {
+    return new Expr(["geometry-type"]);
+}
+/** Get the feature's properties object. */
+export function properties() {
+    return new Expr(["properties"]);
+}
+/** Read a property from the feature's programmatic state. Paint properties only. */
+export function featureState(property) {
+    return new Expr(["feature-state", property]);
+}
+/** Returns the progress along a gradient line. Used in line-gradient paint property. */
+export function lineProgress() {
+    return new Expr(["line-progress"]);
+}
+/** Returns the kernel density estimation of a heatmap layer. Used in heatmap-color paint. */
+export function heatmapDensity() {
+    return new Expr(["heatmap-density"]);
+}
+/** Returns the current map pitch in degrees. */
+export function pitch() {
+    return new Expr(["pitch"]);
+}
+/** Returns the accumulated value of a cluster property. */
+export function accumulated() {
+    return new Expr(["accumulated"]);
+}
+/** Returns the distance from the center of the viewport. Used in 3D camera-reactive styling. */
+export function distanceFromCenter() {
+    return new Expr(["distance-from-center"]);
+}
+// ── Type coercion ────────────────────────────────────────────
+/** Wrap a raw JSON array or object as a literal expression value. */
+export function literal(value) {
+    return new Expr(["literal", value]);
+}
+/** Coerce a value to boolean. */
+export function toBoolean(input) {
+    return new Expr(["to-boolean", r(input)]);
+}
+/** Coerce to number, trying each input in order until one succeeds. */
+export function toNumber(...inputs) {
+    return new Expr(["to-number", ...inputs.map(r)]);
+}
+/** Coerce a value to string. */
+export function exprToString(input) {
+    return new Expr(["to-string", r(input)]);
+}
+/** Coerce to color, trying each input in order until one succeeds. */
+export function toColor(...inputs) {
+    return new Expr(["to-color", ...inputs.map(r)]);
+}
+/** Get the type of a value as a string ("string", "number", "boolean", "object", "array", "null"). */
+export function typeOf(input) {
+    return new Expr(["typeof", r(input)]);
+}
+// ── Comparison ───────────────────────────────────────────────
+/** Strict equality. */
+export function eq(left, right) {
+    return new Expr(["==", r(left), r(right)]);
+}
+/** Strict inequality. */
+export function neq(left, right) {
+    return new Expr(["!=", r(left), r(right)]);
+}
+/** Less than. */
+export function lt(left, right) {
+    return new Expr(["<", r(left), r(right)]);
+}
+/** Less than or equal. */
+export function lte(left, right) {
+    return new Expr(["<=", r(left), r(right)]);
+}
+/** Greater than. */
+export function gt(left, right) {
+    return new Expr([">", r(left), r(right)]);
+}
+/** Greater than or equal. */
+export function gte(left, right) {
+    return new Expr([">=", r(left), r(right)]);
+}
+// ── Logic ────────────────────────────────────────────────────
+/** Logical negation. */
+export function not(input) {
+    return new Expr(["!", r(input)]);
+}
+/** True if all inputs are true. Short-circuits on first false. */
+export function all(...inputs) {
+    return new Expr(["all", ...inputs.map(r)]);
+}
+/** True if any input is true. Short-circuits on first true. */
+export function any(...inputs) {
+    return new Expr(["any", ...inputs.map(r)]);
+}
+// ── Decision ─────────────────────────────────────────────────
+/**
+ * First-match conditional (like if/else-if/else).
+ *
+ * Pass `[condition, output]` tuples followed by a fallback value:
+ * ```ts
+ * expr.case(
+ *   [expr.gt(expr.get("pop"), 1_000_000), "large"],
+ *   [expr.gt(expr.get("pop"), 100_000), "medium"],
+ *   "small",
+ * )
+ * ```
+ */
+export function switchCase(...args) {
+    const json = ["case"];
+    for (let i = 0; i < args.length - 1; i++) {
+        const branch = args[i];
+        json.push(r(branch[0]), r(branch[1]));
+    }
+    json.push(r(args[args.length - 1]));
+    return new Expr(json);
+}
+/**
+ * Switch-style matching on an input value.
+ *
+ * Pass `[label(s), output]` tuples followed by a fallback. Labels can be single
+ * values or arrays for multi-match:
+ * ```ts
+ * expr.match(
+ *   expr.get("type"),
+ *   ["residential", "#0f0"],
+ *   [["commercial", "retail"], "#00f"],
+ *   "#888",
+ * )
+ * ```
+ */
+export function matchExpr(input, ...casesAndFallback) {
+    const json = ["match", r(input)];
+    for (let i = 0; i < casesAndFallback.length - 1; i++) {
+        const branch = casesAndFallback[i];
+        const label = branch[0];
+        json.push(Array.isArray(label) ? label.map(r) : r(label));
+        json.push(r(branch[1]));
+    }
+    json.push(r(casesAndFallback[casesAndFallback.length - 1]));
+    return new Expr(json);
+}
+/** Return the first non-null value from the given expressions. */
+export function coalesce(...inputs) {
+    return new Expr(["coalesce", ...inputs.map(r)]);
+}
+// ── Math ─────────────────────────────────────────────────────
+/** Sum of numbers. */
+export function add(...inputs) {
+    return new Expr(["+", ...inputs.map(r)]);
+}
+/** Subtraction (two args) or negation (one arg). */
+export function subtract(a, b) {
+    return b !== undefined ? new Expr(["-", r(a), r(b)]) : new Expr(["-", r(a)]);
+}
+/** Product of numbers. */
+export function multiply(...inputs) {
+    return new Expr(["*", ...inputs.map(r)]);
+}
+/** Division. */
+export function divide(a, b) {
+    return new Expr(["/", r(a), r(b)]);
+}
+/** Modulo (remainder). */
+export function mod(a, b) {
+    return new Expr(["%", r(a), r(b)]);
+}
+/** Exponentiation: base^exponent. */
+export function pow(base, exponent) {
+    return new Expr(["^", r(base), r(exponent)]);
+}
+/** Absolute value. */
+export function abs(input) {
+    return new Expr(["abs", r(input)]);
+}
+/** Ceiling (round up). */
+export function ceil(input) {
+    return new Expr(["ceil", r(input)]);
+}
+/** Floor (round down). */
+export function floor(input) {
+    return new Expr(["floor", r(input)]);
+}
+/** Round to nearest integer. */
+export function round(input) {
+    return new Expr(["round", r(input)]);
+}
+/** Square root. */
+export function sqrt(input) {
+    return new Expr(["sqrt", r(input)]);
+}
+/** Natural logarithm. */
+export function ln(input) {
+    return new Expr(["ln", r(input)]);
+}
+/** Base-2 logarithm. */
+export function log2(input) {
+    return new Expr(["log2", r(input)]);
+}
+/** Base-10 logarithm. */
+export function log10(input) {
+    return new Expr(["log10", r(input)]);
+}
+/** Sine (input in radians). */
+export function sin(input) {
+    return new Expr(["sin", r(input)]);
+}
+/** Cosine (input in radians). */
+export function cos(input) {
+    return new Expr(["cos", r(input)]);
+}
+/** Tangent (input in radians). */
+export function tan(input) {
+    return new Expr(["tan", r(input)]);
+}
+/** Arcsine (result in radians). */
+export function asin(input) {
+    return new Expr(["asin", r(input)]);
+}
+/** Arccosine (result in radians). */
+export function acos(input) {
+    return new Expr(["acos", r(input)]);
+}
+/** Arctangent (result in radians). */
+export function atan(input) {
+    return new Expr(["atan", r(input)]);
+}
+/** Minimum of the given numbers. */
+export function min(...inputs) {
+    return new Expr(["min", ...inputs.map(r)]);
+}
+/** Maximum of the given numbers. */
+export function max(...inputs) {
+    return new Expr(["max", ...inputs.map(r)]);
+}
+/** Euler's number (e ≈ 2.718). */
+export function e() {
+    return new Expr(["e"]);
+}
+/** Pi (π ≈ 3.14159). */
+export function pi() {
+    return new Expr(["pi"]);
+}
+/** Natural logarithm of 2 (ln(2) ≈ 0.693). */
+export function ln2Const() {
+    return new Expr(["ln2"]);
+}
+// ── String ───────────────────────────────────────────────────
+/** Concatenate values into a string. Non-string values are coerced. */
+export function concat(...inputs) {
+    return new Expr(["concat", ...inputs.map(r)]);
+}
+/** Convert a string to uppercase. */
+export function upcase(input) {
+    return new Expr(["upcase", r(input)]);
+}
+/** Convert a string to lowercase. */
+export function downcase(input) {
+    return new Expr(["downcase", r(input)]);
+}
+// ── Color ────────────────────────────────────────────────────
+/** Create a color from RGB components (0-255). */
+export function rgb(red, green, blue) {
+    return new Expr(["rgb", r(red), r(green), r(blue)]);
+}
+/** Create a color from RGBA components (RGB 0-255, alpha 0-1). */
+export function rgba(red, green, blue, alpha) {
+    return new Expr(["rgba", r(red), r(green), r(blue), r(alpha)]);
+}
+/** Create a color from HSL components (hue 0-360, saturation/lightness 0-100%). */
+export function hsl(hue, saturation, lightness) {
+    return new Expr(["hsl", r(hue), r(saturation), r(lightness)]);
+}
+/** Create a color from HSLA components (hue 0-360, saturation/lightness 0-100%, alpha 0-1). */
+export function hsla(hue, saturation, lightness, alpha) {
+    return new Expr(["hsla", r(hue), r(saturation), r(lightness), r(alpha)]);
+}
+/** Decompose a color into its RGBA components as `[r, g, b, a]`. */
+export function toRgba(color) {
+    return new Expr(["to-rgba", r(color)]);
+}
+/** Linear interpolation method. */
+export function linear() {
+    return ["linear"];
+}
+/** Exponential interpolation method with the given base. */
+export function exponential(base) {
+    return ["exponential", base];
+}
+/** Cubic bezier interpolation method. */
+export function cubicBezier(x1, y1, x2, y2) {
+    return ["cubic-bezier", x1, y1, x2, y2];
+}
+// ── Ramps and scales ─────────────────────────────────────────
+/**
+ * Piecewise-constant function (staircase). Returns the output value of the stop
+ * whose input value is just less than `input`.
+ *
+ * ```ts
+ * expr.step(
+ *   expr.get("population"),
+ *   "#f7fbff",          // default (input < first stop)
+ *   [10_000, "#6baed6"],
+ *   [100_000, "#08306b"],
+ * )
+ * ```
+ */
+export function step(input, defaultOutput, ...stops) {
+    const json = ["step", r(input), r(defaultOutput)];
+    for (const [threshold, output] of stops) {
+        json.push(threshold, r(output));
+    }
+    return new Expr(json);
+}
+/**
+ * Continuous interpolation between stops.
+ *
+ * ```ts
+ * expr.interpolate(
+ *   expr.linear(),
+ *   expr.zoom(),
+ *   [0, 0],
+ *   [10, 1],
+ *   [20, 5],
+ * )
+ * ```
+ */
+export function interpolate(method, input, ...stops) {
+    const json = ["interpolate", method, r(input)];
+    for (const [stopInput, stopOutput] of stops) {
+        json.push(stopInput, r(stopOutput));
+    }
+    return new Expr(json);
+}
+/** Interpolate in the HCL color space. Produces smoother color gradients. */
+export function interpolateHcl(method, input, ...stops) {
+    const json = ["interpolate-hcl", method, r(input)];
+    for (const [stopInput, stopOutput] of stops) {
+        json.push(stopInput, r(stopOutput));
+    }
+    return new Expr(json);
+}
+/** Interpolate in the CIELAB color space. */
+export function interpolateLab(method, input, ...stops) {
+    const json = ["interpolate-lab", method, r(input)];
+    for (const [stopInput, stopOutput] of stops) {
+        json.push(stopInput, r(stopOutput));
+    }
+    return new Expr(json);
+}
+// ── Zoom ─────────────────────────────────────────────────────
+/** The current map zoom level. In paint/layout, may only be the direct input to a top-level `step` or `interpolate`. */
+export function zoom() {
+    return new Expr(["zoom"]);
+}
+// ── Variable binding ─────────────────────────────────────────
+/**
+ * Bind variables for use in a result expression.
+ *
+ * ```ts
+ * expr.let({ x: expr.get("population") },
+ *   expr.multiply(expr.var("x"), 2),
+ * )
+ * ```
+ */
+export function letExpr(bindings, result) {
+    const json = ["let"];
+    for (const [name, value] of Object.entries(bindings)) {
+        json.push(name, r(value));
+    }
+    json.push(r(result));
+    return new Expr(json);
+}
+/** Reference a variable bound by `let`. */
+export function varExpr(name) {
+    return new Expr(["var", name]);
+}
+/**
+ * Create a formatted text value from one or more text segments with per-segment styling.
+ *
+ * Each segment is `[text, options?]`:
+ * ```ts
+ * expr.format(
+ *   [expr.get("name"), { "font-scale": 1.2, "text-color": "#000" }],
+ *   ["\n"],
+ *   [expr.get("description")],
+ * )
+ * ```
+ */
+export function format(...segments) {
+    const json = ["format"];
+    for (const [text, opts] of segments) {
+        json.push(r(text));
+        const resolvedOpts = {};
+        if (opts) {
+            if (opts["font-scale"] !== undefined)
+                resolvedOpts["font-scale"] = r(opts["font-scale"]);
+            if (opts["text-font"] !== undefined)
+                resolvedOpts["text-font"] = opts["text-font"] instanceof Expr ? opts["text-font"].toJSON() : opts["text-font"];
+            if (opts["text-color"] !== undefined)
+                resolvedOpts["text-color"] = r(opts["text-color"]);
+        }
+        json.push(resolvedOpts);
+    }
+    return new Expr(json);
+}
+/** Format a number using locale-sensitive formatting. */
+export function numberFormat(input, options) {
+    const opts = {};
+    if (options) {
+        if (options.locale !== undefined)
+            opts.locale = r(options.locale);
+        if (options.currency !== undefined)
+            opts.currency = r(options.currency);
+        if (options["min-fraction-digits"] !== undefined)
+            opts["min-fraction-digits"] = r(options["min-fraction-digits"]);
+        if (options["max-fraction-digits"] !== undefined)
+            opts["max-fraction-digits"] = r(options["max-fraction-digits"]);
+    }
+    return new Expr(["number-format", r(input), opts]);
+}
+/** Create a collator for locale-aware string comparisons. */
+export function collator(options) {
+    const opts = {};
+    if (options) {
+        if (options["case-sensitive"] !== undefined)
+            opts["case-sensitive"] = r(options["case-sensitive"]);
+        if (options["diacritic-sensitive"] !== undefined)
+            opts["diacritic-sensitive"] = r(options["diacritic-sensitive"]);
+        if (options.locale !== undefined)
+            opts.locale = r(options.locale);
+    }
+    return new Expr(["collator", opts]);
+}
+/** Get the resolved locale string from a collator. */
+export function resolvedLocale(input) {
+    return new Expr(["resolved-locale", input.toJSON()]);
+}
+/** Resolve an image name from the style's sprite. Usable in `icon-image` and pattern properties. */
+export function image(name) {
+    return new Expr(["image", r(name)]);
+}
+// ── Spatial ──────────────────────────────────────────────────
+function resolveGeometry(input) {
+    return input instanceof Expr ? input.toJSON() : input;
+}
+/** Shortest distance in meters from the evaluated feature to the input geometry. */
+export function distance(geometry) {
+    return new Expr(["distance", resolveGeometry(geometry)]);
+}
+/** True if the evaluated feature is entirely within the input geometry. */
+export function within(geometry) {
+    return new Expr(["within", resolveGeometry(geometry)]);
+}
+/** True if the evaluated feature intersects the input geometry. */
+export function intersects(geometry) {
+    return new Expr(["intersects", resolveGeometry(geometry)]);
+}
+// ── Namespace export ─────────────────────────────────────────
+/**
+ * Namespace object that groups all expression builder functions.
+ *
+ * @example
+ * ```ts
+ * import { expr } from "@honua/sdk";
+ *
+ * const fillColor = expr.step(
+ *   expr.get("assessed_value"),
+ *   "#f7fbff",
+ *   [100_000, "#6baed6"],
+ *   [500_000, "#08306b"],
+ * );
+ *
+ * map.addLayer({
+ *   id: "parcel-fill",
+ *   source: "parcels",
+ *   type: "fill",
+ *   paint: { "fill-color": fillColor.toJSON() },
+ * });
+ * ```
+ */
+export const expr = {
+    // Lookup
+    get,
+    has,
+    at,
+    contains,
+    indexOf,
+    slice,
+    length,
+    // Feature data
+    id,
+    geometryType,
+    properties,
+    featureState,
+    lineProgress,
+    heatmapDensity,
+    pitch,
+    accumulated,
+    distanceFromCenter,
+    // Type coercion
+    literal,
+    toBoolean,
+    toNumber,
+    toString: exprToString,
+    toColor,
+    typeOf,
+    // Comparison
+    eq,
+    neq,
+    lt,
+    lte,
+    gt,
+    gte,
+    // Logic
+    not,
+    all,
+    any,
+    // Decision
+    case: switchCase,
+    match: matchExpr,
+    coalesce,
+    // Math
+    add,
+    subtract,
+    multiply,
+    divide,
+    mod,
+    pow,
+    abs,
+    ceil,
+    floor,
+    round,
+    sqrt,
+    ln,
+    log2,
+    log10,
+    sin,
+    cos,
+    tan,
+    asin,
+    acos,
+    atan,
+    min,
+    max,
+    e,
+    pi,
+    ln2: ln2Const,
+    // String
+    concat,
+    upcase,
+    downcase,
+    // Color
+    rgb,
+    rgba,
+    hsl,
+    hsla,
+    toRgba,
+    // Interpolation
+    step,
+    interpolate,
+    interpolateHcl,
+    interpolateLab,
+    linear,
+    exponential,
+    cubicBezier,
+    // Zoom
+    zoom,
+    // Variable binding
+    let: letExpr,
+    var: varExpr,
+    // Format/image
+    format,
+    numberFormat,
+    collator,
+    resolvedLocale,
+    image,
+    // Spatial
+    distance,
+    within,
+    intersects,
+};

package/expr/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `@honua/sdk-js/expr` — Honua expression builder.
+ *
+ * A small, typed DSL that compiles to the MapLibre-style style/filter
+ * expression shape. Use it to build runtime style expressions, layer
+ * filters, and Honua-side projections without hand-rolling JSON arrays.
+ *
+ * @example
+ * ```ts
+ * import { get, eq, all, gt, interpolate, linear, zoom, rgb } from "@honua/sdk-js/expr";
+ *
+ * // Filter: STATUS = 'ACTIVE' AND POPULATION > 10000
+ * const filter = all(eq(get("STATUS"), "ACTIVE"), gt(get("POPULATION"), 10000));
+ *
+ * // Paint expression: interpolate point color by zoom
+ * const color = interpolate(linear(), zoom(), 8, rgb(70, 130, 180), 14, rgb(220, 20, 60));
+ * ```
+ *
+ * @example Render to a JSON expression
+ * ```ts
+ * import { expr, eq, get } from "@honua/sdk-js/expr";
+ *
+ * const isActive = eq(get("STATUS"), "ACTIVE");
+ * const json = expr(isActive); // ["==", ["get", "STATUS"], "ACTIVE"]
+ * map.setFilter("parcels", json);
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { expr, Expr, get, has, at, contains, indexOf, slice, length, id, geometryType, properties, featureState, lineProgress, heatmapDensity, pitch, accumulated, distanceFromCenter, literal, toBoolean, toNumber, exprToString, toColor, typeOf, eq, neq, lt, lte, gt, gte, not, all, any, switchCase, matchExpr, coalesce, add, subtract, multiply, divide, mod, pow, abs, ceil, floor, round, sqrt, ln, log2, log10, sin, cos, tan, asin, acos, atan, min, max, e, pi, ln2Const, concat, upcase, downcase, rgb, rgba, step, interpolate, interpolateHcl, interpolateLab, linear, exponential, cubicBezier, zoom, letExpr, varExpr, format, numberFormat, collator, resolvedLocale, hsl, hsla, toRgba, image, distance, within, intersects, } from "./expression.js";
+export type { ExprColor, ExprFormatted, ExprImage, ExprValue, NumberInput, StringInput, BooleanInput, ColorInput, Resolvable, InterpolationMethod, GeoJsonPoint, GeoJsonMultiPoint, GeoJsonLineString, GeoJsonMultiLineString, GeoJsonPolygon, GeoJsonMultiPolygon, GeoJsonGeometry, FormatSegmentOptions, NumberFormatOptions, CollatorOptions, ExprCollator, } from "./expression.js";
+//# sourceMappingURL=index.d.ts.map

package/expr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/expr/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,EACL,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,GAAG,EACH,EAAE,EACF,QAAQ,EACR,OAAO,EACP,KAAK,EACL,MAAM,EACN,EAAE,EACF,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,KAAK,EACL,WAAW,EACX,kBAAkB,EAClB,OAAO,EACP,SAAS,EACT,QAAQ,EACR,YAAY,EACZ,OAAO,EACP,MAAM,EACN,EAAE,EACF,GAAG,EACH,EAAE,EACF,GAAG,EACH,EAAE,EACF,GAAG,EACH,GAAG,EACH,GAAG,EACH,GAAG,EACH,UAAU,EACV,SAAS,EACT,QAAQ,EACR,GAAG,EACH,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,GAAG,EACH,GAAG,EACH,GAAG,EACH,IAAI,EACJ,KAAK,EACL,KAAK,EACL,IAAI,EACJ,EAAE,EACF,IAAI,EACJ,KAAK,EACL,GAAG,EACH,GAAG,EACH,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,GAAG,EACH,GAAG,EACH,CAAC,EACD,EAAE,EACF,QAAQ,EACR,MAAM,EACN,MAAM,EACN,QAAQ,EACR,GAAG,EACH,IAAI,EACJ,IAAI,EACJ,WAAW,EACX,cAAc,EACd,cAAc,EACd,MAAM,EACN,WAAW,EACX,WAAW,EACX,IAAI,EACJ,OAAO,EACP,OAAO,EACP,MAAM,EACN,YAAY,EACZ,QAAQ,EACR,cAAc,EACd,GAAG,EACH,IAAI,EACJ,MAAM,EACN,KAAK,EACL,QAAQ,EACR,MAAM,EACN,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,SAAS,EACT,aAAa,EACb,SAAS,EACT,SAAS,EACT,WAAW,EACX,WAAW,EACX,YAAY,EACZ,UAAU,EACV,UAAU,EACV,mBAAmB,EACnB,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EACjB,sBAAsB,EACtB,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,YAAY,GACb,MAAM,iBAAiB,CAAC"}