soukai-bis 0.0.0-next.644ab9a2b8f38acac0b1af7fdd2c32dac992efb8 → 0.0.0-next.6ae0e13a5d51cb0b555c0f6a877b441cf081731e

package/dist/soukai-bis.d.ts

@@ -1,11 +1,25 @@
 import { Constructor } from '@noeldemartin/utils';
+import { Fetch } from '@noeldemartin/solid-utils';
+import { JSError } from '@noeldemartin/utils';
+import { JSErrorOptions } from '@noeldemartin/utils';
 import { JsonLD } from '@noeldemartin/solid-utils';
 import { MagicObject } from '@noeldemartin/utils';
 import { NamedNode } from '@rdfjs/types';
+import { Override } from '@noeldemartin/utils';
 import { z } from 'zod';
 import { ZodObject } from 'zod';
 import { ZodType } from 'zod';
 
+export declare type BootedModelClass<T extends typeof Model> = T & {
+    _collection: string;
+    _modelName: string;
+};
+
+export declare function bootModels(models: Record<string, {
+    boot(name: string): unknown;
+    reset(): void;
+}>, reset?: boolean): void;
+
 declare namespace coreExtensions {
     export {
         rdfProperty,
@@ -17,27 +31,102 @@ declare interface CustomMeta {
     rdfProperty?: string;
 }
 
-export declare function defineSchema<T extends SchemaFields>(config: SchemaConfig<T>): SchemaModel<T>;
+export declare function defineSchema<T extends SchemaFields>(config: SchemaConfig<T>): SchemaModelClass<T>;
+
+export declare class DocumentAlreadyExists extends SoukaiError {
+    readonly url: string;
+    constructor(url: string);
+}
+
+export declare interface Engine {
+    createDocument(url: string, graph: JsonLD): Promise<void>;
+    updateDocument(url: string, graph: JsonLD, dirtyAttributes?: string[]): Promise<void>;
+    readManyDocuments(containerUrl: string): Promise<Record<string, JsonLD>>;
+}
+
+export declare function getEngine(): Engine | undefined;
 
-export declare class Model extends MagicObject {
+export declare class IndexedDBEngine implements Engine {
+    private database;
+    private metadataConnection;
+    private documentsConnection;
+    private lock;
+    constructor(database?: string);
+    close(): Promise<void>;
+    createDocument(url: string, graph: JsonLD): Promise<void>;
+    updateDocument(url: string, graph: JsonLD): Promise<void>;
+    readManyDocuments(containerUrl: string): Promise<Record<string, JsonLD>>;
+    private createCollection;
+    private collectionExists;
+    private getCollections;
+    private withMetadataTransaction;
+    private withDocumentsTransaction;
+    private getMetadataConnection;
+    private getDocumentsConnection;
+}
+
+export declare class InMemoryEngine implements Engine {
+    documents: Record<string, JsonLD>;
+    createDocument(url: string, graph: JsonLD): Promise<void>;
+    updateDocument(url: string, graph: JsonLD): Promise<void>;
+    readManyDocuments(containerUrl: string): Promise<Record<string, JsonLD>>;
+}
+
+export declare type MintedModel<T> = T & {
+    url: string;
+};
+
+export declare class Model<Attributes extends Record<string, unknown> = Record<string, unknown>, Field extends string = Exclude<keyof Attributes, number | symbol>> extends MagicObject {
     static schema: Schema;
+    protected static _collection?: string;
+    protected static _modelName?: string;
+    private static __booted;
+    static get collection(): string;
+    static get modelName(): string;
+    static boot<T extends typeof Model>(this: T, name?: string): void;
+    static reset(): void;
+    static newInstance<T extends Model>(this: ModelConstructor<T>, ...params: ConstructorParameters<ModelConstructor<T>>): T;
+    static all<T extends Model>(this: ModelConstructor<T>, containerUrl: string): Promise<MintedModel<T>[]>;
+    static create<T extends Model>(this: ModelConstructor<T>, ...args: ConstructorParameters<ModelConstructor<T>>): Promise<MintedModel<T>>;
+    static createFromJsonLD<T extends Model>(this: ModelConstructor<T>, json: JsonLD, options?: {
+        url?: string;
+    }): Promise<MintedModel<T> | null>;
     static<T extends typeof Model>(): T;
     static<T extends typeof Model, K extends keyof T>(property: K): T[K];
+    private static booted;
     url?: string;
+    private __exists;
     private __attributes;
-    constructor(attributes?: Record<string, unknown>);
-    getAttributes(): Record<string, unknown>;
+    private __dirtyAttributes;
+    constructor(attributes?: Record<string, unknown>, exists?: boolean);
+    getAttributes(): Attributes;
+    isDirty(field?: Field): boolean;
+    exists(): boolean;
+    setExists(exists: boolean): void;
+    save(): Promise<MintedModel<this>>;
+    update(attributes: Partial<Attributes>): Promise<MintedModel<this>>;
     toJsonLD(): Promise<JsonLD>;
     toTurtle(): Promise<string>;
     protected __get(property: string): unknown;
+    protected __set(property: string, value: unknown): void;
+    protected mintUrl(): string;
+    private parseAttribute;
+    private parseAttributes;
+    private isField;
 }
 
+export declare type ModelConstructor<T extends Model = Model> = Constructor<T> & Omit<typeof Model, 'new'>;
+
+export declare type ModelInstanceType<T> = T extends Constructor<infer TInstance> ? TInstance : never;
+
 export declare function patchZod(): void;
 
 declare function rdfProperty<T extends ZodType>(this: T): string | undefined;
 
 declare function rdfProperty<T extends ZodType>(this: T, value: string): T;
 
+export declare function requireEngine(): Engine;
+
 export declare type Schema<T extends SchemaFields = SchemaFields> = {
     fields: ZodObject<T>;
     rdfContext: {
@@ -45,7 +134,7 @@ export declare type Schema<T extends SchemaFields = SchemaFields> = {
     } & Record<string, string>;
     rdfClasses: NamedNode[];
     rdfDefaultResourceHash: string;
-    rdfFieldProperties: Record<string, NamedNode>;
+    rdfFieldProperties: Record<keyof T, NamedNode>;
 };
 
 export declare interface SchemaConfig<T extends SchemaFields> {
@@ -59,7 +148,38 @@ export declare interface SchemaConfig<T extends SchemaFields> {
 
 export declare type SchemaFields = Record<string, ZodType>;
 
-export declare type SchemaModel<T extends SchemaFields> = typeof Model & Constructor<z.infer<ZodObject<T>>>;
+export declare type SchemaModel<T extends SchemaFields = SchemaFields> = Model<SchemaModelAttributes<T>> & z.infer<ZodObject<T>>;
+
+export declare type SchemaModelAttributes<T extends SchemaFields = SchemaFields> = z.infer<ZodObject<T>> & {
+    url?: string;
+};
+
+export declare type SchemaModelClass<T extends SchemaFields = SchemaFields> = Override<typeof Model, {
+    new (attributes?: SchemaModelInput<T>, exists?: boolean): SchemaModel<T>;
+    newInstance<This>(this: This, attributes?: SchemaModelInput<T>, exists?: boolean): ModelInstanceType<This>;
+    create<This>(this: This, attributes?: SchemaModelInput<T>): Promise<MintedModel<ModelInstanceType<This>>>;
+    createFromJsonLD<This>(this: This, json: JsonLD, options?: {
+        url?: string;
+    }): Promise<MintedModel<ModelInstanceType<This>> | null>;
+}>;
+
+export declare type SchemaModelInput<T extends SchemaFields = SchemaFields> = z.input<ZodObject<T>> & {
+    url?: string;
+};
+
+export declare function setEngine(engine: Engine): void;
+
+export declare class SolidEngine implements Engine {
+    private client;
+    constructor(fetch?: Fetch);
+    createDocument(url: string, graph: JsonLD): Promise<void>;
+    updateDocument(url: string, graph: JsonLD, dirtyProperties?: string[]): Promise<void>;
+    readManyDocuments(containerUrl: string): Promise<Record<string, JsonLD>>;
+}
+
+export declare class SoukaiError extends JSError {
+    constructor(message?: string, options?: JSErrorOptions);
+}
 
 export declare type ZodCoreExtensions = typeof coreExtensions;
 

package/dist/soukai-bis.js

@@ -1,103 +1,368 @@
-var j = Object.defineProperty;
-var x = (t, r, e) => r in t ? j(t, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[r] = e;
-var f = (t, r, e) => x(t, typeof r != "symbol" ? r + "" : r, e);
-import { ZodArray as C, ZodURL as R, ZodOptional as m, ZodDefault as b, object as P, z as F } from "zod";
-import { MagicObject as O } from "@noeldemartin/utils";
-import { expandIRI as c, RDFNamedNode as u, RDFQuad as p, RDFLiteral as w, quadsToJsonLD as g, quadsToTurtle as Z } from "@noeldemartin/solid-utils";
-const A = c("rdf:type");
-function d(t) {
-  return t instanceof m || t instanceof b ? d(t.def.innerType) : t;
-}
-function _(t, r) {
-  const e = d(r);
-  return e instanceof C ? (Array.isArray(t) ? t : t == null ? [] : [t]).flatMap((s) => _(s, e.def.element)) : e instanceof R ? [new u(String(t))] : [new w(String(t))];
-}
-function h(t) {
-  const { fields: r, rdfDefaultResourceHash: e, rdfClasses: n, rdfFieldProperties: s } = t.static().schema, i = new u(t.url ?? `#${e}`), o = [];
-  for (const a of n)
-    o.push(new p(i, A, a));
-  for (const [a, y] of Object.entries(t.getAttributes()))
-    for (const D of _(y, r.def.shape[a]))
-      o.push(new p(i, s[a], D));
+var J = Object.defineProperty;
+var Z = (n, e, t) => e in n ? J(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var c = (n, e, t) => Z(n, typeof e != "symbol" ? e + "" : e, t);
+import { ZodOptional as P, ZodDefault as R, ZodArray as I, ZodNumber as q, ZodURL as z, object as B, url as Q, z as U } from "zod";
+import { JSError as V, fail as L, required as H, MagicObject as W, stringToCamelCase as A, objectOnly as Y, uuid as G, Semaphore as K, requireUrlParentDirectory as E, reduceBy as X } from "@noeldemartin/utils";
+import { expandIRI as h, RDFNamedNode as f, SolidStore as tt, RDFQuad as O, RDFLiteral as et, jsonldToQuads as C, quadsToJsonLD as M, quadsToTurtle as m, SolidClient as nt } from "@noeldemartin/solid-utils";
+import { openDB as N } from "idb";
+function mt(n, e = !1) {
+  for (const [t, s] of Object.entries(n))
+    e && s.reset(), s.boot(t);
+}
+class T extends V {
+  constructor(e, t) {
+    super(e, t);
+  }
+}
+let j;
+function _t(n) {
+  j = n;
+}
+function bt() {
+  return j;
+}
+function D() {
+  return j ?? L(T, "Default engine hasn't been initialized");
+}
+const st = h("ldp:BasicContainer"), it = h("ldp:Container"), at = h("ldp:contains"), p = h("rdf:type");
+function b(n) {
+  return n instanceof P || n instanceof R ? b(n.def.innerType) : n;
+}
+function S(n, e) {
+  return e instanceof q ? Number(n) : n;
+}
+function ot(n, e, t) {
+  const { fields: s, rdfFieldProperties: i } = n.schema, a = new f(e), o = {}, r = new tt(t);
+  for (const [d, u] of Object.entries(s.shape)) {
+    const l = b(u), w = i[d], y = r.statements(a, w);
+    if (!(!w || y.length === 0)) {
+      if (l instanceof I) {
+        const $ = b(l.element);
+        o[d] = y.map((k) => S(k.object.value, $));
+        continue;
+      }
+      o[d] = S(H(y[0]).object.value, l);
+    }
+  }
+  return n.newInstance({ url: e, ...o }, !0);
+}
+function v(n, e) {
+  const t = b(e);
+  return t instanceof I ? (Array.isArray(n) ? n : n == null ? [] : [n]).flatMap((i) => v(i, t.def.element)) : t instanceof z ? [new f(String(n))] : [new et(String(n))];
+}
+function F(n) {
+  const { fields: e, rdfDefaultResourceHash: t, rdfClasses: s, rdfFieldProperties: i } = n.static().schema, a = new f(n.url ?? `#${t}`), o = [];
+  for (const r of s)
+    o.push(new O(a, p, r));
+  for (const [r, d] of Object.entries(n.getAttributes())) {
+    const u = e.def.shape[r], l = i[r];
+    if (!(!u || !l))
+      for (const w of v(d, u))
+        o.push(new O(a, l, w));
+  }
   return o;
 }
-class T extends O {
-  constructor(e = {}) {
+class _ extends W {
+  constructor(t = {}, s = !1) {
     super();
-    f(this, "__attributes");
+    c(this, "__exists", !1);
+    c(this, "__attributes");
+    c(this, "__dirtyAttributes", /* @__PURE__ */ new Set());
     if (this.static().isConjuring()) {
       this.__attributes = {};
       return;
     }
-    this.__attributes = this.static().schema.fields.parse(e);
+    this.__exists = s, this.__attributes = this.parseAttributes(t);
+  }
+  static get collection() {
+    return this._collection ?? this.booted()._collection;
+  }
+  static get modelName() {
+    return this._modelName ?? this.booted()._modelName;
+  }
+  static boot(t) {
+    if (this.__booted)
+      throw new T(`${this.name} model already booted`);
+    this._modelName ?? (this._modelName = t ?? this.name), this._collection ?? (this._collection = `solid://${A(this._modelName)}s/`), this.__booted = !0;
   }
-  static(e) {
-    return super.static(e);
+  static reset() {
+    this.__booted = !1;
+  }
+  static newInstance(...t) {
+    return new this(...t);
+  }
+  static async all(t) {
+    const i = await D().readManyDocuments(t);
+    return (await Promise.all(
+      Object.entries(i).map(([o, r]) => this.createFromJsonLD(r, { url: o }))
+    )).filter((o) => o !== null);
+  }
+  static async create(...t) {
+    return new this(...t).save();
+  }
+  static async createFromJsonLD(t, s = {}) {
+    const i = s.url ?? t["@id"] ?? L("JsonLD is missing @id"), a = await C(t), o = new f(i), r = (d) => a.some(
+      (u) => u.subject.value === o.value && u.predicate.value === p && u.object.value === d.value
+    );
+    return this.schema.rdfClasses.some(r) ? ot(this, i, a) : null;
+  }
+  static(t) {
+    return super.static(t);
+  }
+  static booted() {
+    return this.__booted || (this._modelName ?? (this._modelName = this.name), this._collection ?? (this._collection = `solid://${A(this._modelName)}s/`), this.__booted = !0), this;
   }
   getAttributes() {
     return this.__attributes;
   }
+  isDirty(t) {
+    return t ? this.__dirtyAttributes.has(t) : this.__dirtyAttributes.size > 0;
+  }
+  exists() {
+    return this.__exists;
+  }
+  setExists(t) {
+    this.__exists = t;
+  }
+  async save() {
+    this.url ?? (this.url = this.mintUrl());
+    const t = await this.toJsonLD();
+    if (this.__exists) {
+      const s = Array.from(this.__dirtyAttributes).map((i) => {
+        var a;
+        return (a = this.static().schema.rdfFieldProperties[i]) == null ? void 0 : a.value;
+      }).filter((i) => !!i);
+      await D().updateDocument(this.url, t, s);
+    } else
+      await D().createDocument(this.url, t), this.__exists = !0;
+    return this.__dirtyAttributes.clear(), this;
+  }
+  update(t) {
+    const s = Y(this.static().schema.fields.def.shape, Object.keys(t)), i = Object.fromEntries(
+      Object.entries(s).map(([a, o]) => [a, o.parse(t[a])])
+    );
+    return Object.assign(this.__attributes, i), Object.keys(i).forEach((a) => this.__dirtyAttributes.add(a)), this.save();
+  }
   async toJsonLD() {
-    return g(h(this));
+    return M(F(this));
   }
   async toTurtle() {
-    return Z(h(this));
-  }
-  __get(e) {
-    return this.__attributes[e];
-  }
-}
-f(T, "schema");
-function V(t) {
-  var s;
-  const r = t.rdfContext ? { default: t.rdfContext } : { default: "solid" }, { default: e, ...n } = r;
-  return s = class extends T {
-  }, f(s, "schema", {
-    fields: P(t.fields),
-    rdfContext: r,
-    rdfDefaultResourceHash: t.rdfDefaultResourceHash ?? "it",
-    rdfClasses: t.rdfClass ? [
-      new u(
-        c(t.rdfClass, {
-          defaultPrefix: e,
-          extraContext: n
+    return m(F(this));
+  }
+  __get(t) {
+    return this.__attributes[t];
+  }
+  __set(t, s) {
+    this.isField(t) && (this.__attributes[t] = this.parseAttribute(t, s), this.__dirtyAttributes.add(t));
+  }
+  mintUrl() {
+    return `${this.static().collection}${G()}`;
+  }
+  parseAttribute(t, s) {
+    var i;
+    return (i = this.static().schema.fields.def.shape[t]) == null ? void 0 : i.parse(s);
+  }
+  parseAttributes(t) {
+    return this.static().schema.fields.parse(t);
+  }
+  isField(t) {
+    return t in this.static().schema.fields.def.shape;
+  }
+}
+c(_, "schema"), c(_, "_collection"), c(_, "_modelName"), c(_, "__booted", !1);
+function wt(n) {
+  var i;
+  const e = n.rdfContext ? { default: n.rdfContext } : { default: "solid" }, { default: t, ...s } = e;
+  return i = class extends _ {
+  }, c(i, "schema", {
+    fields: B(n.fields).extend({ url: Q().optional() }),
+    rdfContext: e,
+    rdfDefaultResourceHash: n.rdfDefaultResourceHash ?? "it",
+    rdfClasses: n.rdfClass ? [
+      new f(
+        h(n.rdfClass, {
+          defaultPrefix: t,
+          extraContext: s
         })
       )
     ] : [],
     rdfFieldProperties: Object.fromEntries(
-      Object.entries(t.fields).map(([i, o]) => [
-        i,
-        new u(
-          c(o.rdfProperty() ?? i, {
-            defaultPrefix: e,
-            extraContext: n
+      Object.entries(n.fields).map(([a, o]) => [
+        a,
+        new f(
+          h(o.rdfProperty() ?? a, {
+            defaultPrefix: t,
+            extraContext: s
           })
         )
       ])
     )
-  }), s;
+  }), i;
+}
+class x extends T {
+  constructor(t) {
+    super(`Could not create document with url '${t}' because it is already in use.`);
+    c(this, "url");
+    this.url = t;
+  }
+}
+class pt {
+  constructor(e = "soukai-bis") {
+    c(this, "database");
+    c(this, "metadataConnection", null);
+    c(this, "documentsConnection", null);
+    c(this, "lock");
+    this.database = e, this.lock = new K();
+  }
+  async close() {
+    this.metadataConnection && ((await this.metadataConnection).close(), this.metadataConnection = null), this.documentsConnection && ((await this.documentsConnection).close(), this.documentsConnection = null);
+  }
+  async createDocument(e, t) {
+    await this.lock.run(async () => {
+      const s = E(e);
+      await this.withDocumentsTransaction(s, "readwrite", async (i) => {
+        if (await i.store.get(e))
+          throw new x(e);
+        return i.store.add({ url: e, graph: t });
+      });
+    });
+  }
+  async updateDocument(e, t) {
+    await this.lock.run(async () => {
+      const s = E(e);
+      await this.collectionExists(s) && await this.withDocumentsTransaction(s, "readwrite", (i) => i.store.put({ url: e, graph: t }));
+    });
+  }
+  async readManyDocuments(e) {
+    return this.lock.run(async () => {
+      if (!await this.collectionExists(e))
+        return {};
+      const t = await this.withDocumentsTransaction(e, "readonly", (s) => s.store.getAll());
+      return X(t, "url", (s) => s.graph);
+    });
+  }
+  async createCollection(e) {
+    await this.collectionExists(e) || await this.withMetadataTransaction("readwrite", (t) => t.store.add({ name: e }));
+  }
+  async collectionExists(e) {
+    return (await this.getCollections()).includes(e);
+  }
+  async getCollections() {
+    return (await this.withMetadataTransaction("readonly", (t) => t.store.getAll())).map((t) => t.name);
+  }
+  async withMetadataTransaction(e, t) {
+    const i = (await this.getMetadataConnection()).transaction("collections", e);
+    return t(i);
+  }
+  async withDocumentsTransaction(e, t, s) {
+    t === "readwrite" && !await this.collectionExists(e) && await this.createCollection(e);
+    const a = (await this.getDocumentsConnection()).transaction(e, t);
+    return s(a);
+  }
+  async getMetadataConnection() {
+    return this.metadataConnection ? this.metadataConnection : this.metadataConnection = N(`${this.database}-meta`, 1, {
+      upgrade(e) {
+        e.objectStoreNames.contains("collections") || e.createObjectStore("collections", { keyPath: "name" });
+      }
+    });
+  }
+  async getDocumentsConnection() {
+    if (this.documentsConnection)
+      return this.documentsConnection;
+    const e = await this.getCollections();
+    return this.documentsConnection = N(this.database, e.length + 1, {
+      upgrade(t) {
+        for (const s of e)
+          t.objectStoreNames.contains(s) || t.createObjectStore(s, { keyPath: "url" });
+      }
+    });
+  }
+}
+class yt {
+  constructor() {
+    c(this, "documents", {});
+  }
+  async createDocument(e, t) {
+    if (e in this.documents)
+      throw new x(e);
+    this.documents[e] = t;
+  }
+  async updateDocument(e, t) {
+    this.documents[e] = t;
+  }
+  async readManyDocuments(e) {
+    const t = {};
+    for (const [s, i] of Object.entries(this.documents))
+      s.startsWith(e) && (t[s] = i);
+    return t;
+  }
+}
+class Dt {
+  constructor(e) {
+    c(this, "client");
+    this.client = new nt({ fetch: e });
+  }
+  async createDocument(e, t) {
+    if (await this.client.exists(e))
+      throw new x(e);
+    const s = await C(t), i = m(s);
+    await this.client.create(e, i);
+  }
+  async updateDocument(e, t, s) {
+    const i = await C(t);
+    if (s && s.length > 0) {
+      const o = await this.client.read(e), r = i.filter((u) => s.includes(u.predicate.value)), d = o.statements().filter((u) => s.includes(u.predicate.value));
+      await this.client.update(
+        e,
+        `
+                    DELETE DATA { ${m(d)} } ;
+                    INSERT DATA { ${m(r)} }
+                `
+      );
+    }
+    const a = m(i);
+    await this.client.create(e, a);
+  }
+  async readManyDocuments(e) {
+    const s = (await this.client.read(e)).statements(e, at), i = {};
+    return await Promise.all(
+      s.map(async (a) => {
+        const o = a.object.value, r = await this.client.readIfFound(o);
+        !r || r.contains(o, p, it) || r.contains(o, p, st) || (i[o] = await M(r.getQuads()));
+      })
+    ), i;
+  }
 }
-function l(t, r) {
-  const e = t.meta();
-  if (e && r in e)
-    return e[r];
-  if (t instanceof b || t instanceof m)
-    return l(t.def.innerType, r);
+function g(n, e) {
+  const t = n.meta();
+  if (t && e in t)
+    return t[e];
+  if (n instanceof R || n instanceof P)
+    return g(n.def.innerType, e);
 }
-function S(t) {
-  return typeof t != "string" ? l(this, "rdfProperty") : this.meta({ rdfProperty: t });
+function rt(n) {
+  return typeof n != "string" ? g(this, "rdfProperty") : this.meta({ rdfProperty: n });
 }
-const L = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const ct = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  rdfProperty: S
+  rdfProperty: rt
 }, Symbol.toStringTag, { value: "Module" }));
-function q() {
-  for (const [t, r] of Object.entries(L))
-    F.ZodType.prototype[t] = r;
+function Ct() {
+  for (const [n, e] of Object.entries(ct))
+    U.ZodType.prototype[n] = e;
 }
 export {
-  T as Model,
-  V as defineSchema,
-  q as patchZod
+  x as DocumentAlreadyExists,
+  yt as InMemoryEngine,
+  pt as IndexedDBEngine,
+  _ as Model,
+  Dt as SolidEngine,
+  T as SoukaiError,
+  mt as bootModels,
+  wt as defineSchema,
+  bt as getEngine,
+  Ct as patchZod,
+  D as requireEngine,
+  _t as setEngine
 };
 //# sourceMappingURL=soukai-bis.js.map