@coherent.js/forms 1.1.2 → 2.0.0-rc.0

package/README.md

@@ -1,303 +1,222 @@
 # @coherent.js/forms
 
-Comprehensive forms handling and validation utilities for Coherent.js applications.
+Server-rendered forms for Coherent.js: build a form on the server, validate
+submissions with the same rules on both sides, and progressively enhance it in
+the browser with `hydrateForm`.
+
+- ESM-only, Node 22.12+
+- The package root is isomorphic; `@coherent.js/forms/csrf` is server-only.
 
 ## Installation
 
 ```bash
-npm install @coherent.js/forms
-# or
 pnpm add @coherent.js/forms
-# or
-yarn add @coherent.js/forms
 ```
 
-## Overview
-
-The `@coherent.js/forms` package provides powerful form handling capabilities including:
+## Exports
 
-- Form state management
-- Validation with built-in validators
-- Error handling and display
-- Form serialization and submission
-- Integration with Coherent.js components
+| Import path | Exports |
+| --- | --- |
+| `@coherent.js/forms` | `FormBuilder`, `createFormBuilder`, `buildForm`, `DEFAULT_CLASS_NAMES`, `hydrateForm`, `validators`, `FormValidator`, `createValidator`, `validate`, `validateField`, `validateForm`, `registerValidator`, `composeValidators` |
+| `@coherent.js/forms/form-builder` | `FormBuilder`, `createFormBuilder`, `buildForm`, `DEFAULT_CLASS_NAMES` |
+| `@coherent.js/forms/hydration` | `hydrateForm` |
+| `@coherent.js/forms/validation` | `validators`, `FormValidator`, `createValidator`, `validate` |
+| `@coherent.js/forms/validators` | `validators`, `validateField`, `validateForm`, `createValidator`, `registerValidator`, `composeValidators` |
+| `@coherent.js/forms/csrf` (server only) | `createCsrfToken`, `verifyCsrfToken`, `CSRF_FIELD_NAME` |
 
-## Quick Start
+## Quick start
 
 ```javascript
-import { createForm } from '@coherent.js/forms';
-import { validators } from '@coherent.js/state';
-
-const contactForm = createForm({
-  fields: {
-    email: {
-      value: '',
-      validators: [validators.email('Please enter a valid email')]
-    },
-    message: {
-      value: '',
-      validators: [validators.minLength(10, 'Message must be at least 10 characters')]
-    }
-  }
+import { render } from '@coherent.js/core';
+import { createFormBuilder, validators } from '@coherent.js/forms';
+
+// The form definition, shared by every request.
+const signup = createFormBuilder({
+  action: '/signup',
+  method: 'post',
+  fields: [
+    { name: 'email', type: 'email', label: 'Email', required: true },
+    { name: 'password', type: 'password', label: 'Password', required: true,
+      validators: [validators.minLength(8)] }
+  ]
 });
 
-function ContactForm() {
-  const handleSubmit = async (event) => {
-    event.preventDefault();
-    
-    if (contactForm.validate()) {
-      // Form is valid, submit data
-      await submitFormData(contactForm.values);
-      contactForm.reset();
-    }
-  };
-
-  return {
-    form: {
-      onsubmit: handleSubmit,
-      children: [
-        {
-          input: {
-            type: 'email',
-            value: contactForm.fields.email.value,
-            oninput: (e) => contactForm.setField('email', e.target.value),
-            className: contactForm.fields.email.error ? 'error' : ''
-          }
-        },
-        {
-          span: {
-            text: contactForm.fields.email.error || '',
-            className: 'error-message'
-          }
-        },
-        {
-          textarea: {
-            value: contactForm.fields.message.value,
-            oninput: (e) => contactForm.setField('message', e.target.value),
-            className: contactForm.fields.message.error ? 'error' : ''
-          }
-        },
-        {
-          span: {
-            text: contactForm.fields.message.error || '',
-            className: 'error-message'
-          }
-        },
-        {
-          button: {
-            type: 'submit',
-            text: 'Send Message',
-            disabled: contactForm.isSubmitting
-          }
-        }
-      ]
-    }
-  };
+// GET /signup
+const html = render(signup.buildForm());
+
+// POST /signup — fork() gives this request its own state
+const form = signup.fork().setValues(request.body);
+const errors = form.validate();
+if (Object.keys(errors).length > 0) {
+  for (const name of Object.keys(errors)) form.touch(name);
+  return render(form.buildForm()); // re-render with values and errors
 }
 ```
 
-## Features
+In the browser, `hydrateForm('form[name="form"]')` reads the validation rules
+the server rendered and validates on blur and submit.
+
+## Validators
 
-### Form State Management
+A **validator** is a function `(value, formData) => string | null`: an error
+message, or `null` when the value passes. Every runner — `FormValidator`
+schemas, `validateField`, `validateForm`, `FormBuilder` fields and
+`hydrateForm` — calls validators that way.
 
-Automatically manage form state including values, errors, and submission status:
+Each built-in is a **factory** that returns a validator. The last argument is
+always an optional custom message:
 
 ```javascript
-const form = createForm({
-  fields: {
-    username: { value: '' },
-    password: { value: '' }
+import { validators, validateForm } from '@coherent.js/forms';
+
+validateForm(
+  { name: '', email: 'nope', age: '15' },
+  {
+    name: [validators.required('Please enter your name')],
+    email: [validators.required, validators.email()],
+    age: [validators.min(18, 'You must be 18 or older')]
   }
-});
-
-// Access form values
-console.log(form.values); // { username: '', password: '' }
-
-// Update field values
-form.setField('username', 'john_doe');
-
-// Check form validity
-console.log(form.isValid); // true/false
-
-// Check submission status
-console.log(form.isSubmitting); // true/false
+);
+// → { name: 'Please enter your name', email: 'Invalid email address', age: 'You must be 18 or older' }
 ```
 
-### Validation
-
-Built-in validators with custom validation support:
+- A built-in may be listed without calling it (`validators.required`); it runs
+  with its defaults. A string names a built-in or registered validator (see
+  below).
+- Apart from `required` and `matches`, built-ins pass empty values, so combine
+  them with `required`.
+- For direct checks, pass the value and an options object:
+  `validators.minLength('abc', { min: 5 })` returns `'Minimum length is 5'`.
+  A lone string argument is always a message, so `validators.email('a@b.c')`
+  returns a validator rather than checking `'a@b.c'`.
+
+Built-ins: `required`, `email`, `url`, `minLength(min)`, `maxLength(max)`,
+`min(min)`, `max(max)`, `pattern(regex)`, `matches(field)`, `match(field)`,
+`oneOf(values)`, `custom(fn)`, `number`, `integer`, `phone`, `date`, `alpha`,
+`alphanumeric`, `uppercase`, `fileType(accept)`, `fileSize(maxSize)`,
+`fileExtension(extensions)`. Helpers: `compose`, `when`, `chain`, `debounce`,
+`cancellable`, `get`.
+
+### Accepted validator entries
+
+A validator list — a `FormBuilder` field's `validators`, a `FormValidator`
+schema, `validateField` / `validateForm` — accepts, in any mix:
+
+| Entry | Example | Same as |
+| --- | --- | --- |
+| A validator function | `value => value ? null : 'Required'` | — |
+| A built-in, called | `validators.minLength(8, 'Too short')` | — |
+| A built-in, uncalled | `validators.required` | `validators.required()` |
+| A name | `'required'`, `'email'`, `'noShouting'` (registered) | `validators.required()` |
+| A built-in name with arguments | `'minLength:8'` | `validators.minLength(8)` |
+
+A string with arguments is `'name:arguments'`, read by the built-in's
+parameter:
+
+- a number (`minLength`, `maxLength`, `min`, `max`, `fileSize`): the number,
+  then optionally a comma and a message — `'min:18'`,
+  `'minLength:8,Use at least 8 characters'`;
+- a field name (`matches`, `match`): `'matches:password'`, optionally
+  followed by `,message`;
+- a list (`oneOf`, `fileType`, `fileExtension`): every comma-separated value —
+  `'oneOf:small,medium,large'`, `'fileType:image/*,.pdf'`;
+- a regular expression (`pattern`): everything after the colon, commas
+  included — `'pattern:^[a-z]{2,8}$'` (no flags; use `validators.pattern()`
+  for flags or a message);
+- no parameter (`required`, `email`, …): a message — `'required:Name please'`.
+
+Registered validators take no arguments: name them alone. An unknown name,
+or arguments that do not fit (`'minLength:abc'`), is skipped.
 
 ```javascript
-import { validators } from '@coherent.js/state';
-
-const form = createForm({
-  fields: {
-    email: {
-      value: '',
-      validators: [
-        validators.required('Email is required'),
-        validators.email('Please enter a valid email')
-      ]
-    },
-    age: {
-      value: '',
-      validators: [
-        validators.required('Age is required'),
-        validators.min(18, 'Must be at least 18 years old')
-      ]
-    }
-  }
-});
-
-// Custom validator
-const customValidator = (value) => {
-  if (value && value.length < 5) {
-    return 'Value must be at least 5 characters';
-  }
-  return null; // null means valid
-};
-
-const formWithCustomValidation = createForm({
-  fields: {
-    customField: {
-      value: '',
-      validators: [customValidator]
-    }
-  }
+createFormBuilder({
+  fields: [
+    { name: 'password', type: 'password', validators: ['required', 'minLength:8'] },
+    { name: 'size', validators: ['oneOf:s,m,l'] }
+  ]
 });
 ```
 
-### Async Validation
+String entries are enforced on the server and rendered into `data-validators`
+exactly like the equivalent factory call, so `hydrateForm` enforces them too.
 
-Support for asynchronous validation (e.g., checking if username is available):
+Your own validators follow the same shape:
 
 ```javascript
-const asyncValidator = async (value) => {
-  if (!value) return null;
-  
-  const response = await fetch(`/api/check-username/${value}`);
-  const exists = await response.json();
-  
-  return exists ? 'Username is already taken' : null;
-};
-
-const signupForm = createForm({
-  fields: {
-    username: {
-      value: '',
-      validators: [asyncValidator]
-    }
-  }
-});
-```
+import { registerValidator, validators, createValidator } from '@coherent.js/forms';
 
-## API Reference
+const noShouting = value =>
+  value && value === value.toUpperCase() ? 'Please stop shouting' : null;
 
-### createForm(options)
+registerValidator('noShouting', noShouting);   // now validators.noShouting
+const noSpaces = createValidator(value => /\s/.test(value), 'No spaces allowed');
+```
 
-Create a new form instance.
+`createValidator(schema)` returns a `FormValidator`; `createValidator(fn,
+message)` wraps a check function as above.
 
-**Parameters:**
-- `options.fields` - Object defining form fields and their initial state
-- `options.onSubmit` - Optional function to handle form submission
+### Client-side validation
 
-**Returns:** Form instance with methods and properties
+For each field, the builder renders its validators into `data-validators` as
+JSON (`[{"name":"minLength","args":[8]}]`), and `hydrateForm` rebuilds the
+same rules, so the browser and the server give the same verdict and message.
+Built-ins and registered validators (register the same name in the browser)
+are described; anonymous functions run on the server only.
 
-### Form Instance Properties
+## Forms on a server: one state per request
 
-- `values` - Current form values
-- `fields` - Field state objects with value, error, touched, etc.
-- `isValid` - Boolean indicating if form is valid
-- `isSubmitting` - Boolean indicating if form is being submitted
-- `errors` - Object containing field errors
+A `FormBuilder` holds the values, errors and touched state of one submission.
+Keep the definition at module scope, and never fill that shared instance with
+request data — the next user would see it. Either fork it per request:
 
-### Form Instance Methods
+```javascript
+const form = signup.fork();
+form.setValues(request.body);
+```
 
-- `setField(name, value)` - Update a field's value
-- `validate()` - Validate all fields, returns boolean
-- `reset()` - Reset form to initial state
-- `submit()` - Trigger form submission
+or render per-request state without touching the builder:
 
-## Integration with @coherent.js/state
+```javascript
+render(signup.buildForm({ values: request.body, errors }));
+```
 
-The forms package integrates seamlessly with the reactive state system:
+## CSRF protection
 
-```javascript
-import { createForm } from '@coherent.js/forms';
-import { observable } from '@coherent.js/state';
+`@coherent.js/forms/csrf` (server only) issues stateless tokens bound to a
+session and signed with HMAC-SHA256:
 
-// Create reactive form
-const form = createForm({
-  fields: {
-    search: { value: '' }
-  }
-});
+```javascript
+import { createCsrfToken, verifyCsrfToken } from '@coherent.js/forms/csrf';
 
-// Create observable for search results
-const searchResults = observable([]);
+// GET: render the token as a hidden _csrf input
+const csrfToken = createCsrfToken(process.env.CSRF_SECRET, session.id);
+render(signup.buildForm({ csrfToken }));
 
-// Update search results when form changes
-form.fields.search.watch((newValue) => {
-  if (newValue.length > 2) {
-    performSearch(newValue).then(results => {
-      searchResults.value = results;
-    });
-  }
-});
+// POST: reject the request unless the token matches this session
+if (!verifyCsrfToken(request.body._csrf, process.env.CSRF_SECRET, session.id, { maxAge: 60 * 60 * 1000 })) {
+  return response.status(403).end();
+}
 ```
 
-## Examples
-
-### Login Form
+## Hydration
 
 ```javascript
-import { createForm } from '@coherent.js/forms';
-import { validators } from '@coherent.js/state';
-
-const loginForm = createForm({
-  fields: {
-    email: {
-      value: '',
-      validators: [
-        validators.required('Email is required'),
-        validators.email('Please enter a valid email')
-      ]
-    },
-    password: {
-      value: '',
-      validators: [
-        validators.required('Password is required'),
-        validators.minLength(8, 'Password must be at least 8 characters')
-      ]
-    }
-  },
-  async onSubmit(values) {
-    try {
-      const response = await fetch('/api/login', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(values)
-      });
-      
-      if (response.ok) {
-        // Handle successful login
-        window.location.href = '/dashboard';
-      } else {
-        // Handle login error
-        throw new Error('Invalid credentials');
-      }
-    } catch (error) {
-      loginForm.setError('login', error.message);
-    }
+import { hydrateForm } from '@coherent.js/forms/hydration';
+
+const controller = hydrateForm('#signup', {
+  onSubmit: async (values) => {
+    await fetch('/api/signup', { method: 'POST', body: JSON.stringify(values) });
   }
 });
 ```
 
-## Related Packages
+Pass the same `classNames` you gave `buildForm` if you customised them. The
+controller exposes `validateField`, `validateForm`, `getValues`, `getErrors`,
+`setFieldValue`, `reset` and `destroy`.
+
+## TypeScript
 
-- [@coherent.js/state](../state/README.md) - Reactive state management
-- [@coherent.js/core](../core/README.md) - Core framework
-- [@coherent.js/client](../client/README.md) - Client-side utilities
+Type definitions ship with the package (`types/index.d.ts`, `types/csrf.d.ts`).
 
 ## License
 

package/dist/csrf.js

@@ -0,0 +1,57 @@
+// src/csrf.js
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { Buffer } from "node:buffer";
+var CSRF_FIELD_NAME = "_csrf";
+var TOKEN_PATTERN = /^([0-9a-z]{1,13})\.([A-Za-z0-9_-]{16,64})\.([A-Za-z0-9_-]{43})$/;
+var CLOCK_SKEW_MS = 6e4;
+function assertSecret(secret) {
+  const usable = typeof secret === "string" && secret.length > 0 || secret instanceof Uint8Array && secret.length > 0;
+  if (!usable) {
+    throw new TypeError("A CSRF secret (non-empty string or Buffer) is required");
+  }
+}
+function assertSessionId(sessionId) {
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    throw new TypeError("A CSRF token must be bound to a non-empty session id string");
+  }
+}
+function sign(secret, issuedAt, nonce, sessionId) {
+  return createHmac("sha256", secret).update(`${issuedAt}.${nonce}.${sessionId}`).digest("base64url");
+}
+function createCsrfToken(secret, sessionId, options = {}) {
+  assertSecret(secret);
+  assertSessionId(sessionId);
+  const issuedAt = Math.floor(options.now ?? Date.now()).toString(36);
+  const nonce = randomBytes(16).toString("base64url");
+  return `${issuedAt}.${nonce}.${sign(secret, issuedAt, nonce, sessionId)}`;
+}
+function verifyCsrfToken(token, secret, sessionId, options = {}) {
+  assertSecret(secret);
+  if (typeof sessionId !== "string" || sessionId.length === 0) return false;
+  if (typeof token !== "string") return false;
+  const match = TOKEN_PATTERN.exec(token);
+  if (!match) return false;
+  const [, issuedAt, nonce, mac] = match;
+  const expected = Buffer.from(sign(secret, issuedAt, nonce, sessionId));
+  const actual = Buffer.from(mac);
+  if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {
+    return false;
+  }
+  if (options.maxAge !== void 0) {
+    const age = (options.now ?? Date.now()) - parseInt(issuedAt, 36);
+    if (!(age >= -CLOCK_SKEW_MS && age <= options.maxAge)) return false;
+  }
+  return true;
+}
+var csrf_default = {
+  CSRF_FIELD_NAME,
+  createCsrfToken,
+  verifyCsrfToken
+};
+export {
+  CSRF_FIELD_NAME,
+  createCsrfToken,
+  csrf_default as default,
+  verifyCsrfToken
+};
+//# sourceMappingURL=csrf.js.map

package/dist/csrf.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/csrf.js"],
+  "sourcesContent": ["/**\n * Coherent.js Forms - CSRF tokens (server only)\n *\n * Stateless, session-bound CSRF tokens signed with HMAC-SHA256. Import from\n * `@coherent.js/forms/csrf` on the server; the package root stays free of\n * `node:crypto` so it keeps working in the browser.\n *\n * ```js\n * import { createCsrfToken, verifyCsrfToken } from '@coherent.js/forms/csrf';\n *\n * // GET: render the form with a token for this session\n * const csrfToken = createCsrfToken(process.env.CSRF_SECRET, req.session.id);\n * render(form.buildForm({ csrfToken }));   // adds <input type=\"hidden\" name=\"_csrf\">\n *\n * // POST: reject the request unless the token matches the session\n * if (!verifyCsrfToken(req.body._csrf, process.env.CSRF_SECRET, req.session.id, { maxAge: 3_600_000 })) {\n *   return res.status(403).end();\n * }\n * ```\n *\n * A token is `<issuedAt>.<nonce>.<mac>`, where the MAC covers the issue time,\n * the nonce and the session id, so a token minted for one session is rejected\n * for any other, and `maxAge` bounds how long it stays valid.\n *\n * @module forms/csrf\n */\n\nimport { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';\nimport { Buffer } from 'node:buffer';\n\n/** Default name of the hidden field the form builder renders. */\nexport const CSRF_FIELD_NAME = '_csrf';\n\nconst TOKEN_PATTERN = /^([0-9a-z]{1,13})\\.([A-Za-z0-9_-]{16,64})\\.([A-Za-z0-9_-]{43})$/;\n\nconst CLOCK_SKEW_MS = 60_000;\n\nfunction assertSecret(secret) {\n  const usable = (typeof secret === 'string' && secret.length > 0) ||\n    (secret instanceof Uint8Array && secret.length > 0);\n  if (!usable) {\n    throw new TypeError('A CSRF secret (non-empty string or Buffer) is required');\n  }\n}\n\nfunction assertSessionId(sessionId) {\n  if (typeof sessionId !== 'string' || sessionId.length === 0) {\n    throw new TypeError('A CSRF token must be bound to a non-empty session id string');\n  }\n}\n\nfunction sign(secret, issuedAt, nonce, sessionId) {\n  return createHmac('sha256', secret)\n    .update(`${issuedAt}.${nonce}.${sessionId}`)\n    .digest('base64url');\n}\n\n/**\n * Create a CSRF token bound to `sessionId`.\n *\n * @param {string|Buffer} secret - Server-side signing secret\n * @param {string} sessionId - The session the token belongs to\n * @param {{ now?: number }} [options] - `now` (ms) overrides the issue time\n * @returns {string} The token\n */\nexport function createCsrfToken(secret, sessionId, options = {}) {\n  assertSecret(secret);\n  assertSessionId(sessionId);\n\n  const issuedAt = Math.floor(options.now ?? Date.now()).toString(36);\n  const nonce = randomBytes(16).toString('base64url');\n  return `${issuedAt}.${nonce}.${sign(secret, issuedAt, nonce, sessionId)}`;\n}\n\n/**\n * Check a submitted CSRF token. Returns `false` (never throws) for a missing,\n * malformed, forged, expired or other-session token.\n *\n * @param {unknown} token - The submitted token (e.g. `req.body._csrf`)\n * @param {string|Buffer} secret - The secret the token was created with\n * @param {string} sessionId - The current request's session id\n * @param {{ maxAge?: number, now?: number }} [options] - `maxAge` in ms\n * @returns {boolean} Whether the token is valid for this session\n */\nexport function verifyCsrfToken(token, secret, sessionId, options = {}) {\n  assertSecret(secret);\n  if (typeof sessionId !== 'string' || sessionId.length === 0) return false;\n  if (typeof token !== 'string') return false;\n\n  const match = TOKEN_PATTERN.exec(token);\n  if (!match) return false;\n  const [, issuedAt, nonce, mac] = match;\n\n  const expected = Buffer.from(sign(secret, issuedAt, nonce, sessionId));\n  const actual = Buffer.from(mac);\n  if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) {\n    return false;\n  }\n\n  if (options.maxAge !== undefined) {\n    const age = (options.now ?? Date.now()) - parseInt(issuedAt, 36);\n    // A minute of tolerance for clocks that differ between servers.\n    if (!(age >= -CLOCK_SKEW_MS && age <= options.maxAge)) return false;\n  }\n\n  return true;\n}\n\nexport default {\n  CSRF_FIELD_NAME,\n  createCsrfToken,\n  verifyCsrfToken\n};\n"],
+  "mappings": ";AA2BA,SAAS,YAAY,aAAa,uBAAuB;AACzD,SAAS,cAAc;AAGhB,IAAM,kBAAkB;AAE/B,IAAM,gBAAgB;AAEtB,IAAM,gBAAgB;AAEtB,SAAS,aAAa,QAAQ;AAC5B,QAAM,SAAU,OAAO,WAAW,YAAY,OAAO,SAAS,KAC3D,kBAAkB,cAAc,OAAO,SAAS;AACnD,MAAI,CAAC,QAAQ;AACX,UAAM,IAAI,UAAU,wDAAwD;AAAA,EAC9E;AACF;AAEA,SAAS,gBAAgB,WAAW;AAClC,MAAI,OAAO,cAAc,YAAY,UAAU,WAAW,GAAG;AAC3D,UAAM,IAAI,UAAU,6DAA6D;AAAA,EACnF;AACF;AAEA,SAAS,KAAK,QAAQ,UAAU,OAAO,WAAW;AAChD,SAAO,WAAW,UAAU,MAAM,EAC/B,OAAO,GAAG,QAAQ,IAAI,KAAK,IAAI,SAAS,EAAE,EAC1C,OAAO,WAAW;AACvB;AAUO,SAAS,gBAAgB,QAAQ,WAAW,UAAU,CAAC,GAAG;AAC/D,eAAa,MAAM;AACnB,kBAAgB,SAAS;AAEzB,QAAM,WAAW,KAAK,MAAM,QAAQ,OAAO,KAAK,IAAI,CAAC,EAAE,SAAS,EAAE;AAClE,QAAM,QAAQ,YAAY,EAAE,EAAE,SAAS,WAAW;AAClD,SAAO,GAAG,QAAQ,IAAI,KAAK,IAAI,KAAK,QAAQ,UAAU,OAAO,SAAS,CAAC;AACzE;AAYO,SAAS,gBAAgB,OAAO,QAAQ,WAAW,UAAU,CAAC,GAAG;AACtE,eAAa,MAAM;AACnB,MAAI,OAAO,cAAc,YAAY,UAAU,WAAW,EAAG,QAAO;AACpE,MAAI,OAAO,UAAU,SAAU,QAAO;AAEtC,QAAM,QAAQ,cAAc,KAAK,KAAK;AACtC,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,CAAC,EAAE,UAAU,OAAO,GAAG,IAAI;AAEjC,QAAM,WAAW,OAAO,KAAK,KAAK,QAAQ,UAAU,OAAO,SAAS,CAAC;AACrE,QAAM,SAAS,OAAO,KAAK,GAAG;AAC9B,MAAI,OAAO,WAAW,SAAS,UAAU,CAAC,gBAAgB,QAAQ,QAAQ,GAAG;AAC3E,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,WAAW,QAAW;AAChC,UAAM,OAAO,QAAQ,OAAO,KAAK,IAAI,KAAK,SAAS,UAAU,EAAE;AAE/D,QAAI,EAAE,OAAO,CAAC,iBAAiB,OAAO,QAAQ,QAAS,QAAO;AAAA,EAChE;AAEA,SAAO;AACT;AAEA,IAAO,eAAQ;AAAA,EACb;AAAA,EACA;AAAA,EACA;AACF;",
+  "names": []
+}