@radialapps/memories-vips-editor 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,102 @@
-# Temporary Holding Version
+# @radialapps/memories-vips-editor — headless WebGL preview + VIPS-mappable edit list
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Pure-TypeScript, zero-dependency library. The caller provides a `<canvas>`
+(layout and CSS); the pipeline renders an **ordered list of image edits**
+with fullscreen shader passes (ping-pong, like `glfx.js`), resizing the
+canvas backing store to the rendered output area and presenting 1:1 — the
+image always fills the canvas exactly. The same list serializes
+to JSON that `vips-preview` (`convert`/`thumbnail` `"edits"`) applies
+before saving.
+
+```
+editor/
+  src/
+    types.ts      edit list model + JSON wire format
+    math.ts       shared pixel-math helpers
+    shaders.ts    shared GLSL (quad, copy, blit, gaussian)
+    pipeline.ts   EditPipeline — headless, canvas-taking preview
+    transforms/   one Transform class per edit + registry (index.ts)
+                  + state serialization (state.ts); mirrors src/transforms/*.h
+    index.ts      public surface (per-transform types import from their file)
+  demo/ tests/   playground (schema-driven) · vitest
+  demo/parity.html + demo/parity.ts + demo/parity-cases.json
+                  committed WebGL↔VIPS side-by-side page: static shell, runtime
+                  cards + live WebGL, cases as typed JSON (`satisfies` import)
+  demo/parity/    git-ignored VIPS JPEGs rendered by generate-parity.py
+  demo/generate-parity.py  dumb renderer: reads parity-cases.json, runs a
+                  built vips-preview (`npm run parity`)
+              UltraHDR source; VIPS side pre-rendered, WebGL side live.
+```
+
+Adding a transform: write its file, add one line to the registry — pipeline,
+validation, serialization, and demo pick it up.
+
+```bash
+cd editor
+npm install
+npm run dev        # demo playground
+npm run parity     # render VIPS-side parity JPEGs via a built vips-preview
+npm run typecheck && npm test   # tsc + vitest
+npm run format     # prettier --write
+npm run build      # typecheck + demo bundle (index.html + parity.html)
+```
+
+## Publishing
+
+The package ships compiled `dist/` (JS + `.d.ts`, zero runtime deps).
+`npm publish` runs `prepublishOnly` (clean → typecheck → test → `build:lib`).
+
+```bash
+cd editor
+npm run publish:dry  # verify tarball contents without uploading
+npm publish          # clean + typecheck + test + build:lib, then publish
+```
+
+## Wire format
+
+```json
+{
+  "cmd": "convert",
+  "input": "in.jpg",
+  "output": "out.jpg",
+  "edits": [{ "edit": "brightnessContrast", "brightness": 0.1, "contrast": 0.1 }]
+}
+```
+
+Numerics are optional (missing = no-change, except `sepia.amount` default 1);
+the CLI rejects out-of-range values, so normalize client-side.
+
+## VIPS mapping
+
+sRGB 0..1 floats, array order, single uchar clip at the end; alpha is split
+off, normalized to 0..1 float alongside, reattached. Everything agrees to
+float precision (±1 LSB after quantize), including `blur`/`sharpen` (both
+sides convolve the same discrete kernel — `sigma=radius/2`,
+`half=min(15,max(1,ceil(2σ)))`, clamp edges — via two separable passes).
+Thumbnail edits run **after** resize (radii are output pixels). The preview
+downscales sources larger than 2048px and scales `blur`/`sharpen` radii by
+the working/native ratio, so it shows the same *relative* blur as the
+full-res VIPS output. UHDR ICC+gainmap pass through untouched (gainmap is
+not re-derived). `rotate` by
+a non-90 angle appends a transparent alpha band (corners + fringes); 90°
+multiples stay exact with no band change.
+
+| edit                    | params                                 | VIPS                           |
+| ----------------------- | -------------------------------------- | ------------------------------ |
+| `brightnessContrast`    | `brightness`, `contrast` −1..1         | `linear(mult, bias)`           |
+| `exposure`              | `stops` −5..5                          | `linear(2^stops)`              |
+| `hueSaturation`         | `hue`, `saturation` −1..1              | fused 3×3 (≡ `recomb`)         |
+| `sepia`                 | `amount` 0..1                          | same matrix, clipped at cast   |
+| `vibrance` / `vignette` | `amount` −1..1 / `size`, `amount` 0..1 | identical CPU loop             |
+| `grayscale` / `invert`  | —                                      | `(r+g+b)/3` / `linear(-1, +1)` |
+| `blur` / `sharpen`      | `radius` 0..100 / +`amount` 0..5       | shared kernel + `convsep` (mix)|
+| `crop`                  | `x`,`y`,`width`,`height` 0..1 fractions| `extract_area` (rounded+clamped)|
+| `rotate`                | `angle` −180..180 (clockwise °)        | `rot()` @90s, else `rotate()` |
+
+Excluded (no clean VIPS mapping): `denoise`, `noise`, `curves`,
+`lensBlur`/`tiltShift`/`zoomBlur`, halftones, warps.
+
+Caveats: no-float GPUs fall back to 8-bit targets (more rounding drift);
+preview caps at 2048px longest side (VIPS renders full-res); WebGL failures
+throw instead of rendering black. Shaders adapted from
+[evanw/glfx.js](https://github.com/evanw/glfx.js) (BSD).

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { EditPipeline } from './pipeline.js';
+export { TRANSFORMS, validateEdit, normalizeEdit } from './transforms/index.js';
+export { validateState, stateToJSON, stateFromJSON } from './transforms/state.js';
+export type { Transform, ParamControl, RenderContext, Target } from './transforms/transform.js';
+export { emptyState, EDIT_STATE_VERSION } from './types.js';
+export type { Edit, EditName, EditState } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAClF,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AAChG,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAC5D,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+// index.ts — minimal public surface: the pipeline, the registry, state
+// helpers, and the types needed to consume them (including writing a
+// custom Transform). Internal helpers (lookup, isNumInRange,
+// setFloatUniform, math utils, per-transform types) live in their own
+// modules — import those directly.
+export { EditPipeline } from './pipeline.js';
+export { TRANSFORMS, validateEdit, normalizeEdit } from './transforms/index.js';
+export { validateState, stateToJSON, stateFromJSON } from './transforms/state.js';
+export { emptyState, EDIT_STATE_VERSION } from './types.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,uEAAuE;AACvE,qEAAqE;AACrE,6DAA6D;AAC7D,sEAAsE;AACtE,mCAAmC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAElF,OAAO,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC"}

package/dist/math.d.ts

@@ -0,0 +1,11 @@
+export declare function clampf(lo: number, v: number, hi: number): number;
+/** Exposure gain for a stop shift. */
+export declare function exposureMult(stops: number): number;
+/** 1D gaussian kernel for a blur radius (sigma = radius/2). Preview + docs.
+ *
+ * Single source of truth, ported term-for-term to src/transforms/gaussian.h:
+ * both sides convolve these exact weights (separable, clamp edges), so
+ * preview and VIPS agree to ±1 LSB at every radius.
+ */
+export declare function gaussianKernel(radius: number): number[];
+//# sourceMappingURL=math.d.ts.map

package/dist/math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"AAYA,wBAAgB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,sCAAsC;AACtC,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAavD"}

package/dist/math.js

@@ -0,0 +1,40 @@
+// math.ts — CPU reference for every edit's pixel math.
+//
+// These functions are the single source of truth shared (by port, not by
+// import) with the GLSL in shaders.ts and the libvips code in src/edit.h:
+//   preview (WebGL)  ==  math.ts  ==  VIPS applier
+// all operate on sRGB-encoded 0..1 floats and apply in array order.
+//
+// glfx.js inspiration: brightnessContrast / hueSaturation / sepia / vibrance /
+// vignette shaders are direct ports of evanw/glfx.js adjust filters (see
+// shaders.ts); the matrix derivations below match those shaders term for term
+// so a VIPS `recomb`/`linear` does exactly what the canvas showed.
+export function clampf(lo, v, hi) {
+    return Math.min(hi, Math.max(lo, v));
+}
+/** Exposure gain for a stop shift. */
+export function exposureMult(stops) {
+    return Math.pow(2, clampf(-5, stops, 5));
+}
+/** 1D gaussian kernel for a blur radius (sigma = radius/2). Preview + docs.
+ *
+ * Single source of truth, ported term-for-term to src/transforms/gaussian.h:
+ * both sides convolve these exact weights (separable, clamp edges), so
+ * preview and VIPS agree to ±1 LSB at every radius.
+ */
+export function gaussianKernel(radius) {
+    const r = clampf(0, radius, 100);
+    if (r <= 0)
+        return [1];
+    const sigma = r / 2;
+    const half = Math.min(15, Math.max(1, Math.ceil(sigma * 2)));
+    const w = [];
+    let sum = 0;
+    for (let i = -half; i <= half; i++) {
+        const v = Math.exp(-0.5 * (i / sigma) * (i / sigma));
+        w.push(v);
+        sum += v;
+    }
+    return w.map((v) => v / sum);
+}
+//# sourceMappingURL=math.js.map

package/dist/math.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"math.js","sourceRoot":"","sources":["../src/math.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,EAAE;AACF,yEAAyE;AACzE,0EAA0E;AAC1E,mDAAmD;AACnD,oEAAoE;AACpE,EAAE;AACF,+EAA+E;AAC/E,yEAAyE;AACzE,8EAA8E;AAC9E,mEAAmE;AAEnE,MAAM,UAAU,MAAM,CAAC,EAAU,EAAE,CAAS,EAAE,EAAU;IACtD,OAAO,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AACvC,CAAC;AAED,sCAAsC;AACtC,MAAM,UAAU,YAAY,CAAC,KAAa;IACxC,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;AAC3C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc;IAC3C,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IACjC,IAAI,CAAC,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IACvB,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC;IACpB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7D,MAAM,CAAC,GAAa,EAAE,CAAC;IACvB,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;QACrD,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACV,GAAG,IAAI,CAAC,CAAC;IACX,CAAC;IACD,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;AAC/B,CAAC"}

package/dist/pipeline.d.ts

@@ -0,0 +1,129 @@
+import type { Target, UniformSetter, ExtraTex } from './transforms/transform.js';
+import { type Edit } from './types.js';
+export declare class EditPipeline {
+    private gl;
+    private canvas;
+    private programs;
+    private quad;
+    private src;
+    private ping;
+    private pong;
+    private extra;
+    private imgW;
+    private imgH;
+    private outW;
+    private outH;
+    /** Working/native resolution ratio backing RenderContext.resolutionScale. */
+    private resScale;
+    private state;
+    private floatOK;
+    private highp;
+    /**
+     * Take over the canvas' WebGL context. preserveDrawingBuffer stays true
+     * so the demo can read pixels back; premultipliedAlpha stays false
+     * so alpha survives the passes unmodified. The canvas backing store is
+     * resized to the rendered output on every render — the caller owns layout
+     * and CSS only. Throws when WebGL is missing.
+     */
+    constructor(canvas: HTMLCanvasElement);
+    /** Output image size (source size when no geometric edit applies). */
+    get width(): number;
+    get height(): number;
+    /** Ordered edit list (live reference — mutate via setEdits/addEdit/...). */
+    getEdits(): Edit[];
+    /** Replace the whole edit list (normalizing each edit) and re-render. */
+    setEdits(edits: Edit[]): void;
+    /** Append one edit (normalized) and re-render. */
+    addEdit(edit: Edit): void;
+    /** Drop the edit at `index` and re-render. */
+    removeEdit(index: number): void;
+    /** Reorder one edit and re-render. */
+    moveEdit(from: number, to: number): void;
+    /** Drop all edits (back to the bare source image) and re-render. */
+    clearEdits(): void;
+    /** Canonical JSON state for the VIPS side. */
+    toJSON(): string;
+    /**
+     * Longest side of the working image. Camera JPEGs (12-50MP) would need
+     * hundreds of MB as float ping-pong targets and exceed
+     * MAX_TEXTURE_SIZE on weak GPUs — both failure modes render black with
+     * no exception. The preview is resolution-capped (reported via
+     * width/height); the VIPS side always renders full-res from the JSON.
+     */
+    static readonly MAX_DIM = 2048;
+    /** Resolve the pixel size of any TexImageSource upload. */
+    private sourceDims;
+    /** Turn a sticky GL error flag into a thrown message naming the stage. */
+    private checkGLError;
+    /**
+     * Upload a new source image, (re)allocating all targets to it.
+     * Oversized sources are downscaled through a 2D canvas first (see
+     * MAX_DIM); old GL targets are deleted. Ends with a full render(),
+     * which resizes the canvas backing store to the output area.
+     * Throws with a message instead of rendering black on failure.
+     */
+    setImage(source: TexImageSource): void;
+    /**
+     * Re-run all passes: copy source -> ping, then apply each edit in order,
+     * ping-ponging between the two working targets (`cur` holds the latest
+     * result, `nxt` is the scratch target; multi-pass edits may bounce
+     * between them internally and return either side). Geometric edits
+     * (crop/rotate) change dimensions: `nxt` is resized to the edit's
+     * outputDims before apply, `extra` is kept at the input size (sharpen
+     * scratch). Presents by resizing the canvas to the rendered area and
+     * blitting fullscreen 1:1. No-op when no image is loaded yet.
+     */
+    render(): void;
+    /**
+     * RenderContext facade for Transform.apply(): exposes the pass/blit/gauss
+     * drawing primitives plus the scratch `extra` target, without handing
+     * out the raw WebGL context.
+     */
+    private renderContext;
+    /** Resize a working target when geometry changed (returns live target). */
+    private ensureSize;
+    /**
+     * Decide float vs 8-bit ping-pong targets. Float needs both the
+     * renderable-float extension and float-linear filtering (every pass
+     * samples with LINEAR); either missing falls back to UNSIGNED_BYTE.
+     * Also verifies float renderability with a throwaway 4x4 target.
+     */
+    private probeFloat;
+    /**
+     * Allocate one offscreen RGBA render target (texture + framebuffer) with
+     * linear filtering and clamp-to-edge (NPOT-safe: no mipmaps, no repeat).
+     */
+    private makeTarget;
+    /**
+     * Compile one shader stage, throwing the info log on failure (a bad
+     * shader would otherwise render black with no indication why).
+     */
+    private compile;
+    /** Compile+link the quad vertex shader with `frag`, cached by source. */
+    private program;
+    /**
+     * Draw one fullscreen pass: render `from` through `frag` into `to`.
+     * `from` is bound to unit 0 (`texture` uniform) unless the shader uses
+     * other sampler names; `extraTex` optionally binds a second texture
+     * (used by the sharpen mix pass). `setUniforms` fills the rest.
+     */
+    pass(frag: string, from: Target, to: Target, setUniforms?: UniformSetter, extraTex?: ExtraTex): void;
+    /** Copy one target to another with the identity shader. */
+    blit(from: Target, to: Target): void;
+    /**
+     * One axis of the separable gaussian: `horizontal` picks the sample
+     * direction (offsets are in UV units, hence the 1/width division).
+     * The shader loops over a fixed 31-tap array; `kernel.length` tells it
+     * how many center taps carry real weight, the rest are zero-padded.
+     */
+    gauss(from: Target, to: Target, horizontal: boolean, kernel: number[]): void;
+    /**
+     * Present the final result: resize the canvas backing store to the
+     * rendered output area (a no-op assignment when it already matches —
+     * setting width/height clears, so this only fires when geometry changed)
+     * and blit fullscreen 1:1. (The BLIT_FRAG flip still compensates the
+     * unflipped upload.)
+     */
+    private toCanvas;
+}
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../src/pipeline.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAiB,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAChG,OAAO,EAAc,KAAK,IAAI,EAAkB,MAAM,YAAY,CAAC;AAEnE,qBAAa,YAAY;IACvB,OAAO,CAAC,EAAE,CAAwB;IAClC,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,QAAQ,CAAmC;IAEnD,OAAO,CAAC,IAAI,CAA4B;IAIxC,OAAO,CAAC,GAAG,CAAuB;IAClC,OAAO,CAAC,IAAI,CAAuB;IACnC,OAAO,CAAC,IAAI,CAAuB;IACnC,OAAO,CAAC,KAAK,CAAuB;IACpC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,IAAI,CAAK;IACjB,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,KAAK,CAA2B;IACxC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAS;IAEtB;;;;;;OAMG;gBACgB,MAAM,EAAE,iBAAiB;IA2B5C,sEAAsE;IACtE,IAAW,KAAK,IAAI,MAAM,CAEzB;IACD,IAAW,MAAM,IAAI,MAAM,CAE1B;IAED,4EAA4E;IACrE,QAAQ,IAAI,IAAI,EAAE;IAIzB,yEAAyE;IAClE,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAKpC,kDAAkD;IAC3C,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAKhC,8CAA8C;IACvC,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAKtC,sCAAsC;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAM/C,oEAAoE;IAC7D,UAAU,IAAI,IAAI;IAKzB,8CAA8C;IACvC,MAAM,IAAI,MAAM;IAIvB;;;;;;OAMG;IACH,gBAAuB,OAAO,QAAQ;IAEtC,2DAA2D;IAC3D,OAAO,CAAC,UAAU;IAelB,0EAA0E;IAC1E,OAAO,CAAC,YAAY;IAQpB;;;;;;OAMG;IACI,QAAQ,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI;IAuD7C;;;;;;;;;OASG;IACI,MAAM,IAAI,IAAI;IAqCrB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAoBrB,2EAA2E;IAC3E,OAAO,CAAC,UAAU;IAelB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAqBlB;;;OAGG;IACH,OAAO,CAAC,UAAU;IAiBlB;;;OAGG;IACH,OAAO,CAAC,OAAO;IAcf,yEAAyE;IACzE,OAAO,CAAC,OAAO;IAoBf;;;;;OAKG;IACI,IAAI,CACT,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,WAAW,CAAC,EAAE,aAAa,EAC3B,QAAQ,CAAC,EAAE,QAAQ,GAClB,IAAI;IA2BP,2DAA2D;IACpD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAI3C;;;;;OAKG;IACI,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI;IAenF;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;CAsBjB"}