@tryghost/jsonapi-mapper 1.0.0

package/src/bookshelf/links.ts

@@ -0,0 +1,139 @@
+import { assign, omit, isEmpty, isNil } from 'lodash';
+import { pluralize as plural } from 'inflection';
+import { stringify as queryParams } from 'qs';
+
+import { Model } from './extras';
+import { LinkOpts, PagOpts, QueryOpts } from '../interfaces';
+import { LinkObj } from '../serializer';
+
+function urlConcat(...parts: string[]): string {
+  return parts.join('/');
+}
+
+/**
+ * Creates top level links object, for primary data and pagination links.
+ */
+export function topLinks(linkOpts: LinkOpts): LinkObj {
+  let { baseUrl, type, pag }: LinkOpts = linkOpts;
+
+  let obj: LinkObj = {
+    self: urlConcat(baseUrl, plural(type))
+  };
+
+  // Build pagination if available
+  if (!isNil(pag)) {
+
+    // Support Bookshelf's built-in paging parameters
+    if (!isNil(pag.rowCount)) {
+      pag.total = pag.rowCount;
+    }
+
+    // Only add pagination links when more than 1 page
+    if (!isNil(pag.total) && pag.total > 0 && pag.total > pag.limit) {
+      assign(obj, pagLinks(linkOpts));
+    }
+  }
+
+  return obj;
+}
+
+/**
+ * Create links object, for pagination links.
+ * Since its used only inside other functions in this model, its not exported
+ */
+function pagLinks(linkOpts: LinkOpts): LinkObj | undefined {
+  let { baseUrl, type, pag, query = {} }: LinkOpts = linkOpts;
+
+  if (pag === undefined) {
+    return undefined;
+  }
+
+  const { offset, limit, total}: PagOpts = pag;
+  // All links are based on the resource type
+  let baseLink: string = urlConcat(baseUrl, plural(type));
+
+  // Stringify the query string without page element
+  query = omit(query, ['page', 'page[limit]', 'page[offset]']) as QueryOpts;
+  baseLink = baseLink + '?' + queryParams(query, {encode: false});
+
+  let obj: LinkObj = {} as LinkObj;
+
+  // Add leading pag links if not at the first page
+  if (offset > 0) {
+    obj.first = () => {
+      let page: any = {page: {limit, offset: 0}};
+      return baseLink + queryParams(page, {encode: false});
+    };
+
+    obj.prev = () => {
+      let page: any = {page: {limit, offset: offset - limit}};
+      return baseLink + queryParams(page, {encode: false});
+    };
+  }
+
+  // Add trailing pag links if not at the last page
+  if (total && (offset + limit < total)) {
+    obj.next = () => {
+      let page: any = {page: {limit, offset: offset + limit}};
+      return baseLink + queryParams(page, {encode: false});
+    };
+
+    obj.last = () => {
+      // Avoiding overlapping with the penultimate page
+      let lastLimit: number = (total - (offset % limit)) % limit;
+      // If the limit fits perfectly in the total, reset it to the original
+      lastLimit = lastLimit === 0 ? limit : lastLimit;
+
+      let lastOffset: number = total - lastLimit;
+      let page: any = {page: {limit: lastLimit, offset: lastOffset }};
+      return baseLink + queryParams(page, {encode: false});
+    };
+  }
+
+  return !isEmpty(obj) ? obj : undefined;
+}
+
+/**
+ * Creates links object for a resource
+ */
+export function dataLinks(linkOpts: LinkOpts): LinkObj {
+  let { baseUrl, type }: LinkOpts = linkOpts;
+  let baseLink: string = urlConcat(baseUrl, plural(type));
+
+  return {
+    self: function(resource: Model): string {
+      return urlConcat(baseLink, resource.id);
+    }
+  };
+}
+
+/**
+ * Creates links object for a relationship
+ */
+export function relationshipLinks(linkOpts: LinkOpts, related: string): LinkObj {
+  let { baseUrl, type }: LinkOpts = linkOpts;
+  let baseLink: string = urlConcat(baseUrl, plural(type));
+
+  return {
+    self: function(resource: any, current: any, parent: Model): string {
+      return urlConcat(baseLink, parent.id, 'relationships', related);
+    },
+    related: function(resource: any, current: any, parent: Model): string {
+      return urlConcat(baseLink, parent.id, related);
+    }
+  };
+}
+
+/**
+ * Creates links object for a related resource, to be used for the included's array
+ */
+export function includedLinks(linkOpts: LinkOpts): LinkObj {
+  let { baseUrl, type }: LinkOpts = linkOpts;
+  let baseLink: string = urlConcat(baseUrl, plural(type));
+
+  return {
+    self: function(primary: Model, current: Model): string {
+      return urlConcat(baseLink, current.id);
+    }
+  };
+}

package/src/bookshelf/utils.ts

@@ -0,0 +1,279 @@
+/**
+ * The main purpose of this module is to provide utility functions
+ * that follows the restrictions of the Bookshelf/Mapper/Serializer APIs
+ * with the goal of simplifying the logic of the main 'map' method.
+ */
+
+import {
+  assign,
+  clone,
+  cloneDeep,
+  filter,
+  includes,
+  intersection,
+  isArray,
+  isNil,
+  isString,
+  isUndefined,
+  escapeRegExp,
+  forOwn,
+  has,
+  keys,
+  map,
+  mapValues,
+  merge,
+  omit,
+  reduce,
+  some,
+  toString,
+  update
+} from 'lodash';
+
+import { LinkOpts, RelationOpts } from '../interfaces';
+import { SerialOpts } from '../serializer';
+import { AttrMatcher, AttributesOpt } from '../interfaces';
+import { topLinks, dataLinks, relationshipLinks, includedLinks } from './links';
+import { BookOpts, Data, Model, isModel, isCollection } from './extras';
+
+/**
+ * Main structure used through most utility and recursive functions
+ */
+export interface Information {
+  bookOpts: BookOpts;
+  linkOpts: LinkOpts;
+}
+
+/**
+ * Start the data processing with top level information,
+ * then handle resources recursively in processSample
+ */
+export function processData(info: Information, data: Data): SerialOpts {
+  let { bookOpts: { enableLinks }, linkOpts }: Information = info;
+
+  let template: SerialOpts = processSample(info, sample(data));
+
+  if (enableLinks) {
+    template.dataLinks = dataLinks(linkOpts);
+    template.topLevelLinks = topLinks(linkOpts);
+  }
+
+  return template;
+}
+
+/**
+ * Recursively adds data-related properties to the
+ * template to be sent to the serializer
+ */
+function processSample(info: Information, sample: Sample): SerialOpts {
+  let { bookOpts, linkOpts }: Information = info;
+  let { enableLinks }: BookOpts = bookOpts;
+
+  let template: SerialOpts = {
+    // Add list of valid attributes
+    attributes: getAttrsList(sample, bookOpts)
+  };
+
+  // Nested relations (recursive) template generation
+  forOwn(sample.relations, (relSample: Sample, relName: string): void => {
+    if (!relationAllowed(bookOpts, relName)) { return; }
+
+    let relLinkOpts: LinkOpts = assign(clone(linkOpts), {type: relName});
+    let relTemplate: SerialOpts = processSample({bookOpts, linkOpts: relLinkOpts}, relSample);
+    relTemplate.ref = 'id'; // Add reference in nested resources
+
+    // Related links
+    if (enableLinks) {
+      relTemplate.relationshipLinks = relationshipLinks(linkOpts, relName);
+      relTemplate.includedLinks = includedLinks(relLinkOpts);
+    }
+
+    // Include links as compound document
+    if (!includeAllowed(bookOpts, relName)) {
+        relTemplate.included = false;
+    }
+
+    template[relName] = relTemplate;
+    (template.attributes as string[]).push(relName);
+  });
+
+  return template;
+}
+
+/**
+ * Representation of a sample, a model with only models in the relations,
+ * no collections
+ */
+interface Sample extends Model {
+  relations: {
+    [relationName: string]: Sample
+  };
+}
+
+/**
+ * Convert any data into a model representing
+ * a complete sample to be used in the template generation
+ */
+function sample(data: Data): Sample {
+  if (isModel(data)) {
+    // Override type because we will overwrite relations
+    const sampled: Sample = cloneDeep(omit(data, 'relations')) as Sample;
+    sampled.relations = mapValues(data.relations, sample);
+
+    return sampled;
+  } else if (isCollection(data)) {
+    const first: Model = data.first();
+    const rest: Model[] = (<Model[]><unknown> data).slice(1);
+    return reduce(rest, mergeSample, sample(first));
+  } else {
+    return {} as Sample;
+  }
+}
+
+/**
+ * Merge two models into a representation of both
+ */
+function mergeSample(main: Sample, toMerge: Model): Sample {
+  const sampled: Sample = sample(toMerge);
+  main.attributes = merge(main.attributes, sampled.attributes);
+  main.relations = merge(main.relations, sampled.relations);
+  return main;
+}
+
+function matches(matcher: AttrMatcher, str: string): boolean {
+  let reg: RegExp;
+
+  if (typeof matcher === 'string') {
+    reg = RegExp(`^${escapeRegExp(matcher)}$`);
+  } else {
+    reg = matcher;
+  }
+
+  return reg.test(str);
+}
+/**
+ * Retrieve model's attribute names
+ * following filtering rules
+ */
+function getAttrsList(data: Model, bookOpts: BookOpts): string[] {
+  let idAttr: undefined | string | string[] = data.idAttribute;
+  if (isString(idAttr)) {
+    idAttr = [ idAttr ];
+  } else if (isUndefined(idAttr)) {
+    idAttr = [];
+  }
+
+  let attrs: string[] = keys(data.attributes);
+  let outputVirtuals = data.outputVirtuals;
+
+  if (!isNil(bookOpts.outputVirtuals)) {
+    outputVirtuals = bookOpts.outputVirtuals
+  }
+
+  if (data.virtuals && outputVirtuals) {
+    attrs = attrs.concat(keys(data.virtuals))
+  }
+
+  let { attributes = { omit: idAttr } }: BookOpts = bookOpts;
+
+  // cast it to the object version of the option
+  if (attributes instanceof Array) {
+    attributes = { include : attributes };
+  }
+  let { omit, include }: AttributesOpt = attributes;
+
+  return filter(attrs, (attr: string) => {
+    let included: boolean = true;
+    let omitted: boolean = false;
+
+    if (include) {
+      included = some(include, (m: AttrMatcher) => matches(m, attr));
+    }
+
+    if (omit) {
+      omitted = some(omit, (m: AttrMatcher) => matches(m, attr));
+    }
+
+    // `omit` has more precedence than `include` option
+    return ! omitted && included;
+  });
+}
+
+/**
+ * Based on Bookshelf options, determine if a relation must be included
+ */
+function relationAllowed(bookOpts: BookOpts, relName: string): boolean {
+  let { relations }: BookOpts = bookOpts;
+
+  if (typeof relations === 'boolean') {
+    return relations;
+  } else {
+    let { fields }: RelationOpts = relations;
+    return ! fields || includes(fields, relName);
+  }
+}
+
+/**
+ * Based on Bookshelf options, determine if a relation must be included
+ */
+function includeAllowed(bookOpts: BookOpts, relName: string): boolean {
+  let { relations }: BookOpts = bookOpts;
+
+  if (typeof relations === 'boolean') {
+    return relations;
+  } else {
+    let { fields, included }: RelationOpts = relations;
+
+    if (typeof included === 'boolean') {
+      return included;
+    } else {
+      // If included is an array, only allow relations that are in that array
+      let allowed: string[] = included;
+
+      if (fields) {
+        // If fields specified, ensure that the included relations
+        // are listed as one of the relations to be serialized
+        allowed = intersection(fields, included);
+      }
+
+      return includes(allowed, relName);
+    }
+  }
+}
+
+/**
+ * Convert a bookshelf model or collection to
+ * json adding the id attribute if missing
+ */
+export function toJSON(data: Data): any {
+
+  let json: any = null;
+
+  if (isModel(data)) {
+    json = data.toJSON({shallow: true}); // serialize without the relations
+
+    // When idAttribute is a composite id, calling .id returns `undefined`
+    const idAttr: undefined | string | string[] = data.idAttribute;
+    if (isArray(idAttr)) {
+      // the id will be the values in order separated by comma
+      data.id = map(idAttr, (attr: string) => data.attributes[attr]).join(',');
+    }
+
+    // Assign the id for the model if it's not present already
+    if (! has(json, 'id')) {
+      json.id = data.id;
+    }
+
+    update(json, 'id', toString);
+
+    // Loop over model relations to call toJSON recursively on them
+    forOwn(data.relations, function (relData: Data, relName: string): void {
+      json[relName] = toJSON(relData);
+    });
+
+  } else if (isCollection(data)) {
+    // Run a recursive toJSON on each model of the collection
+    json = data.map(toJSON);
+  }
+
+  return json;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './bookshelf';
+export * from './interfaces';
+export * from './serializer';

package/src/interfaces/common.ts

@@ -0,0 +1,38 @@
+import { PagOpts, QueryOpts } from './links';
+import { RelationTypeOpt, RelationOpts } from './relations';
+
+//// GENERAL INTERFACES FOR MAPPERS
+
+// Mapper
+export interface Mapper {
+  map(data: any, type: string, mapOpts?: MapOpts): any;
+}
+
+export type AttrMatcher = RegExp | string;
+
+export type AttributesOpt = {
+  omit?: AttrMatcher[],
+  include?: AttrMatcher[]
+};
+
+// Mapper Options
+export interface MapOpts {
+  // Attributes-related
+  attributes?: AttrMatcher[] | AttributesOpt;
+  keyForAttr?: (attr: string) => string;
+
+  // Relations-related
+  relations?: boolean | RelationOpts;
+  typeForModel?: RelationTypeOpt;
+
+  // Links-related
+  enableLinks?: boolean;
+  pagination?: PagOpts;
+  query?: QueryOpts;
+
+  // Meta-related
+  meta?: { [key:string]: any };
+
+  // Virtuals-related
+  outputVirtuals?: boolean;
+}

package/src/interfaces/index.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './links';
+export * from './relations';

package/src/interfaces/links.ts

@@ -0,0 +1,26 @@
+/**
+ * Query Parameters map
+ */
+export interface QueryOpts {
+  [key: string]: string;
+}
+
+/**
+ * Pagination variables
+ */
+export interface PagOpts {
+  offset: number;
+  limit: number;
+  total?: number;
+  rowCount?: number;
+}
+
+/**
+ * Data required to form links
+ */
+export interface LinkOpts {
+  baseUrl: string;
+  type: string;
+  pag?: PagOpts;
+  query?: QueryOpts;
+}

package/src/interfaces/relations.ts

@@ -0,0 +1,24 @@
+/**
+ * Map to specify type for the passed relations
+ */
+export interface RelationTypeMap {
+  [relationName: string]: string;
+}
+
+/**
+ * Function to pass directly as the typeForAttributes option to the serializer
+ */
+export type RelationTypeFunction = (attribute: string) => string;
+
+/**
+ * The relationTypes option can be a function or an object
+ */
+export type RelationTypeOpt = RelationTypeMap | RelationTypeFunction;
+
+/**
+ * Relationship options
+ */
+export interface RelationOpts {
+    included: boolean | string[];
+    fields?: string[];
+}

package/src/serializer/index.ts

@@ -0,0 +1,50 @@
+import * as jas from 'jsonapi-serializer';
+
+export type LinkFunc = (primary: any, related?: any, parent?: any) => string;
+
+export type Link = string | LinkFunc;
+
+export interface LinkObj {
+  self?: Link;
+  related?: Link;
+
+  first?: Link;
+  last?: Link;
+
+  prev?: Link;
+  next?: Link;
+}
+
+export interface SerialOpts {
+  attributes?: string[];
+  ref?: string;
+  included?: boolean;
+
+  topLevelLinks?: LinkObj;
+  dataLinks?: LinkObj;
+  relationshipLinks?: LinkObj;
+  includedLinks?: LinkObj;
+
+  relationshipMeta?: any;
+  ignoreRelationshipData?: boolean;
+
+  keyForAttribute?: (attribute: any) => string;
+  typeForAttribute?: (attribute: any) => any;
+  pluralizeType?: boolean;
+
+  meta?: any;
+
+  // TODO improve type-checking of relationship options
+  [relationships: string]: any;
+}
+
+export interface SerializerCtor {
+  new(type: string, opts: SerialOpts): Serializer;
+}
+
+export interface Serializer {
+  serialize(data: any): any;
+}
+
+// tslint:disable-next-line variable-name
+export let Serializer: SerializerCtor = jas.Serializer;

package/src/serializer/jsonapi-serializer.skel.d.ts

@@ -0,0 +1,4 @@
+declare module 'jsonapi-serializer' {
+  const content: any;
+  export = content;
+}

package/types/bookshelf/extras.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The purpose of this module is to extend the initially defined properties,
+ * behaviors and characteristics of the bookshelf API
+ */
+import { Model as BModel, Collection as BCollection } from 'bookshelf';
+import { MapOpts, RelationTypeOpt, RelationOpts } from '../interfaces';
+export interface BookOpts extends MapOpts {
+    keyForAttr: (attr: string) => string;
+    relations: boolean | RelationOpts;
+    typeForModel: RelationTypeOpt;
+    enableLinks: boolean;
+    outputVirtuals?: boolean;
+}
+/**
+ * Internal form of the relations property of bookshelf objects
+ */
+export interface RelationsObject {
+    [relationName: string]: Data;
+}
+export interface Attributes {
+    [attrName: string]: any;
+}
+/**
+ * Bookshelf Model including some private properties
+ */
+export interface Model extends BModel<any> {
+    id: any;
+    idAttribute: any;
+    attributes: Attributes;
+    relations: RelationsObject;
+    virtuals?: any;
+    outputVirtuals?: boolean;
+}
+/**
+ * Bookshelf Collection including some private properties
+ */
+export interface Collection extends BCollection<any> {
+    models: Model[];
+    length: number;
+}
+export type Data = Model | Collection;
+/**
+ * Bookshelf Model Type Guard
+ * https://basarat.gitbooks.io/typescript/content/docs/types/typeGuard.html
+ */
+export declare function isModel(data: Data): data is Model;
+/**
+ * Bookshelf Collection Type Guard
+ * https://basarat.gitbooks.io/typescript/content/docs/types/typeGuard.html
+ */
+export declare function isCollection(data: Data): data is Collection;
+//# sourceMappingURL=extras.d.ts.map

package/types/bookshelf/extras.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extras.d.ts","sourceRoot":"","sources":["../../src/bookshelf/extras.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,IAAI,MAAM,EAAE,UAAU,IAAI,WAAW,EAAE,MAAM,WAAW,CAAC;AACvE,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAGvE,MAAM,WAAW,QAAS,SAAQ,OAAO;IAEvC,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAGrC,SAAS,EAAE,OAAO,GAAG,YAAY,CAAC;IAClC,YAAY,EAAE,eAAe,CAAC;IAG9B,WAAW,EAAE,OAAO,CAAC;IAGrB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,UAAU;IACzB,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,KAAM,SAAQ,MAAM,CAAC,GAAG,CAAC;IACxC,EAAE,EAAE,GAAG,CAAC;IAIR,WAAW,EAAE,GAAG,CAAC;IAEjB,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,EAAE,eAAe,CAAC;IAC3B,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,WAAW,CAAC,GAAG,CAAC;IAClD,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,UAAU,CAAC;AAEtC;;;GAGG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,KAAK,CAEjD;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,IAAI,UAAU,CAG3D"}

package/types/bookshelf/index.d.ts

@@ -0,0 +1,22 @@
+import { SerialOpts } from '../serializer';
+import { Mapper, MapOpts } from '../interfaces';
+import { Data } from './extras';
+/**
+ * Mapper class for Bookshelf sources
+ */
+export declare class Bookshelf implements Mapper {
+    baseUrl: string;
+    serialOpts?: SerialOpts | undefined;
+    /**
+     * Standard constructor
+     */
+    constructor(baseUrl: string, serialOpts?: SerialOpts | undefined);
+    /**
+     * Maps bookshelf data to a JSON-API 1.0 compliant object
+     *
+     * The `any` type data source is set for typing compatibility, but must be removed if possible
+     * TODO fix data any type
+     */
+    map(data: Data | any, type: string, mapOpts?: MapOpts): any;
+}
+//# sourceMappingURL=index.d.ts.map

package/types/bookshelf/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bookshelf/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAc,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAY,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,IAAI,EAAY,MAAM,UAAU,CAAC;AAG1C;;GAEG;AACH,qBAAa,SAAU,YAAW,MAAM;IAKnB,OAAO,EAAE,MAAM;IAAS,UAAU,CAAC,EAAE,UAAU;IAHlE;;OAEG;gBACgB,OAAO,EAAE,MAAM,EAAS,UAAU,CAAC,EAAE,UAAU,YAAA;IAElE;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,OAAY,GAAG,GAAG;CAuChE"}

package/types/bookshelf/links.d.ts

@@ -0,0 +1,19 @@
+import { LinkOpts } from '../interfaces';
+import { LinkObj } from '../serializer';
+/**
+ * Creates top level links object, for primary data and pagination links.
+ */
+export declare function topLinks(linkOpts: LinkOpts): LinkObj;
+/**
+ * Creates links object for a resource
+ */
+export declare function dataLinks(linkOpts: LinkOpts): LinkObj;
+/**
+ * Creates links object for a relationship
+ */
+export declare function relationshipLinks(linkOpts: LinkOpts, related: string): LinkObj;
+/**
+ * Creates links object for a related resource, to be used for the included's array
+ */
+export declare function includedLinks(linkOpts: LinkOpts): LinkObj;
+//# sourceMappingURL=links.d.ts.map

package/types/bookshelf/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../src/bookshelf/links.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAsB,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAMxC;;GAEG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAsBpD;AA0DD;;GAEG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CASrD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAY9E;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CASzD"}