@multiplatform.one/node-graph 7.7.2

package/types/theme/GraphVarsStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GraphVarsStyle.d.ts","sourceRoot":"","sources":["../../src/theme/GraphVarsStyle.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,KAAK,SAAS,EAAW,MAAM,OAAO,CAAC;AAEhD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,gBAAgB,EAAgB,MAAM,aAAa,CAAC;AAE5F;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAE7C,MAAM,WAAW,cAAc;IAC7B,8FAA8F;IAC9F,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChD,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;IAClC;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,qFAAqF;AACrF,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACtC,MAAM,EAAE,OAAO,GAAG,MAAM,EACxB,QAAQ,EAAE,MAAM,GACf,MAAM,CAMR;AAED,wBAAgB,SAAS,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,cAAc,GAAG,SAAS,CAWzF;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,IAAI,gBAAgB,CAsBtD;AAED,6CAA6C;AAC7C,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAIxB"}

package/types/theme/faces.d.ts

@@ -0,0 +1,152 @@
+/**
+ * The `$body` face inside the WebView, and the control that proves it painted.
+ *
+ * WKWebView cannot see an `expo-font` registration, so the face has to arrive
+ * as bytes. Design §6.3 names two mechanisms, and this module owns both ends:
+ * the `@font-face` CSS (asset URL first, base64 second) and
+ * `probeRenderedFamily`, which answers the question MPO-191 actually asked —
+ * did the first family in the cascade render, or did we quietly get
+ * `-apple-system` and call it a pass?
+ *
+ * WHY THE FIRST NAME IS CORRUPTED RATHER THAN THE WHOLE STACK REPLACED. The
+ * gate measured the real stack against a wholly bogus family
+ * (`NoSuchFont, monospace`). Two different widths came back and it read as a
+ * pass — but a stack that fell through to `-apple-system` ALSO measures
+ * differently from monospace, so the gate could not tell "Inter rendered" from
+ * "the second family rendered". Corrupting only the first name leaves the rest
+ * of the cascade byte-identical, so the widths differ if and only if the first
+ * family is the one that painted.
+ *
+ * Design: docs/design/node-graph-editor.md §6.3.
+ */
+/** A knob font category, narrowed to what this package can ship bytes for. */
+export type GraphFaceCategory = "sans-serif";
+/** One declared face: what it is, and where its bytes come from. */
+export interface GraphFaceDeclaration {
+    /** Stable id — the generator's key and the `assetUris` key a consumer passes. */
+    readonly id: string;
+    /** The CSS family name. Must be the FIRST name in the category's stack. */
+    readonly family: string;
+    readonly weight: number;
+    readonly style: "normal" | "italic";
+    readonly category: GraphFaceCategory;
+    /** Repo-relative source, so the generated payload is traceable to a file. */
+    readonly source: string;
+}
+/** A declared face with its bytes, as `faces.generated.ts` emits it. */
+export interface GraphFaceAsset extends GraphFaceDeclaration {
+    /** WOFF2, base64. */
+    readonly base64: string;
+    /** Decoded length, so the ceiling is measured against real bytes. */
+    readonly byteLength: number;
+    /** sha256 of the source file, so a silent source swap fails `--check`. */
+    readonly sha256: string;
+}
+/**
+ * The faces this package ships bytes for.
+ *
+ * TWO DEPARTURES FROM DESIGN §6.3, both forced by what is actually in the repo
+ * and both measured rather than assumed.
+ *
+ * 1. **700, not 600.** The design asked for Inter 400 and 600. The repo ships
+ *    `inter-400.woff2` and `inter-700.woff2` and nothing between them
+ *    (`git ls-files '*.woff2'` — 20 files, all 400 or 700, ten copies of the
+ *    same pair). `@tamagui/font-inter` does ship an `Inter-SemiBold.woff2` at
+ *    `usWeightClass` 600, but its cmap carries 92 codepoints — bare ASCII,
+ *    missing even `?` and `~` — so a node label with a question mark in it
+ *    would fall out of the face. Declaring the 700 file at `font-weight: 700`
+ *    is not a loss: the CSS font matching algorithm resolves a request for 600
+ *    to the nearest heavier declared face, which is this one.
+ *
+ * 2. **No mono face.** `fontCategoryStacks.mono` is
+ *    `ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace` —
+ *    every name a system face WKWebView resolves on its own. There is no mono
+ *    webfont anywhere in the repo to build a payload from, and declaring one
+ *    under a family the stack never names would render nothing at all. The
+ *    category falls through to the WebView's own faces, which is what the rest
+ *    of §6.3 already says happens to every category but these.
+ */
+export declare const graphFaces: readonly GraphFaceDeclaration[];
+/**
+ * The declared payload ceiling, in decoded WOFF2 bytes.
+ *
+ * 96 KB against a measured 69.5 KB (34,500 + 36,636), which is ~38% headroom:
+ * enough that a face rebuilt from a newer Inter, or one more punctuation block
+ * added to the subset ranges, does not trip it — and tight enough that a THIRD
+ * face cannot slip in unnoticed, because a third would land around 106 KB.
+ *
+ * IT WAS 220 KB, AND THE DIFFERENCE IS THE SUBSET (MPO-211). Design §6.3 asked
+ * for latin-subset faces and milestone 2 shipped the repo's whole Inter files:
+ * 2,505 codepoints each, 1,980 of them outside Latin (254 Cyrillic, 121 Greek,
+ * 256 Vietnamese), 200.2 KB decoded — twice §6.3's own "roughly 100 KB
+ * inflated" estimate. Base64 does not compress, so every one of those glyphs
+ * cost its full weight in the DOM bundle's gzip. `scripts/build-graph-faces.mjs`
+ * now cuts the subset with `subset-font` (harfbuzz) at generate time, 205,008
+ * bytes down to 71,136, and the toolchain gap that blocked it is closed by one
+ * devDependency of THIS package — nothing reaches a consumer's install.
+ */
+export declare const graphFaceCeilingBytes: number;
+/** Decoded bytes across every generated face. */
+export declare function faceBytes(faces: readonly GraphFaceAsset[]): number;
+/**
+ * Splits a CSS font stack into the family names a browser would try, in order.
+ *
+ * Quotes are stripped because a family is the same family quoted or not, and
+ * the probe compares names rather than re-serializing them.
+ */
+export declare function splitFontStack(stack: string): string[];
+/**
+ * Breaks the first family in a stack and leaves every later one byte-identical.
+ *
+ * The result is quoted, because the suffix contains a space.
+ */
+export declare function corruptFirstFamily(stack: string): string;
+/** Design §6.3's probe result, plus the honesty bit the design's shape lacked. */
+export interface FaceProbe {
+    readonly stack: string;
+    readonly widthStack: number;
+    /** The same cascade, first family name broken. */
+    readonly widthFirstCorrupted: number;
+    /** `widthStack !== widthFirstCorrupted`, and only meaningful when conclusive. */
+    readonly matched: boolean;
+    /**
+     * Whether the two measurements could tell us anything at all.
+     *
+     * False in the two cases where equal widths are not evidence of a miss:
+     * nothing measured (a hidden or empty element reads 0), and a stack with no
+     * fallback behind the first name, where corrupting it leaves the UA default
+     * and the widths may coincide by luck. Design §6.3's interface had no such
+     * field, so both cases would have reported a confident `matched: false`.
+     */
+    readonly conclusive: boolean;
+}
+export interface ProbeFamilyOptions {
+    readonly stack: string;
+    /** Width of one line of text rendered in `stack`. */
+    readonly measure: (stack: string) => number;
+}
+/** The control, with measurement injected so it is testable off a browser. */
+export declare function probeFamily({ stack, measure }: ProbeFamilyOptions): FaceProbe;
+/**
+ * Design §6.3's entry point: probe the family an element actually rendered in.
+ *
+ * Reads the element's own computed `font-family`, so it reports on the real
+ * cascade the knob stack produced rather than on one this module guessed.
+ */
+export declare function probeRenderedFamily(el: Element): FaceProbe;
+/**
+ * The `@font-face` block for a set of faces.
+ *
+ * `assetUris` is the PRIMARY path of design §6.3: a consumer hands in the URL
+ * Expo produced from a `require()` of the face, and no bytes ride in the
+ * bundle for it. A face with no URI falls back to its inline base64. The
+ * `require()` lives in the consumer because that is where the asset lives —
+ * this package vendors no font binary of its own, per §6.3's note that no new
+ * vendored asset is needed.
+ *
+ * `font-display: block` rather than `swap`: the probe measures a rendered
+ * width, and a swap would let it measure the fallback face during the swap
+ * period and report a miss that is really a race.
+ */
+export declare function graphFaceCss(faces: readonly GraphFaceAsset[], assetUris?: Readonly<Record<string, string>>): string;
+//# sourceMappingURL=faces.d.ts.map

package/types/theme/faces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faces.d.ts","sourceRoot":"","sources":["../../src/theme/faces.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,8EAA8E;AAC9E,MAAM,MAAM,iBAAiB,GAAG,YAAY,CAAC;AAE7C,oEAAoE;AACpE,MAAM,WAAW,oBAAoB;IACnC,iFAAiF;IACjF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACpC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wEAAwE;AACxE,MAAM,WAAW,cAAe,SAAQ,oBAAoB;IAC1D,qBAAqB;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,EAAE,SAAS,oBAAoB,EAiBrD,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,QAAY,CAAC;AAE/C,iDAAiD;AACjD,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,CAElE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAUtD;AAUD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAMxD;AAED,kFAAkF;AAClF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,iFAAiF;IACjF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7C;AAED,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,kBAAkB,GAAG,SAAS,CAc7E;AAsBD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,OAAO,GAAG,SAAS,CAe1D;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,cAAc,EAAE,EAChC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC3C,MAAM,CAgBR"}

package/types/theme/faces.generated.d.ts

@@ -0,0 +1,27 @@
+/**
+ * GENERATED by scripts/build-graph-faces.mjs. Do not edit.
+ *
+ * Run `node scripts/build-graph-faces.mjs` to rebuild, and
+ * `node scripts/build-graph-faces.mjs --check` to prove it is current — the
+ * spec runs that check, so a font swap without a regeneration fails the suite.
+ *
+ * What is embedded, measured from the files themselves:
+ *
+ *   apps/storybook/public/fonts/inter-400.woff2
+ *     subset  34,500 bytes, 619 codepoints, 525 of them Latin (<= U+024F)
+ *     source  98,868 bytes, 2505 codepoints
+ *   apps/storybook/public/fonts/inter-700.woff2
+ *     subset  36,636 bytes, 619 codepoints, 525 of them Latin (<= U+024F)
+ *     source  106,140 bytes, 2505 codepoints
+ *
+ * Total 71,136 decoded bytes, subset from 205,008.
+ *
+ * These ARE latin subsets, cut by `subset-font` (harfbuzz) at generate time:
+ * design §6.3's requirement, which milestone 2 shipped without and MPO-211
+ * closed. The ceiling they are measured against is `graphFaceCeilingBytes` in
+ * `faces.ts`, and `faces.spec.ts` refuses a ceiling more than twice the
+ * payload, so the budget cannot quietly become a rubber stamp.
+ */
+import type { GraphFaceAsset } from "./faces";
+export declare const generatedGraphFaces: readonly GraphFaceAsset[];
+//# sourceMappingURL=faces.generated.d.ts.map

package/types/theme/faces.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"faces.generated.d.ts","sourceRoot":"","sources":["../../src/theme/faces.generated.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,eAAO,MAAM,mBAAmB,EAAE,SAAS,cAAc,EAyBxD,CAAC"}

package/types/theme/graphVars.d.ts

@@ -0,0 +1,155 @@
+/**
+ * The `--xy-*` token bridge.
+ *
+ * Every paint in React Flow reads through `var(--xy-thing,
+ * var(--xy-thing-default))`. We set the non-default layer from `ResolvedKnobs`
+ * plus the Tamagui theme, so the library stylesheet is never edited, never
+ * forked, and no specificity war is possible. A designer never touches React
+ * Flow CSS — `checkGraphVarsCoverage()` in `public/config/lint.mjs` makes that
+ * mechanical rather than aspirational.
+ *
+ * Scope, honestly: the installed sheet exposes 35 settable names and 7 of them
+ * are dead for us. The `--xy-node-*` family binds ONLY to React Flow's built-in
+ * node classes (style.css:454-486) and a Tamagui node never carries them; its
+ * paint comes from the `knobProps` spread in `GraphNode.tsx`. So this layer
+ * paints CHROME: edges, edge labels, handles, minimap, controls, background
+ * pattern, selection rect, connection line, resize control.
+ *
+ * Design: docs/design/node-graph-editor.md section 6.2.
+ */
+import { type ResolvedKnobs } from "@multiplatform.one/theme";
+/**
+ * How a colour is reached, in the two forms this module needs.
+ *
+ * `css` is what gets emitted for a plain reference. On web it is the Tamagui
+ * Variable's own `var(--…)` string, read off the live theme rather than
+ * reconstructed from a guessed prefix, so a theme flip repaints without a
+ * revision bump. `raw` is the literal value, and exists only because the two
+ * BLENDED entries have to be computed in JS: `color-mix()` support in the
+ * Android WebView images in play is unchecked, and four values would silently
+ * vanish if we leaned on it (design 6.2).
+ */
+export interface GraphThemeAccess {
+    /** CSS-ready reference for a theme key, with or without the `$`. */
+    readonly css: (key: string) => string | undefined;
+    /** Literal value for the same key — `#fff`, `hsl(…)`, `rgb(…)`. */
+    readonly raw: (key: string) => string | undefined;
+}
+/**
+ * Names React Flow exposes that this package deliberately does not set, each
+ * with the reason a reader can check against the installed sheet. The spec
+ * re-derives the binding from `@xyflow/react/dist/style.css` rather than
+ * trusting these strings, so a version that starts binding one of them to a
+ * class we DO render fails the build.
+ */
+export declare const xyVarAllowlist: Readonly<Record<string, string>>;
+/**
+ * A var's value, kept structured rather than pre-stringified.
+ *
+ * Design 6.2 asks the spec to run `isResolvableThemeValue` over "every mapped
+ * value", and taken literally that is not satisfiable: two of the 28 are CSS
+ * SHORTHANDS (`1px dashed <colour>`, a box-shadow), and the predicate answers
+ * "is this a colour a renderer can resolve" — it says no to any shorthand, and
+ * to `2px`. So the map carries the ATOMS: every `color`, and every colour
+ * inside a `composite`, is put through the predicate; a `length` is a finite
+ * number, which the predicate also accepts. Nothing is exempted by hand.
+ */
+export type GraphVarValue = {
+    readonly kind: "color";
+    readonly color: string;
+} | {
+    readonly kind: "length";
+    readonly px: number;
+} | {
+    readonly kind: "composite";
+    readonly css: string;
+    readonly colors: readonly string[];
+};
+export interface GraphCssVarsOptions {
+    /**
+     * Pointer class the graph is being painted for. Coarse pointers get the
+     * 44 px HIG/M3 press floor on the handle HIT region; the painted disc never
+     * moves (design 7.1 H1/H3).
+     */
+    readonly pointer?: "coarse" | "fine";
+}
+/**
+ * Tamagui space tokens as px.
+ *
+ * `knobProps.gap.gap` and `knobProps.panelPadding.padding` are TOKEN strings
+ * (`"$4"`), and a CSS custom property whose value is `$4` is dead — it is
+ * exactly the silent no-op the repo's own token lints exist to catch. The
+ * numbers are mirrored here the way `resolveKnobs.ts:148-162` mirrors them, and
+ * `graphVars.spec.ts` asserts the mirror against the INSTALLED
+ * `@tamagui/themes` table, which is the drift check resolveKnobs' own mirror
+ * does not have.
+ */
+export declare const spaceTokenPx: Readonly<Record<string, number>>;
+/**
+ * `animation` token to a complete CSS `transition` shorthand.
+ *
+ * Mirrored, not imported: `animationConfig` is a platform twin
+ * (`animations/index.web.ts` -> `./css` gives these strings, `./reactNative`
+ * gives spring objects), and this function runs on the NATIVE host too — it
+ * builds the vars that cross into the WebView. `graphVars.spec.ts` asserts the
+ * mirror against the web twin.
+ */
+export declare const graphTransitionCss: Readonly<Record<string, string>>;
+/** GraphPort painted disc, by the `size` knob (design 11, Size). Never 44 — that is the HIT value. */
+export declare const handlePaintedPx: Readonly<Record<string, number>>;
+/**
+ * Edge ink by the `borderWidth` knob (design 11, Border width): none 1, small
+ * 1.5, medium 2, large 3.
+ *
+ * A remap, not a floor to `hairlineWidth`: an edge is a stroke, not a divider,
+ * and `hairline.ts:16-21` scopes that token to dividers only. `none` still
+ * paints, because a 0-width edge erases the graph's primary information.
+ *
+ * Keyed by `knobProps.controlBorderFilled.borderWidth`, NOT by the design's
+ * `controlBorderOutlined.borderWidth`. That fragment is
+ * `Math.max(borderWidthValue, 1)` (resolveKnobs.ts:599-602), which collapses
+ * none / small / medium onto the single value 1 — three of the four stops are
+ * not recoverable from it, so a remap off it cannot produce four widths.
+ * `controlBorderFilled` carries the unclamped number (0 / 0.5 / 1 / 2) and is
+ * the only post-resolution place the stop survives; `ResolvedKnobs` exposes no
+ * `borderWidth` string at all.
+ *
+ * One measured consequence: under `fillStyle: "outlined"` the resolver already
+ * promotes `borderWidth: "none"` to `small` (resolveKnobs.ts:530-533), so an
+ * outlined graph paints the 1.5 px edge at BOTH stops. That is the resolver's
+ * own clamp showing through, not a choice made here.
+ */
+export declare const edgeStrokeWidthPx: Readonly<Record<string, number>>;
+/**
+ * The same colour at a different alpha, as `rgba()` / `hsla()`.
+ *
+ * No `color-mix()` and no hex out: the blends are computed here so the emitted
+ * value is one every engine in play already paints. Returns `undefined` when
+ * the input is not a literal colour this can read (a `var()` reference, an
+ * `oklch()`), so the caller degrades visibly rather than emitting nonsense.
+ */
+export declare function withAlpha(color: string | undefined, alpha: number): string | undefined;
+/**
+ * `knobProps.elevationChrome` as a CSS box-shadow.
+ *
+ * On web `elevationChrome.style.boxShadow` is already the house shadow string
+ * (`resolveKnobs.ts:312-322`, pure `rgba()`), so it is used verbatim. On the
+ * NATIVE host that key is absent — `elevationPaint` only sets it under `isWeb`
+ * — and the shadow is rebuilt from the paint props, resolving a `$token`
+ * shadow colour through the theme. `elevation: "none"` resolves to an empty
+ * chrome and emits `none`, which is the right answer rather than a missing one.
+ */
+export declare function elevationBoxShadow(resolved: ResolvedKnobs, theme: GraphThemeAccess): {
+    css: string;
+    colors: readonly string[];
+};
+/**
+ * Every var this package sets, structured. `graphCssVars` is the string form
+ * that goes into the sheet; this is the form the spec can reason about.
+ */
+export declare function graphVarValues(resolved: ResolvedKnobs, theme: GraphThemeAccess, options?: GraphCssVarsOptions): Record<string, GraphVarValue>;
+/** One var value as it appears in the sheet. */
+export declare function graphVarCss(value: GraphVarValue): string;
+/** The layer that goes into the envelope and into `<GraphVars>`. */
+export declare function graphCssVars(resolved: ResolvedKnobs, theme: GraphThemeAccess, options?: GraphCssVarsOptions): Record<string, string>;
+//# sourceMappingURL=graphVars.d.ts.map

package/types/theme/graphVars.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphVars.d.ts","sourceRoot":"","sources":["../../src/theme/graphVars.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAoB,KAAK,aAAa,EAAiB,MAAM,0BAA0B,CAAC;AAI/F;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oEAAoE;IACpE,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IAClD,mEAAmE;IACnE,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACnD;AAID;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAe3D,CAAC;AAIF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAClD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAAC;AAE7F,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC;CACtC;AAID;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAQzD,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAS/D,CAAC;AAEF,sGAAsG;AACtG,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAI5D,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAK9D,CAAC;AAYF;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CA2CtF;AAuBD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,gBAAgB,GACtB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,CAuB5C;AAQD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,gBAAgB,EACvB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAyG/B;AAED,gDAAgD;AAChD,wBAAgB,WAAW,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CASxD;AAED,oEAAoE;AACpE,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,gBAAgB,EACvB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMxB"}