@tryghost/metafield-types 0.1.2 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,71 @@
 # @tryghost/metafield-types
 
+## 0.3.0
+
+### Minor Changes
+
+- Changed the catalog to describe each field type as a composition of building blocks, and to derive each type's rule from them.
+
+  - `FIELD_STRUCTURES` replaces `FIELD_PARTS`. A type is one leaf, `{ shape: 'scalar', leaf }`, or a record of named leaves, `{ shape: 'record', parts }`.
+  - A leaf is text of a size, `text(size)` with `TEXT_SIZES`, or a choice from a list, `choice(from)` with `LIST_SOURCES`. `country` is the choice from the list of countries.
+  - A part's type is now its leaf, so `PART_TYPE_IDS`, `PartType` and `partTypesOf` are removed. An address's postal code is `text('code')`, its country is `country`, and its other parts are `text('line')`.
+  - `FIELD_KINDS` and `FieldKind` are removed. A scalar's leaf says what it holds.
+  - `matchShape(type, { scalar, record })` and `matchLeaf(leaf, { text, choice })` call the handler for a type's shape or a leaf's kind, so a caller has to say what it does with every one. `matchShape` throws for a type the package doesn't know, so check a type from the wire with `isFieldType` first.
+  - `isRecordValue` tells whether a value is laid out as a record of parts.
+  - `StructureOf`, `ShapeOf`, `FieldTypeOfShape` and `PartsOf` name what a type is composed of, and `ValueOf` names the value it holds.
+  - `partsOf` names a record's parts as plain strings. Read one type's parts by name from `FIELD_STRUCTURES[type].parts`, whose keys are typed.
+  - `valueSchemaFor(field)` is the rule a value of one field must satisfy, derived from its type's composition. It replaces `FIELD_TYPES`, `FieldTypeDefinition`, `PART_TYPES` and `AddressValue`, which are removed. `FieldValue` and `Address` stay.
+
+- Added helpers for editing a list field's answers.
+
+  - `inOptionOrder(settings, held)` is the answers among `held` that a list offers, in its order, and `editableAnswers(settings, held)` is what a form editing a list's answers starts from: none while a field taking one holds several.
+
+- Added the list field type, whose field offers options of its own and takes one or several of them.
+
+  - `list` is `{ shape: 'set' }`: a value is the text of each option picked, as `string[]`, even when the field takes one. `matchShape` handlers take a `set` branch.
+  - A field now carries `settings` beside its `type`. `SettingsOf<T>` is what a type is set up with: `SetSettings` (`options`, in the order shown, and `multiple`) for a list, and nothing for every other type, so a field of another type has no settings. `TypedSettings` pairs a type with its settings. `withTypedSettings(base, settings)` builds what a field holds beside its type with that pair, a variant per shape, from how each shape's settings are held: `WRITTEN_SETTINGS` checks them against the rules, and `READ_SETTINGS` reads them back by `SetSettingsShape` alone, so a rule tightened later never hides a field set up under the old one. `TypedSettingsInputSchema` and `TypedSettingsSchema` are the pair on its own, and `MetafieldDefinitionSchema` is built the same way. `typesOfShape(shape)` lists the types of a shape.
+  - `MetafieldDefinitionSchema` reads `settings`, and `MetafieldDefinition` is typed by them, so a list definition always has its options.
+  - `valueSchemaFor(field)` takes the field's type and settings. A list's rule accepts only the options its field offers, and at most one when it takes one.
+  - `matchField(field, handlers)` calls a handler for the field's shape with the field narrowed, settings included.
+  - `optionText` is how an option's text is matched: trimmed, with accents encoded one way. `MIN_OPTIONS`, `MAX_OPTIONS` and `OPTION_SEPARATOR` are a list's limits and the character joining options in one CSV cell, which no option may contain.
+
+- Added `SHAPE_SETTINGS`, each field shape's settings in one place: the shape a read is checked against, the rules a write is checked against on top of that shape, and the defaults a field starts with. `WRITTEN_SETTINGS` and `READ_SETTINGS` are now taken from it, and `SetSettingsSchema` is now built on `SetSettingsShape`.
+
+- Added `refusedProperty(path)`, which names where a refusal points within what was sent by its path, with parts and positions joined by dots, such as `settings.options.2` for a field's third option. Ghost reports a custom field refusal's `property` this way, and a form can file the problems it finds under the same keys.
+
+- Added the shape of a field definition as the Admin and Members APIs return it.
+
+  - `MetafieldDefinitionSchema` reads a definition (namespace, key, name, type, status, member access and dates) and `MetafieldDefinition` is the type it produces. Ghost writes every definition through it.
+  - `FIELD_STATUSES`, `FieldStatusSchema`, `FIELD_STATUS` and `FieldStatus` name whether a field is active or archived.
+
+### Patch Changes
+
+- Pointed the README at a guide for Ghost contributors adding a field type.
+
+- Updated dependencies
+
+- Updated dependencies
+
+- Updated dependencies
+
+## 0.2.0
+
+### Minor Changes
+
+- Changed `./identity` to name a field through types that only a check produces, and renamed the parts helper.
+
+  - `IdentityTextSchema` reads an identity such as `custom.shipping_address.country` into its namespace, key and parts, and writes one back. `z.safeDecode(IdentityTextSchema, text)` replaces `parseIdentity`, and `z.encode(IdentityTextSchema, identity)` replaces `formatIdentity`.
+  - `IdentitySchema` checks an identity whose segments arrive apart, such as a route's namespace and key. Reading a whole field's identity can leave `parts` out; what it reads always has them.
+  - `NamespaceSchema`, `KeySchema` and `PartSchema` check one segment each and produce the `Namespace`, `Key` and `Part` types. They replace `IDENTITY_SEGMENT`.
+  - `Identity` is the decoded shape, with `parts` in place of `partPath`. `FieldIdentity` and `FieldIdentityString` are removed.
+  - `CUSTOM_NAMESPACE` is a `Namespace` rather than the literal `'custom'`.
+  - `./identity` now loads `zod/mini`.
+  - `subFieldsOf` is renamed `partsOf`.
+
+### Patch Changes
+
+- Corrected the description of CUSTOM_NAMESPACE: every field now records its namespace, so the constant only matters to code that speaks for the publisher's own fields.
+
 ## 0.1.2
 
 ### Patch Changes

package/README.md

@@ -1,9 +1,9 @@
 # @tryghost/metafield-types
 
-The types of member custom field Ghost supports: which types exist, which parts a
-type is made of, the type of value each part holds, and how a value of each type is
-validated. Ghost, its Admin and Portal use it, and so can an integration that offers
-inputs for a site's custom fields, such as the Ghost Zapier integration.
+The types of member custom field Ghost supports: which types exist, what each type
+is composed of, and how a value of each type is validated. Ghost, its Admin and Portal
+use it, and so can an integration that offers inputs for a site's custom fields, such
+as the Ghost Zapier integration.
 
 ```bash
 npm install @tryghost/metafield-types
@@ -11,28 +11,37 @@ npm install @tryghost/metafield-types
 
 ## Entry points
 
-- `@tryghost/metafield-types/structure`: the type ids, each type's parts and the
-  type of value each part holds. It depends on nothing.
-- `@tryghost/metafield-types/countries`: the two-letter country codes a country
-  part accepts. It depends on nothing.
-- `@tryghost/metafield-types/identity`: how a field is named in filters and
-  payloads (`custom.<key>`). It depends on nothing.
-- `@tryghost/metafield-types`: the structure above, plus the rules that validate
-  a value of each type. These are built on [zod](https://zod.dev), and only this
-  entry point loads it, so an integration that only draws inputs can use the three
-  entry points above without zod ever being loaded.
+- `@tryghost/metafield-types/structure`: the type ids and what each type is composed
+  of. A type is one leaf, a record of named leaves, or a set of options its field
+  offers, and a leaf is text of a size or a choice from a list, such as a country. A
+  field of a set type is set up with its options, which a field carries as its
+  `settings`. It depends on nothing.
+- `@tryghost/metafield-types/countries`: the two-letter country codes the list of
+  countries offers. It depends on nothing.
+- `@tryghost/metafield-types/identity`: how a field is named everywhere: its
+  namespace, its key, the parts of a record value, and the identity they make
+  together (`custom.shipping_address.country`). Each is a type that only its
+  check produces. It loads `zod/mini`, a small fraction of zod's size, so a
+  browser app can check identities without paying for the rest.
+- `@tryghost/metafield-types`: the structure above, plus `valueSchemaFor(field)`,
+  the rule a value of a field must satisfy given its type and settings. The rules are built on
+  [zod](https://zod.dev), and only this entry point loads all of it, so an
+  integration that only draws inputs can use `./structure` and `./countries`
+  without loading zod at all.
 
 ## Compatibility
 
 An integration using this package talks to sites on many Ghost versions, so a type
-never changes once it has shipped: it keeps its parts and the type of value each
-holds. New structure arrives as a new type. An integration should skip a type it
-doesn't recognise, which is what happens when a site is on a newer Ghost than the
-package the integration was built with.
+never changes once it has shipped. It keeps what it is composed of: its shape, its
+leaves, and the names of any parts. New structure arrives as a new type. An integration
+should skip a type it doesn't recognise, which is what happens when a site is on a newer
+Ghost than the package the integration was built with.
 
 ## Develop
 
-This is a workspace package in the Ghost monorepo. From the repo root:
+This is a workspace package in the Ghost monorepo. Adding a field type to Ghost is
+covered in [`docs/adding-a-field-type.md`](docs/adding-a-field-type.md). From the repo
+root:
 
 ```bash
 pnpm --filter @tryghost/metafield-types build   # compile to build/ with tsc (ESM)
@@ -49,9 +58,9 @@ imports in `src/` must carry an explicit extension; write the real `.ts` one —
 `import {x} from './x.ts'` — and `tsc` rewrites it to `.js` on emit
 (`rewriteRelativeImportExtensions`).
 
-`./structure` is the half of the catalog a renderer needs — which parts a field type
-has, and what each holds — and it stands apart from `./index` so that importing it
-costs a bundle almost nothing. The rules in `./index` are built on zod, some
+`./structure` is the half of the catalog a renderer needs, what each field type is
+composed of, and it stands apart from `./index` so that importing it costs a bundle
+almost nothing. The rules in `./index` are built on zod, some
 seventeen kilobytes gzipped that a renderer never runs. Portal imports `./structure`
 and loads on every page view of every themed site, so the difference reaches every
 visitor of every Ghost site.

package/build/identity.d.ts

@@ -1,36 +1,58 @@
+import * as z from 'zod/mini';
 /**
- * How a field is named on every surface that writes its name down as text: CSV column
- * headers, filter values, error paths, URLs.
+ * How a metafield is named, in the words every surface uses for it, and the checks that
+ * produce each word.
  *
- * The name is the namespace that declared the field and the field's key, joined by a
- * dot — `custom.company`. A value made of several parts, such as an address, appends
- * the part: `custom.shipping_address.country`. Splitting on dots by position is safe
- * because a key can never contain one; that is enforced where keys are minted.
+ * - A **namespace** is who declared the field: `custom` for the fields a site's own staff
+ *   define, and an app's own name for the fields it declares.
+ * - A **key** names the field within its namespace.
+ * - A **part** names one attribute of a record type's value, such as an address's
+ *   `country`. A record inside a record takes a part for each level.
+ * - An **identity** is the namespace, the key and any parts, in that order, joined by dots:
+ *   `custom.company` names a field, and `custom.shipping_address.country` one part of its
+ *   value.
  *
- * `metafields` is the qualifier, not part of the identity: it names the container, and
- * each context writes it exactly once — the payload key, the route prefix, the CSV
- * column prefix, the filter relation alias — never twice.
+ * Every one of them is a segment, and every segment follows the same rule: lowercase
+ * letters, digits and underscores. Filters, CSV columns, email replacement strings and
+ * themes all accept those and disagree about everything else. No segment can contain the
+ * dot, so an identity splits back into its segments by position.
+ *
+ * `metafields` is the qualifier, not part of an identity: it names the container, and each
+ * context writes it once, as the payload key, the route prefix, the CSV column prefix or the
+ * filter relation.
  */
 export declare const QUALIFIER = "metafields";
 export declare const SEPARATOR = ".";
+export declare const NamespaceSchema: z.core.$ZodBranded<z.ZodMiniString<string>, "Namespace", "out">;
+export type Namespace = z.infer<typeof NamespaceSchema>;
+export declare const KeySchema: z.core.$ZodBranded<z.ZodMiniString<string>, "Key", "out">;
+export type Key = z.infer<typeof KeySchema>;
+export declare const PartSchema: z.core.$ZodBranded<z.ZodMiniString<string>, "Part", "out">;
+export type Part = z.infer<typeof PartSchema>;
+/**
+ * An identity's segments, each checked. A field's own identity has no parts, so reading one
+ * whose segments arrive apart, such as a route's namespace and key, can leave `parts` out.
+ * What it reads always has them.
+ */
+export declare const IdentitySchema: z.ZodMiniObject<{
+    namespace: z.core.$ZodBranded<z.ZodMiniString<string>, "Namespace", "out">;
+    key: z.core.$ZodBranded<z.ZodMiniString<string>, "Key", "out">;
+    parts: z.ZodMiniDefault<z.ZodMiniArray<z.core.$ZodBranded<z.ZodMiniString<string>, "Part", "out">>>;
+}, z.core.$strip>;
+export type Identity = z.output<typeof IdentitySchema>;
+/** An identity read from its text, checking every segment, and written back to it. */
+export declare const IdentityTextSchema: z.ZodMiniCodec<z.ZodMiniString<string>, z.ZodMiniObject<{
+    namespace: z.core.$ZodBranded<z.ZodMiniString<string>, "Namespace", "out">;
+    key: z.core.$ZodBranded<z.ZodMiniString<string>, "Key", "out">;
+    parts: z.ZodMiniDefault<z.ZodMiniArray<z.core.$ZodBranded<z.ZodMiniString<string>, "Part", "out">>>;
+}, z.core.$strip>>;
 /**
  * The namespace holding the fields a site's own staff define.
  *
- * It is a constant only because the table storing these fields has no namespace
- * column: it holds this namespace's fields and nothing else, so the query layer has
- * to supply the name the rows implicitly carry. Nothing outside that layer should
- * compare against this value — a namespace nobody has declared fields in is an empty
- * namespace, not an error.
+ * Every field records its namespace, so reading and writing fields never needs this. It
+ * is for code that speaks only for the publisher's fields: who may define fields where,
+ * and the surfaces that name a publisher's field by key alone. Another namespace is not
+ * an error for not being this one: a namespace nobody has declared fields in is empty.
  */
-export declare const CUSTOM_NAMESPACE = "custom";
-export declare const IDENTITY_SEGMENT: RegExp;
-/** A formatted identity — `namespace.key`, or `namespace.key.partPath` for one part. */
-export type FieldIdentityString = string;
-export interface FieldIdentity {
-    namespace: string;
-    key: string;
-    partPath: string | null;
-}
-export declare function formatIdentity({ namespace, key, partPath }: FieldIdentity): FieldIdentityString;
-export declare function parseIdentity(identity: string): FieldIdentity | null;
+export declare const CUSTOM_NAMESPACE: string & z.$brand<"Namespace">;
 //# sourceMappingURL=identity.d.ts.map

package/build/identity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,SAAS,eAAe,CAAC;AAEtC,eAAO,MAAM,SAAS,MAAM,CAAC;AAE7B;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,WAAW,CAAC;AAEzC,eAAO,MAAM,gBAAgB,QAAiB,CAAC;AAE/C,wFAAwF;AACxF,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC;AAEzC,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,wBAAgB,cAAc,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE,aAAa,GAAG,mBAAmB,CAG/F;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAUpE"}
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,eAAO,MAAM,SAAS,eAAe,CAAC;AAEtC,eAAO,MAAM,SAAS,MAAM,CAAC;AAU7B,eAAO,MAAM,eAAe,iEAA4C,CAAC;AACzE,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,eAAO,MAAM,SAAS,2DAAgC,CAAC;AACvD,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AAE5C,eAAO,MAAM,UAAU,4DAAkC,CAAC;AAC1D,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;iBAIzB,CAAC;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC;AAEvD,sFAAsF;AACtF,eAAO,MAAM,kBAAkB;;;;kBAQ7B,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,gCAAkC,CAAC"}

package/build/identity.js

@@ -1,40 +1,63 @@
+import * as z from 'zod/mini';
 /**
- * How a field is named on every surface that writes its name down as text: CSV column
- * headers, filter values, error paths, URLs.
+ * How a metafield is named, in the words every surface uses for it, and the checks that
+ * produce each word.
  *
- * The name is the namespace that declared the field and the field's key, joined by a
- * dot — `custom.company`. A value made of several parts, such as an address, appends
- * the part: `custom.shipping_address.country`. Splitting on dots by position is safe
- * because a key can never contain one; that is enforced where keys are minted.
+ * - A **namespace** is who declared the field: `custom` for the fields a site's own staff
+ *   define, and an app's own name for the fields it declares.
+ * - A **key** names the field within its namespace.
+ * - A **part** names one attribute of a record type's value, such as an address's
+ *   `country`. A record inside a record takes a part for each level.
+ * - An **identity** is the namespace, the key and any parts, in that order, joined by dots:
+ *   `custom.company` names a field, and `custom.shipping_address.country` one part of its
+ *   value.
  *
- * `metafields` is the qualifier, not part of the identity: it names the container, and
- * each context writes it exactly once — the payload key, the route prefix, the CSV
- * column prefix, the filter relation alias — never twice.
+ * Every one of them is a segment, and every segment follows the same rule: lowercase
+ * letters, digits and underscores. Filters, CSV columns, email replacement strings and
+ * themes all accept those and disagree about everything else. No segment can contain the
+ * dot, so an identity splits back into its segments by position.
+ *
+ * `metafields` is the qualifier, not part of an identity: it names the container, and each
+ * context writes it once, as the payload key, the route prefix, the CSV column prefix or the
+ * filter relation.
  */
 export const QUALIFIER = 'metafields';
 export const SEPARATOR = '.';
+function segment(noun) {
+    return z.string().check(z.regex(/^[a-z0-9_]+$/, {
+        error: `A ${noun} can only contain lowercase letters, numbers and underscores.`,
+    }));
+}
+export const NamespaceSchema = segment('namespace').brand();
+export const KeySchema = segment('key').brand();
+export const PartSchema = segment('part').brand();
+/**
+ * An identity's segments, each checked. A field's own identity has no parts, so reading one
+ * whose segments arrive apart, such as a route's namespace and key, can leave `parts` out.
+ * What it reads always has them.
+ */
+export const IdentitySchema = z.object({
+    namespace: NamespaceSchema,
+    key: KeySchema,
+    parts: z._default(z.array(PartSchema), () => []),
+});
+/** An identity read from its text, checking every segment, and written back to it. */
+export const IdentityTextSchema = z.codec(z.string(), IdentitySchema, {
+    decode: (text) => {
+        const [namespace = '', key = '', ...parts] = text.split(SEPARATOR);
+        return { namespace, key, parts };
+    },
+    // Zod types the argument as what the schema reads, where `parts` can be left out, but `z.encode`
+    // refuses an identity without them before this runs.
+    encode: ({ namespace, key, parts = [] }) => [namespace, key, ...parts].join(SEPARATOR),
+});
 /**
  * The namespace holding the fields a site's own staff define.
  *
- * It is a constant only because the table storing these fields has no namespace
- * column: it holds this namespace's fields and nothing else, so the query layer has
- * to supply the name the rows implicitly carry. Nothing outside that layer should
- * compare against this value — a namespace nobody has declared fields in is an empty
- * namespace, not an error.
+ * Every field records its namespace, so reading and writing fields never needs this. It
+ * is for code that speaks only for the publisher's fields: who may define fields where,
+ * and the surfaces that name a publisher's field by key alone. Another namespace is not
+ * an error for not being this one: a namespace nobody has declared fields in is empty.
  */
-export const CUSTOM_NAMESPACE = 'custom';
-export const IDENTITY_SEGMENT = /^[a-z0-9_]+$/;
-export function formatIdentity({ namespace, key, partPath }) {
-    const identity = `${namespace}${SEPARATOR}${key}`;
-    return partPath ? `${identity}${SEPARATOR}${partPath}` : identity;
-}
-export function parseIdentity(identity) {
-    const [namespace, key, ...parts] = identity.split(SEPARATOR);
-    if (namespace === undefined ||
-        key === undefined ||
-        ![namespace, key, ...parts].every((segment) => IDENTITY_SEGMENT.test(segment))) {
-        return null;
-    }
-    return { namespace, key, partPath: parts.length > 0 ? parts.join(SEPARATOR) : null };
-}
+export const CUSTOM_NAMESPACE = NamespaceSchema.parse('custom');
 //# sourceMappingURL=identity.js.map

package/build/identity.js.map

@@ -1 +1 @@
-{"version":3,"file":"identity.js","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,YAAY,CAAC;AAEtC,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,CAAC;AAE7B;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,QAAQ,CAAC;AAEzC,MAAM,CAAC,MAAM,gBAAgB,GAAG,cAAc,CAAC;AAW/C,MAAM,UAAU,cAAc,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAiB;IACxE,MAAM,QAAQ,GAAG,GAAG,SAAS,GAAG,SAAS,GAAG,GAAG,EAAE,CAAC;IAClD,OAAO,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;AACpE,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,QAAgB;IAC5C,MAAM,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC7D,IACE,SAAS,KAAK,SAAS;QACvB,GAAG,KAAK,SAAS;QACjB,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAC9E,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;AACvF,CAAC"}
+{"version":3,"file":"identity.js","sourceRoot":"","sources":["../src/identity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,YAAY,CAAC;AAEtC,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,CAAC;AAE7B,SAAS,OAAO,CAAC,IAAY;IAC3B,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CACrB,CAAC,CAAC,KAAK,CAAC,cAAc,EAAE;QACtB,KAAK,EAAE,KAAK,IAAI,+DAA+D;KAChF,CAAC,CACH,CAAC;AACJ,CAAC;AAED,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,KAAK,EAAe,CAAC;AAGzE,MAAM,CAAC,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,KAAK,EAAS,CAAC;AAGvD,MAAM,CAAC,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,EAAU,CAAC;AAG1D;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,SAAS,EAAE,eAAe;IAC1B,GAAG,EAAE,SAAS;IACd,KAAK,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC;CACjD,CAAC,CAAC;AAGH,sFAAsF;AACtF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,cAAc,EAAE;IACpE,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;QACf,MAAM,CAAC,SAAS,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,EAAE,GAAG,KAAK,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACnE,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC;IACnC,CAAC;IACD,iGAAiG;IACjG,qDAAqD;IACrD,MAAM,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,KAAK,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;CACvF,CAAC,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,eAAe,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC"}