repl-sdk 0.0.0 → 1.0.1

package/src/types.ts

@@ -1,62 +1,339 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { FileDescription } from 'tarparser';
+
+export interface RequestAnswer {
+  inTarFile: string;
+  ext: string;
+  from: string;
+}
+
+export interface PublicMethods {
+  announce: (type: 'error' | 'info', message: string) => void;
+  getCompiler: (format: string, flavor?: string) => Promise<Compiler>;
+  getAllowedFormats: () => string[];
+  getFlavorsFor: (format: string) => string[];
+
+  /**
+   * Will try to use a shimmed import, or will return null.
+   */
+  tryResolve: (
+    moduleName: string,
+    fallback?: (moduleName?: string) => Promise<object | undefined>
+  ) => Promise<any>;
+
+  /**
+   * Import many modules in parallel.
+   * For each array entry,
+   *   Will try to use a shimmed import, or will return null.
+   *
+   * Optionally accepts a fallback function for proxying to a CDN, if desired.
+   *
+   */
+  tryResolveAll: (
+    moduleNames: string[],
+    fallback?: (moduleName?: string) => Promise<unknown>
+  ) => Promise<any[]>;
+  compile: (
+    format: string,
+    text: string,
+    options?: {
+      flavor?: string;
+      fileName?: string;
+    }
+  ) => Promise<{ element: HTMLElement; destroy: () => void }>;
+
+  optionsFor: (
+    format: string,
+    flavor?: string
+  ) => {
+    resolve?: (id: string) => string | undefined;
+    versions?: { [packageName: string]: string };
+    needsLiveMeta?: boolean;
+    [option: string]: unknown;
+  };
+
+  /**
+   * Does this compiler support the given format?
+   */
+  canCompile: (
+    format: string,
+    flavor?: string
+  ) =>
+    | {
+        result: true;
+      }
+    | { result: false; reason: string };
+}
+export interface ResolvedCompilerOptions {
+  resolve: { [importPath: string]: unknown };
+  needsLiveMeta?: boolean;
+  versions?: { [packageName: string]: string };
+  userOptions?: Options['options'];
+}
+
+type CompileResult =
+  | string
+  | {
+      compiled: string;
+      [option: string]: unknown;
+    };
+
+export interface Compiler {
+  /**
+   * Convert a string from "fileExtension" to standard JavaScript.
+   * This will be loaded as a module and then passed to the render method.
+   *
+   * You may return either just a string, or an object with a `compiled` property that is a string -- any additional properties will be passde through to the render function -- which may be useful if there is accompanying CSS.
+   */
+  compile: (text: string, options: Record<string, unknown>) => Promise<CompileResult>;
+
+  /**
+   * For the root of a node rendered for this compiler,
+   * how will this particular library / framework
+   * render in to the given element?
+   *
+   * Example:
+   * ```js
+   * {
+   *   async compiler() {
+   *     const { createRoot } = await import('react-dom/client');
+   *
+   *     return {
+   *        render(element, defaultExport) {
+   *          const root = createRoot(element);
+   *
+   *          root.render(defaultExport);
+   *        },
+   *        // ...
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * @param {HTMLElement} the element to render in to, this is provided by repl-sdk.
+   * @param {any} defaultExport the default export from the compiled module.
+   * @param {{ compiled: string } & Record<string, unknown>} extras the compiled string (for reference), as well as any extra information that may have been returned from the compile function.
+   */
+  render: (
+    element: HTMLElement,
+    defaultExport: unknown,
+    extras: { compiled: string } & Record<string, unknown>,
+    compiler: PublicMethods
+  ) => Promise<void | (() => void)>;
+
+  /**
+   * Sometimes libraries do not publish browser-compatible modules,
+   * and require additional transpilation.
+   * Usually this happens by the consuming application's build process -- but in this REPL,
+   * we are kind of not exactly a consuming application, but still need to handle the further
+   * build concerns.
+   *
+   * For example, `import.meta.env.DEV` is not a platform native thing that and requires
+   * a build plugin. Vite has one built in, but all other tools need to manually specify
+   * what to do with `import.meta.env.DEV`.
+   *
+   * Another example, some component frameworks may use templates, which can only be compiled
+   * by the host application, as the details of how a template is compiled are private API,
+   * and can vary in minor releases of the template compiler.
+   *
+   * This should be a map of file extensions to async functions that must return either the
+   * original file text or additionally transformed text.
+   *
+   * ```js
+   * handlers: {
+   *   // When resolving a .js file from a CDN or NPM, replace `import.meta.env.DEV` with `true`
+   *   js: async(text) => {
+   *     return text.replaceAll('import.meta.env.DEV', 'true');
+   *   }
+   * }
+   * ```
+   *
+   * This could also be used to run the same build step on fetched files as
+   * the files provided to the REPL.
+   *
+   * ```js
+   * let compiler = {
+   *   compile: async (text) => { ... },
+   *   render: async (element, compiled, ...rest) => { ... },
+   *   handlers: {
+   *     js: async(text) => {
+   *       return compiler.compile(text);
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  handlers?: {
+    [fileExtension: string]: (text: string) => Promise<CompileResult>;
+  };
+}
+
+export interface CompilerConfig {
+  /**
+   * Extensions for codemirror, providing syntax highlighting and other editor features (completions, etc)
+   */
+  codemirror: {
+    lang: () => Promise<unknown>;
+    support?: () => Promise<unknown>;
+  };
+
+  /**
+   * When using this file extension in markdown documents,
+   * should we only evaluate the code block if the "live"
+   * meta is attached to the codefence?
+   *
+   * If you don't use markdown-embedded rendering,
+   * you can ignore this option. Default behavior is "false",
+   * but it doesn't matter if you don't render markdown anyway.
+   *
+   * For example, with `needsLiveMeta: false`:
+   * \`\`\`js
+   * console.log('hello');
+   * \`\`\`
+   * will be evaluated and log to the console.
+   * However, with `needsLiveMeta: true`, the above snippet would not
+   * be evaluated. To evaluate a snippet with `needsLiveMeta: true`:
+   * \`\`\`js live
+   * console.log('hello');
+   * \`\`\`
+   */
+  needsLiveMeta?: boolean;
+
+  /**
+   * Synchronously extend the way resolution works
+   * This is "import map as a function", which allows for more flexibility than just the static import map.
+   *
+   * This may not return a promise.
+   * But we can return functions that return promises.
+   *
+   */
+  resolve?: (
+    id: string
+  ) =>
+    | string
+    | (() => Record<string, unknown>)
+    | (() => Promise<Record<string, unknown>>)
+    | undefined;
+
+  /**
+   * This optional method provides the opportunity to reformat messages that would be displayed to the REPL.
+   */
+  onUnhandled?: (e: PromiseRejectionEvent, handle: (msg: string) => void) => void;
+
+  compiler: (
+    /**
+     * The config for the compiler may be passed by the caller.
+     * Common use case for this object is specifying what versions
+     * of the compiler/library/framework dependencies to use.
+     */
+    config: { versions: { [packageName: string]: string }; [option: string]: unknown },
+    /**
+     * The public methods provided from the compiler
+     */
+    api: PublicMethods
+  ) => Promise<Compiler>;
+}
+
 export interface Options {
+  /**
+   * Events will be emitted on this object.
+   * Not required, but could be useful for providing lots of feedback to the user.
+   */
+  on?: {
+    /**
+     * Public-log messages will be emitted here.
+     * These include:
+     * - errors
+     * - what is being fetched / compiled
+     */
+    log?: (type: 'error' | 'info', message: string) => void;
+  };
+
+  /**
+   * Map of pre-resolved JS values to use as the import map
+   * These could assume the role of runtime virtual modules.
+   *
+   * These will take precedence over the importMap, and implicit CDN fallback.
+   */
+  resolve?: { [importPath: string]: unknown };
+
+  /**
+   * Specifies which vesions of dependencies to when pulling from a CDN.
+   * Defaults to latest.
+   */
+  versions?: { [packageName: string]: string };
+
+  /**
+   * Map of file extensions to compiler configurations
+   */
   formats: {
-    [fileExtension: string]: {
-      /**
-       * When using this file extension in markdown documents,
-       * should we only evaluate the code block if the "live" 
-       * meta is attached to the codefence?
-       *
-       * If you don't use markdown-embedded rendering, 
-       * you can ignore this option. Default behavior is "false",
-       * but it doesn't matter if you don't render markdown anyway.
-       *
-       * For example, with `needsLiveMeta: false`:
-       * \`\`\`js
-       * console.log('hello');
-       * \`\`\`
-       * will be evaluated and log to the console.
-       * However, with `needsLiveMeta: true`, the above snippet would not
-       * be evaluated. To evaluate a snippet with `needsLiveMeta: true`:
-       * \`\`\`js live 
-       * console.log('hello');
-       * \`\`\`
-       */
-      needsLiveMeta?: boolean;
-      compiler: () => Promise<{
-        /**
-         * Convert a string from "fileExtension" to standard JavaScript.
-         * This will be loaded as a module and then passed to the render method.
-         */
-        compile: (text: string) => Promise<string>;
-        /**
-         * For the root of a node rendered for this compiler,
-         * how will this particular library / framework
-         * render in to the given element?
-         *
-         * Example:
-         * ```js
-         * {
-         *   async compiler() {
-         *     const { createRoot } = await import('react-dom/client');
-         *   
-         *     return {
-         *        render(element, defaultExport) {
-         *          const root = createRoot(element);
-         *
-         *          root.render(defaultExport);
-         *        },
-         *        // ...
-         *     }
-         *   }
-         * }
-         * ```
-         *
-         * @param {HTMLElement} the element to render in to, this is provided by repl-sdk.
-         * @param {any} the default export from the compiled module.
-         */
-        render: (element: HTMLElement, defaultExport: any) => void;
-      }>;
-    }
-  }
+    [fileExtension: string]:
+      | CompilerConfig
+      | {
+          [flavor: string]: CompilerConfig;
+        };
+  };
+
+  options?: {
+    [format: string]:
+      | KnownDefaultOptions
+      | {
+          [flavor: string]: { [option: string]: unknown };
+        }
+      | {
+          [option: string]: unknown;
+        };
+  };
+
+  /**
+   * Show extra debug logging or not
+   */
+  logging?: boolean | undefined;
+}
+
+interface KnownDefaultOptions {
+  md?: {
+    rehypePlugins?: unknown[];
+    remarkPlugins?: unknown[];
+    CopyComponent?: string;
+    ShadowComponent?: string;
+  };
+}
+
+import type { ImportMap as ManifestImports } from 'resolve.imports';
+
+export interface UntarredPackage {
+  /**
+   * the package.json
+   */
+  manifest: {
+    name: string;
+    version: string;
+    exports?: ManifestExports;
+    imports?: Record<string, ManifestImports>;
+    main?: string;
+    module?: string;
+    browser?: string;
+  };
+  contents: {
+    [path: string]: FileDescription;
+  };
+}
+
+type ManifestExport = string | string[] | { [condition: string]: ManifestExport };
+
+export interface ManifestExports {
+  [importPath: string]: ManifestExport;
+}
+
+export interface InfoMessage {
+  type: 'info';
+  message: string;
+}
+
+export interface ErrorMessage {
+  type: 'error';
+  message: string;
 }
 
+export type Message = InfoMessage | ErrorMessage;

package/src/utils.js

@@ -1,10 +1,37 @@
 /**
  * @param {string} message
  * @param {unknown} test
- * @asserts test
+ * @returns {asserts test}
  */
 export function assert(message, test) {
   if (!test) {
     throw new Error(message);
   }
 }
+
+let i = 0;
+
+export function nextId() {
+  i += 1;
+
+  return `repl_${i}`;
+}
+
+export const fakeDomain = 'repl.sdk';
+export const tgzPrefix = 'file:///tgz.repl.sdk/';
+export const unzippedPrefix = 'file:///tgz.repl.sdk/unzipped';
+
+/**
+ * @param {string} url
+ */
+export function prefix_tgz(url) {
+  return `${tgzPrefix}${url}`;
+}
+
+/**
+ * @param {unknown} x
+ * @returns {x is Record<string, unknown>}
+ */
+export function isRecord(x) {
+  return typeof x === 'object' && x !== null && !Array.isArray(x);
+}

package/declarations/index.d.ts

@@ -1,73 +0,0 @@
-export declare class Compiler {
-    constructor(options?: Options);
-
-    compile(format: string, text: string): Promise<HTMLElement>;
-}
-
-export declare const defaultFormats: Options['formats'];
-
-export declare const defaults: Options;
-
-declare interface Options {
-    formats: {
-        [fileExtension: string]: {
-            /**
-             * When using this file extension in markdown documents,
-             * should we only evaluate the code block if the "live"
-             * meta is attached to the codefence?
-             *
-             * If you don't use markdown-embedded rendering,
-             * you can ignore this option. Default behavior is "false",
-             * but it doesn't matter if you don't render markdown anyway.
-             *
-             * For example, with `needsLiveMeta: false`:
-             * \`\`\`js
-             * console.log('hello');
-             * \`\`\`
-             * will be evaluated and log to the console.
-             * However, with `needsLiveMeta: true`, the above snippet would not
-             * be evaluated. To evaluate a snippet with `needsLiveMeta: true`:
-             * \`\`\`js live
-             * console.log('hello');
-             * \`\`\`
-             */
-            needsLiveMeta?: boolean;
-            compiler: () => Promise<{
-                /**
-                 * Convert a string from "fileExtension" to standard JavaScript.
-                 * This will be loaded as a module and then passed to the render method.
-                 */
-                compile: (text: string) => Promise<string>;
-                /**
-                 * For the root of a node rendered for this compiler,
-                 * how will this particular library / framework
-                 * render in to the given element?
-                 *
-                 * Example:
-                 * ```js
-                 * {
-                 *   async compiler() {
-                 *     const { createRoot } = await import('react-dom/client');
-                 *
-                 *     return {
-                 *        render(element, defaultExport) {
-                 *          const root = createRoot(element);
-                 *
-                 *          root.render(defaultExport);
-                 *        },
-                 *        // ...
-                 *     }
-                 *   }
-                 * }
-                 * ```
-                 *
-                 * @param {HTMLElement} the element to render in to, this is provided by repl-sdk.
-                 * @param {any} the default export from the compiled module.
-                 */
-                render: (element: HTMLElement, defaultExport: any) => void;
-            }>;
-        };
-    };
-}
-
-export { }

package/dist/index.js

@@ -1,107 +0,0 @@
-function assert(message, test) {
-  if (!test) {
-    throw new Error(message);
-  }
-}
-assert(`There is no document. repl-sdk is meant to be ran in a browser`, globalThis.document);
-const defaultFormats = {
-  mermaid: {
-    compiler: async () => {
-      return {
-        compile: async (text) => {
-        }
-      };
-    }
-  }
-};
-const defaults = {
-  formats: defaultFormats
-};
-const secret = Symbol.for("__repl-sdk__compiler__");
-assert(
-  `There is already an instance of repl-sdk, and there can only be one. Make sure that your dependency graph is correct.`,
-  !globalThis[secret]
-);
-class Compiler {
-  /** @type {Options} */
-  #options;
-  /**
-   * Options may be passed to the compiler to add to its behavior.
-   */
-  constructor(options = defaults) {
-    this.#options = options;
-    globalThis[secret] = this;
-    globalThis.window.esmsInitOptions = {
-      shimMode: true,
-      skip: `https://esm.sh/`,
-      revokeBlobURLs: true,
-      // default false
-      // Permit overrides to import maps
-      mapOverrides: true,
-      // default false
-      // Hook all module resolutions
-      resolve: (id, parentUrl, resolve) => {
-        if (id.startsWith("blob:")) return id;
-        if (id.startsWith("https://")) return id;
-        console.log("Resolving", id);
-        return `https://esm.sh/*${id}`;
-      },
-      // Hook source fetch function
-      fetch: async (url, options2) => {
-        console.log(`Fetching`, url);
-        if (url.endsWith("example.js")) {
-          const transformed = `export const js = 'transformed'`;
-          return new Response(new Blob([transformed], { type: "application/javascript" }));
-        }
-        const response = await fetch(url, options2);
-        return response;
-      }
-    };
-  }
-  /**
-   * @param {string} format
-   * @param {string} text
-   */
-  async compile(format, text) {
-    await import("es-module-shims");
-    const compiler = await this.#getCompiler(format);
-    const compiledText = await compiler.compile(text);
-    const asBlobUrl = textToBlobUrl(compiledText);
-    const { default: defaultExport } = await importShim(
-      /* @vite-ignore */
-      asBlobUrl
-    );
-    return this.#render(compiler, defaultExport);
-  }
-  async #getCompiler(format) {
-    const config = this.#options.formats[format];
-    assert(
-      `${format} is not a configured format. The currently configured formats are ${Object.keys(this.#options.formats).join(", ")}`,
-      config
-    );
-    const compiler = await config.compiler();
-    return compiler;
-  }
-  async #render(compiler, whatToRender) {
-    const div = this.#createDiv();
-    await compiler.render(div, whatToRender);
-    return div;
-  }
-  #createDiv() {
-    let div = document.createElement("div");
-    div.setAttribute("data-repl-output", "");
-    div.id = "some-random-string";
-    return div;
-  }
-}
-function textToBlobUrl(text) {
-  const blob = new Blob([text], { type: "text/javascript" });
-  const blobUrl = URL.createObjectURL(blob);
-  return blobUrl;
-}
-export {
-  Compiler,
-  defaultFormats,
-  defaults
-};
-//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":["../src/utils.js","../src/index.js"],"sourcesContent":["/**\n * @param {string} message\n * @param {unknown} test\n * @asserts test\n */\nexport function assert(message, test) {\n  if (!test) {\n    throw new Error(message);\n  }\n}\n","/**\n * @typedef {import(\"./types.ts\").Options} Options\n */\nimport { assert } from './utils.js';\n\nassert(`There is no document. repl-sdk is meant to be ran in a browser`, globalThis.document);\n\nexport const defaultFormats = {\n  mermaid: {\n    compiler: async () => {\n      return {\n        compile: async (text) => {},\n      };\n    },\n  },\n};\n\nexport const defaults = {\n  formats: defaultFormats,\n};\n\nconst secret = Symbol.for('__repl-sdk__compiler__');\n\nassert(\n  `There is already an instance of repl-sdk, and there can only be one. Make sure that your dependency graph is correct.`,\n  !globalThis[secret]\n);\n\nexport class Compiler {\n  /** @type {Options} */\n  #options;\n\n  /**\n   * Options may be passed to the compiler to add to its behavior.\n   */\n  constructor(options = defaults) {\n    this.#options = options;\n\n    globalThis[secret] = this;\n    globalThis.window.esmsInitOptions = {\n      shimMode: true,\n      skip: `https://esm.sh/`,\n      revokeBlobURLs: true, // default false\n      // Permit overrides to import maps\n      mapOverrides: true, // default false\n      // Hook all module resolutions\n      resolve: (id, parentUrl, resolve) => {\n        if (id.startsWith('blob:')) return id;\n        if (id.startsWith('https://')) return id;\n\n        console.log('Resolving', id);\n        /**\n         * TODO: locally defined scope\n         *       vs\n         *       proxy to esm.sh\n         */\n\n        /**\n         * For esm.sh, we want all imports to declare they don't want\n         * their dependencies bundled. We want to have every import go\n         * through this resolve/fetch combo of things so we have a chance\n         * to compile if we need to.\n         */\n        return `https://esm.sh/*${id}`;\n      },\n      // Hook source fetch function\n      fetch: async (url, options) => {\n        console.log(`Fetching`, url);\n        /**\n         * Do transformations here based on file extension\n         */\n        if (url.endsWith('example.js')) {\n          const transformed = `export const js = 'transformed'`;\n          return new Response(new Blob([transformed], { type: 'application/javascript' }));\n        }\n\n        const response = await fetch(url, options);\n\n        // if (response.url.endsWith('.ts')) {\n        //   const source = await response.body();\n        //   const transformed = tsCompile(source);\n        //   return new Response(new Blob([transformed], { type: 'application/javascript' }));\n        // }\n        return response;\n      },\n    };\n    // addShim();\n  }\n\n  /**\n   * @param {string} format\n   * @param {string} text\n   */\n  async compile(format, text) {\n    await import('es-module-shims');\n\n    const compiler = await this.#getCompiler(format);\n\n    // TODO: pass this through es-module-shims\n    //       for getting the actual module back\n    const compiledText = await compiler.compile(text);\n\n    const asBlobUrl = textToBlobUrl(compiledText);\n\n    const { default: defaultExport } = await importShim(/* @vite-ignore */ asBlobUrl);\n\n    return this.#render(compiler, defaultExport);\n  }\n\n  async #getCompiler(format) {\n    const config = this.#options.formats[format];\n\n    assert(\n      `${format} is not a configured format. ` +\n        `The currently configured formats are ${Object.keys(this.#options.formats).join(', ')}`,\n      config\n    );\n\n    const compiler = await config.compiler();\n\n    return compiler;\n  }\n\n  async #render(compiler, whatToRender) {\n    const div = this.#createDiv();\n\n    await compiler.render(div, whatToRender);\n\n    return div;\n  }\n\n  #createDiv() {\n    let div = document.createElement('div');\n    div.setAttribute('data-repl-output', '');\n    div.id = 'some-random-string';\n    return div;\n  }\n}\n\nfunction addShim() {\n  let url = 'https://ga.jspm.io/npm:es-module-shims@1.10.0/dist/es-module-shims.js';\n\n  if (document.querySelector('script[src=\"${url}\"]')) {\n    // Shim is already present\n    return;\n  }\n\n  let script = document.createElement('script');\n  // script.setAttribute('async', '');\n  script.setAttribute('src', `<script async src=\"${url}\"></script>`);\n\n  document.head.appendChild(script);\n}\n\n/**\n * @param {string} text\n */\nfunction textToBlobUrl(text) {\n  const blob = new Blob([text], { type: 'text/javascript' });\n\n  const blobUrl = URL.createObjectURL(blob);\n  return blobUrl;\n}\n"],"names":["options"],"mappings":"AAKO,SAAS,OAAO,SAAS,MAAM;AACpC,MAAI,CAAC,MAAM;AACT,UAAM,IAAI,MAAM,OAAO;AAAA,EACxB;AACH;ACJA,OAAO,kEAAkE,WAAW,QAAQ;AAEhF,MAAC,iBAAiB;AAAA,EAC5B,SAAS;AAAA,IACP,UAAU,YAAY;AACpB,aAAO;AAAA,QACL,SAAS,OAAO,SAAS;AAAA,QAAE;AAAA,MACnC;AAAA,IACK;AAAA,EACF;AACH;AAEY,MAAC,WAAW;AAAA,EACtB,SAAS;AACX;AAEA,MAAM,SAAS,OAAO,IAAI,wBAAwB;AAElD;AAAA,EACE;AAAA,EACA,CAAC,WAAW,MAAM;AACpB;AAEO,MAAM,SAAS;AAAA;AAAA,EAEpB;AAAA;AAAA;AAAA;AAAA,EAKA,YAAY,UAAU,UAAU;AAC9B,SAAK,WAAW;AAEhB,eAAW,MAAM,IAAI;AACrB,eAAW,OAAO,kBAAkB;AAAA,MAClC,UAAU;AAAA,MACV,MAAM;AAAA,MACN,gBAAgB;AAAA;AAAA;AAAA,MAEhB,cAAc;AAAA;AAAA;AAAA,MAEd,SAAS,CAAC,IAAI,WAAW,YAAY;AACnC,YAAI,GAAG,WAAW,OAAO,EAAG,QAAO;AACnC,YAAI,GAAG,WAAW,UAAU,EAAG,QAAO;AAEtC,gBAAQ,IAAI,aAAa,EAAE;AAa3B,eAAO,mBAAmB,EAAE;AAAA,MAC7B;AAAA;AAAA,MAED,OAAO,OAAO,KAAKA,aAAY;AAC7B,gBAAQ,IAAI,YAAY,GAAG;AAI3B,YAAI,IAAI,SAAS,YAAY,GAAG;AAC9B,gBAAM,cAAc;AACpB,iBAAO,IAAI,SAAS,IAAI,KAAK,CAAC,WAAW,GAAG,EAAE,MAAM,yBAA0B,CAAA,CAAC;AAAA,QAChF;AAED,cAAM,WAAW,MAAM,MAAM,KAAKA,QAAO;AAOzC,eAAO;AAAA,MACR;AAAA,IACP;AAAA,EAEG;AAAA;AAAA;AAAA;AAAA;AAAA,EAMD,MAAM,QAAQ,QAAQ,MAAM;AAC1B,UAAM,OAAO,iBAAiB;AAE9B,UAAM,WAAW,MAAM,KAAK,aAAa,MAAM;AAI/C,UAAM,eAAe,MAAM,SAAS,QAAQ,IAAI;AAEhD,UAAM,YAAY,cAAc,YAAY;AAE5C,UAAM,EAAE,SAAS,cAAa,IAAK,MAAM;AAAA;AAAA,MAA8B;AAAA,IAAS;AAEhF,WAAO,KAAK,QAAQ,UAAU,aAAa;AAAA,EAC5C;AAAA,EAED,MAAM,aAAa,QAAQ;AACzB,UAAM,SAAS,KAAK,SAAS,QAAQ,MAAM;AAE3C;AAAA,MACE,GAAG,MAAM,qEACiC,OAAO,KAAK,KAAK,SAAS,OAAO,EAAE,KAAK,IAAI,CAAC;AAAA,MACvF;AAAA,IACN;AAEI,UAAM,WAAW,MAAM,OAAO;AAE9B,WAAO;AAAA,EACR;AAAA,EAED,MAAM,QAAQ,UAAU,cAAc;AACpC,UAAM,MAAM,KAAK;AAEjB,UAAM,SAAS,OAAO,KAAK,YAAY;AAEvC,WAAO;AAAA,EACR;AAAA,EAED,aAAa;AACX,QAAI,MAAM,SAAS,cAAc,KAAK;AACtC,QAAI,aAAa,oBAAoB,EAAE;AACvC,QAAI,KAAK;AACT,WAAO;AAAA,EACR;AACH;AAoBA,SAAS,cAAc,MAAM;AAC3B,QAAM,OAAO,IAAI,KAAK,CAAC,IAAI,GAAG,EAAE,MAAM,kBAAiB,CAAE;AAEzD,QAAM,UAAU,IAAI,gBAAgB,IAAI;AACxC,SAAO;AACT;"}