@mdxeditor/editor 0.10.1 → 0.11.1-alpha.1

package/dist/gurx/realm.js

@@ -0,0 +1,491 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { tap } from "../utils/fp.js";
+import { uuidv4 } from "../utils/uuid4.js";
+function defaultComparator(current, next) {
+  return current === next;
+}
+class SetMap {
+  constructor() {
+    __publicField(this, "map", /* @__PURE__ */ new Map());
+  }
+  getOrCreate(key) {
+    let record = this.map.get(key);
+    if (!record) {
+      record = /* @__PURE__ */ new Set();
+      this.map.set(key, record);
+    }
+    return record;
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  use(key, cb) {
+    const set = this.get(key);
+    if (set !== void 0) {
+      cb(set);
+    }
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+}
+class RefCount {
+  constructor(map = /* @__PURE__ */ new Map()) {
+    __publicField(this, "map");
+    this.map = map;
+  }
+  clone() {
+    return new RefCount(new Map(this.map));
+  }
+  increment(key) {
+    const counter = this.map.get(key) ?? 0;
+    this.map.set(key, counter + 1);
+  }
+  decrement(key, ifZero) {
+    let counter = this.map.get(key);
+    if (counter !== void 0) {
+      counter -= 1;
+      this.map.set(key, counter);
+      if (counter === 0) {
+        ifZero();
+      }
+    }
+  }
+}
+const NO_VALUE = Symbol("NO_VALUE");
+function realm() {
+  const subscriptions = new SetMap();
+  const singletonSubscriptions = /* @__PURE__ */ new Map();
+  const graph = new SetMap();
+  const state = /* @__PURE__ */ new Map();
+  const distinctNodes = /* @__PURE__ */ new Map();
+  const labels = {};
+  function node(value = NO_VALUE, distinct = false) {
+    const key = uuidv4();
+    if (value !== NO_VALUE) {
+      state.set(key, value);
+    }
+    if (distinct !== false) {
+      distinctNodes.set(key, distinct === true ? defaultComparator : distinct);
+    }
+    return { key, toString: () => key };
+  }
+  function subSingle({ key }, subscription) {
+    const nodeSubscriptions = subscriptions.getOrCreate(key);
+    nodeSubscriptions.add(subscription);
+    return () => nodeSubscriptions.delete(subscription);
+  }
+  function singletonSub({ key }, subscription) {
+    singletonSubscriptions.set(key, subscription);
+    return () => singletonSubscriptions.delete(key);
+  }
+  function singletonSubKey(key, subscription) {
+    return singletonSub(labels[key], subscription);
+  }
+  function resetSingletonSubs() {
+    singletonSubscriptions.clear();
+  }
+  function subMultiple(sources, cb) {
+    const sink = node();
+    connect({
+      map: (done) => (...args) => {
+        done(args);
+      },
+      sink,
+      sources
+    });
+    return subSingle(sink, cb);
+  }
+  function sub(...args) {
+    const [subscription] = args.slice(-1);
+    const nodes = args.slice(0, -1);
+    if (nodes.length === 1) {
+      return subSingle(nodes[0], subscription);
+    } else {
+      return subMultiple(nodes, subscription);
+    }
+  }
+  function calculateExecutionMap(keys) {
+    const participatingNodeKeys = [];
+    const visitedNodes = /* @__PURE__ */ new Set();
+    const pendingPulls = new SetMap();
+    const refCount = new RefCount();
+    const projections = new SetMap();
+    function visit(key, insertIndex = 0) {
+      refCount.increment(key);
+      if (visitedNodes.has(key)) {
+        return;
+      }
+      pendingPulls.use(key, (pulls) => {
+        insertIndex = Math.max(...Array.from(pulls).map((key2) => participatingNodeKeys.indexOf(key2))) + 1;
+      });
+      graph.use(key, (sinkProjections) => {
+        sinkProjections.forEach((projection) => {
+          if (projection.sources.has(key)) {
+            projections.getOrCreate(projection.sink).add(projection);
+            visit(projection.sink, insertIndex);
+          } else {
+            pendingPulls.getOrCreate(projection.sink).add(key);
+          }
+        });
+      });
+      visitedNodes.add(key);
+      participatingNodeKeys.splice(insertIndex, 0, key);
+    }
+    keys.forEach((key) => visit(key));
+    return { participatingNodeKeys, pendingPulls, projections, refCount };
+  }
+  const executionMaps = /* @__PURE__ */ new Map();
+  function pubIn(values) {
+    var _a;
+    const keys = Object.keys(values);
+    const executionMapKey = keys.join(",");
+    if (!executionMaps.has(executionMapKey)) {
+      executionMaps.set(executionMapKey, calculateExecutionMap(keys));
+    }
+    const map2 = executionMaps.get(executionMapKey);
+    const refCount = map2.refCount.clone();
+    const participatingNodeKeys = map2.participatingNodeKeys.slice();
+    const transientState = new Map(state);
+    function nodeWillNotEmit(key) {
+      graph.use(key, (projections) => {
+        projections.forEach(({ sources, sink }) => {
+          if (sources.has(key)) {
+            refCount.decrement(sink, () => {
+              participatingNodeKeys.splice(participatingNodeKeys.indexOf(sink), 1);
+              nodeWillNotEmit(sink);
+            });
+          }
+        });
+      });
+    }
+    let nodeKey;
+    while (nodeKey = participatingNodeKeys.shift()) {
+      let resolved = false;
+      const done = (value) => {
+        if (distinctNodes.has(nodeKey) && distinctNodes.get(nodeKey)(state.get(nodeKey), value)) {
+          resolved = false;
+          return;
+        }
+        resolved = true;
+        transientState.set(nodeKey, value);
+        if (state.has(nodeKey)) {
+          state.set(nodeKey, value);
+        }
+      };
+      if (Object.prototype.hasOwnProperty.call(values, nodeKey)) {
+        done(values[nodeKey]);
+      } else {
+        map2.projections.use(nodeKey, (nodeProjections) => {
+          nodeProjections.forEach((projection) => {
+            const args = [...Array.from(projection.sources), ...Array.from(projection.pulls)].map((id) => transientState.get(id));
+            projection.map(done)(...args);
+          });
+        });
+      }
+      if (resolved) {
+        const value = transientState.get(nodeKey);
+        subscriptions.use(nodeKey, (nodeSubscriptions) => {
+          nodeSubscriptions.forEach((subscription) => subscription(value));
+        });
+        (_a = singletonSubscriptions.get(nodeKey)) == null ? void 0 : _a(value);
+      } else {
+        nodeWillNotEmit(nodeKey);
+      }
+    }
+  }
+  function nodesToKeySet(nodes) {
+    return new Set(nodes.map((s) => s.key));
+  }
+  function connect({ sources, pulls = [], map: map2, sink: { key: sink } }) {
+    const dependency = {
+      map: map2,
+      pulls: nodesToKeySet(pulls),
+      sink,
+      sources: nodesToKeySet(sources)
+    };
+    [...sources, ...pulls].forEach(({ key: sourceKey }) => {
+      graph.getOrCreate(sourceKey).add(dependency);
+    });
+    executionMaps.clear();
+  }
+  function debug() {
+    Object.entries(labels).forEach(([name, value]) => {
+      state.get(value.key);
+    });
+  }
+  function pub(...args) {
+    const map2 = {};
+    for (let index = 0; index < args.length; index += 2) {
+      const node2 = args[index];
+      map2[node2.key] = args[index + 1];
+    }
+    pubIn(map2);
+  }
+  function label(newLabels) {
+    Object.assign(labels, newLabels);
+  }
+  function pipe(source, ...operators) {
+    for (const operator of operators) {
+      source = operator(source);
+    }
+    return source;
+  }
+  function spread(source, initialValues) {
+    return initialValues.map((initialValue, index) => {
+      return tap(node(initialValue, true), (sink) => {
+        connect({
+          map: (done) => (sourceValue) => {
+            done(sourceValue[index]);
+          },
+          sink,
+          sources: [source]
+        });
+      });
+    });
+  }
+  function link(source, sink) {
+    connect({ map: (done) => (value) => done(value), sink, sources: [source] });
+  }
+  function derive(source, initial) {
+    return tap(node(initial, true), (sink) => {
+      connect({ map: (done) => (value) => done(value), sink, sources: [source] });
+    });
+  }
+  function map(mapFunction) {
+    return (source) => {
+      const sink = node();
+      connect({
+        map: (done) => (value) => {
+          done(mapFunction(value));
+        },
+        sink,
+        sources: [source]
+      });
+      return sink;
+    };
+  }
+  function mapTo(value) {
+    return (source) => {
+      const sink = node();
+      connect({ map: (done) => () => done(value), sink, sources: [source] });
+      return sink;
+    };
+  }
+  function filter(predicate) {
+    return (source) => {
+      const sink = node();
+      connect({ map: (done) => (value) => predicate(value) && done(value), sink, sources: [source] });
+      return sink;
+    };
+  }
+  function once() {
+    return (source) => {
+      const sink = node();
+      let passed = false;
+      connect({
+        map: (done) => (value) => {
+          if (!passed) {
+            passed = true;
+            done(value);
+          }
+        },
+        sink,
+        sources: [source]
+      });
+      return sink;
+    };
+  }
+  function scan(accumulator, seed) {
+    return (source) => {
+      const sink = node();
+      connect({ map: (done) => (value) => done(seed = accumulator(seed, value)), sink, sources: [source] });
+      return sink;
+    };
+  }
+  function throttleTime(delay) {
+    return (source) => {
+      const sink = node();
+      let currentValue;
+      let timeout;
+      sub(source, (value) => {
+        currentValue = value;
+        if (timeout) {
+          return;
+        }
+        timeout = setTimeout(() => {
+          timeout = void 0;
+          pub(sink, currentValue);
+        }, delay);
+      });
+      return sink;
+    };
+  }
+  function delayWithMicrotask() {
+    return (source) => {
+      const sink = node();
+      sub(source, (value) => queueMicrotask(() => pub(sink, value)));
+      return sink;
+    };
+  }
+  function debounceTime(delay) {
+    return (source) => {
+      const sink = node();
+      let currentValue;
+      let timeout;
+      sub(source, (value) => {
+        currentValue = value;
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        timeout = setTimeout(() => {
+          pub(sink, currentValue);
+        }, delay);
+      });
+      return sink;
+    };
+  }
+  function onNext(bufNode) {
+    return (source) => {
+      const sink = node();
+      let pendingValue = NO_VALUE;
+      sub(source, (value) => pendingValue = value);
+      connect({
+        map: (done) => (value) => {
+          if (pendingValue !== NO_VALUE) {
+            done([pendingValue, value]);
+            pendingValue = NO_VALUE;
+          }
+        },
+        sink,
+        sources: [bufNode]
+      });
+      return sink;
+    };
+  }
+  function passOnlyAfterNodeHasEmittedBefore(starterNode, durationNode) {
+    return (source) => {
+      const sink = node();
+      let startTime = 0;
+      sub(starterNode, () => startTime = Date.now());
+      connect({
+        map: (done) => (value) => {
+          if (Date.now() < startTime + state.get(durationNode.key)) {
+            done(value);
+          }
+        },
+        sink,
+        sources: [source]
+      });
+      return sink;
+    };
+  }
+  function withLatestFrom(...nodes) {
+    return (source) => {
+      const sink = node();
+      connect({
+        map: (done) => (...args) => done(args),
+        pulls: nodes,
+        sink,
+        sources: [source]
+      });
+      return sink;
+    };
+  }
+  function combine(...nodes) {
+    const sink = node();
+    connect({
+      map: (done) => (...args) => done(args),
+      sink,
+      sources: nodes
+    });
+    return sink;
+  }
+  function subKey(key, subscription) {
+    return sub(labels[key], subscription);
+  }
+  function subKeys(keys, subscription) {
+    const nodes = keys.map((key) => labels[key]);
+    return sub(...nodes.concat(subscription));
+  }
+  function pubKey(key, value) {
+    pubKeys({ [key]: value });
+  }
+  function pubKeys(values) {
+    const valuesWithInternalKeys = Object.entries(values).reduce(
+      (acc, [key, value]) => tap(acc, (acc2) => {
+        const label2 = labels[key];
+        if (!label2) {
+          throw new Error(`No label for key ${key}. Do you miss a plugin?`);
+        }
+        acc2[label2.key] = value;
+        return value;
+      }),
+      {}
+    );
+    pubIn(valuesWithInternalKeys);
+  }
+  function getKeyValue(key) {
+    return state.get(labels[key].key);
+  }
+  function getValue(node2) {
+    return state.get(node2.key);
+  }
+  function getKeyValues(keys) {
+    return keys.map((key) => {
+      const label2 = labels[key];
+      if (!label2) {
+        throw new Error(`No label for key ${key}. Do you miss a plugin?`);
+      }
+      return state.get(label2.key);
+    });
+  }
+  return {
+    combine,
+    connect,
+    debug,
+    derive,
+    getKeyValue,
+    getValue,
+    getKeyValues,
+    label,
+    labels,
+    link,
+    node,
+    o: {
+      delayWithMicrotask,
+      debounceTime,
+      filter,
+      map,
+      mapTo,
+      onNext,
+      scan,
+      throttleTime,
+      withLatestFrom,
+      once,
+      passOnlyAfterNodeHasEmittedBefore
+    },
+    pipe,
+    pub,
+    pubIn,
+    pubKey,
+    pubKeys,
+    resetSingletonSubs,
+    singletonSub,
+    singletonSubKey,
+    spread,
+    sub,
+    subKey,
+    subKeys
+  };
+}
+export {
+  RefCount,
+  defaultComparator,
+  realm
+};

package/dist/gurx/realmFactory.d.ts

@@ -0,0 +1,58 @@
+import { Realm, RealmNode, Subscription, UnsubscribeHandle } from './realm';
+export interface System {
+    [key: string]: RealmNode<any>;
+}
+/**
+ * a SystemSpec is the result from a [[system]] call. To obtain the [[system]], pass the spec to [[init]].
+ * @typeParam Dependencies - The dependencies of the system.
+ * @typeParam Constructor - The system constructor.
+ */
+export interface SystemSpec<Dependencies extends AnySystemSpecs, /** @internal */ Constructor extends SystemConstructor<Dependencies>> {
+    id: string;
+    constructor: Constructor;
+    dependencies: Dependencies;
+}
+export interface AnySystemSpec extends SystemSpec<AnySystemSpecs, any> {
+    id: string;
+}
+export interface AnySystemSpecs extends Array<AnySystemSpec> {
+}
+export type SystemOfSpec<Spec extends AnySystemSpec> = ReturnType<Spec['constructor']>;
+/** @internal **/
+export type SSR<Spec extends AnySystemSpec> = SystemOfSpec<Spec>;
+/** @internal **/
+export type SystemsFromSpecs<ST extends AnySystemSpecs> = ST extends unknown[] ? SystemsFromSpecsRec<ST, []> : never;
+type SystemsFromSpecsRec<ST extends unknown[], Acc extends unknown[]> = ST extends [infer Head, ...infer Tail] ? SystemsFromSpecsRec<Tail, [...Acc, Head extends AnySystemSpec ? SystemOfSpec<Head> : never]> : Acc;
+/**
+ * The system constructor is a function which initializes and connects nodes and returns them as a [[system]].
+ * If the [[system]] call specifies system dependencies, the constructor receives the dependencies as an array argument.
+ */
+export interface SystemConstructor<D extends AnySystemSpecs> {
+    (r: Realm, dependencies: SystemsFromSpecs<D>): System;
+}
+export declare function system<Dependencies extends LongTuple<AnySystemSpec>, Constructor extends SystemConstructor<Dependencies>>(constructor: Constructor, dependencies?: Dependencies): SystemSpec<Dependencies, Constructor>;
+type SystemKey<S extends System> = Extract<keyof S, string>;
+export type ValuesForKeys<S extends System, K extends SystemKey<S>[]> = K extends unknown[] ? ValuesForKeysRec<S, K, []> : never;
+type ValuesForKeysRec<S extends Record<any, RealmNode>, K extends unknown[], Acc extends unknown[]> = K extends [infer Head, ...infer Tail] ? ValuesForKeysRec<S, Tail, [...Acc, S[Head] extends RealmNode<infer R> ? R : never]> : Acc;
+export type SystemOfSpecs<Specs extends AnySystemSpec[]> = Specs extends unknown[] ? SystemOfSpecsRec<Specs, {}> : Specs;
+type SystemOfSpecsRec<Specs extends unknown[], Acc extends {}> = Specs extends [infer Head, ...infer Tail] ? SystemOfSpecsRec<Tail, Head extends AnySystemSpec ? Acc & SystemOfSpec<Head> : never> : Acc;
+export type LongTuple<K> = [] | [K] | [K, K] | [K, K, K] | [K, K, K, K] | [K, K, K, K, K] | [K, K, K, K, K, K] | [K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K] | [K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K, K];
+export type SystemKeys<S extends System, K extends Extract<keyof S, string> = Extract<keyof S, string>> = LongTuple<K>;
+export type ValueForKey<S extends System, K extends keyof S> = S[K] extends RealmNode<infer V> ? V : never;
+export type SystemDict<S extends System> = {
+    [K in keyof S]?: ValueForKey<S, K>;
+};
+export type SystemKeysArray<S extends System> = Array<keyof S>;
+export interface TypedRealm<S extends System> extends Pick<Realm, 'sub' | 'pub' | 'spread' | 'derive' | 'singletonSubKey' | 'resetSingletonSubs'> {
+    getKeyValues<K extends SystemKeys<S>>(keys: K): ValuesForKeys<S, K>;
+    getKeyValue<K extends keyof S>(key: K): ValueForKey<S, K>;
+    labels: S;
+    pubKey<K extends keyof S>(key: K, value: ValueForKey<S, K>): void;
+    pubKeys: (values: SystemDict<S>) => void;
+    subKey<K extends keyof S>(key: K, subscription: Subscription<ValueForKey<S, K>>): UnsubscribeHandle;
+    subKeys<K extends SystemKeys<S>>(keys: K, subscription: Subscription<ValuesForKeys<S, K>>): UnsubscribeHandle;
+}
+export declare function realmFactory<Specs extends LongTuple<AnySystemSpec>>(...specs: Specs): TypedRealm<SystemOfSpecs<Specs>>;
+export type RealmFactory<Sys extends System> = () => TypedRealm<Sys>;
+export declare function getRealmFactory<Specs extends LongTuple<AnySystemSpec>>(...specs: Specs): () => TypedRealm<SystemOfSpecs<[...Specs]>>;
+export {};

package/dist/gurx/realmFactory.js

@@ -0,0 +1,32 @@
+import { uuidv4 } from "../utils/uuid4.js";
+import { realm } from "./realm.js";
+function system(constructor, dependencies = []) {
+  return {
+    constructor,
+    dependencies,
+    id: uuidv4()
+  };
+}
+function realmFactory(...specs) {
+  const singletons = /* @__PURE__ */ new Map();
+  const r = realm();
+  const _init = ({ id, constructor, dependencies }) => {
+    if (singletons.has(id)) {
+      return singletons.get(id);
+    }
+    const system2 = constructor(r, dependencies.map((t) => _init(specs.find((spec) => spec.id === t.id))));
+    r.label(system2);
+    singletons.set(id, system2);
+    return system2;
+  };
+  specs.forEach(_init);
+  return r;
+}
+function getRealmFactory(...specs) {
+  return () => realmFactory(...specs);
+}
+export {
+  getRealmFactory,
+  realmFactory,
+  system
+};

package/dist/icons/add_column.svg.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const SvgAddColumn = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 20, height: 20, fill: "currentColor", viewBox: "0 0 20 20", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 20, height: 20, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h20v20H0z", transform: "matrix(0 -1 -1 0 20 20)" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M3.25 10.5H6v2.75h1.5V10.5h2.75V9H7.5V6.25H6V9H3.25v1.5ZM6 17h8V3H6v2.5h1.5v-1h5v11h-5V14H6v3Z" })));
+const AddColumnIcon = SvgAddColumn;
+export {
+  AddColumnIcon as default
+};

package/dist/icons/add_photo.svg.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const SvgAddPhoto = (props) => /* @__PURE__ */ React.createElement("svg", { width: 24, height: 24, viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "mask0_343_38", style: {
+  maskType: "alpha"
+}, maskUnits: "userSpaceOnUse", x: 0, y: 0, width: 24, height: 24 }, /* @__PURE__ */ React.createElement("rect", { width: 24, height: 24, fill: "#D9D9D9" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#mask0_343_38)" }, /* @__PURE__ */ React.createElement("path", { d: "M3 21V3H14V5H5V19H19V10H21V21H3ZM17 9V7H15V5H17V3H19V5H21V7H19V9H17ZM6 17H18L14.25 12L11.25 16L9 13L6 17Z", fill: "currentColor" })));
+const AddPhotoIcon = SvgAddPhoto;
+export {
+  AddPhotoIcon as default
+};

package/dist/icons/add_row.svg.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const SvgAddRow = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 20, height: 20, fill: "currentColor", viewBox: "0 0 20 20", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 20, height: 20, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M20 20h20v20H20z", transform: "rotate(180 20 20)" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M10.5 3.25V6h2.75v1.5H10.5v2.75H9V7.5H6.25V6H9V3.25h1.5ZM17 6v8H3V6h2.5v1.5h-1v5h11v-5H14V6h3Z" })));
+const AddRowIcon = SvgAddRow;
+export {
+  AddRowIcon as default
+};

package/dist/icons/arrow_drop_down.svg.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const SvgArrowDropDown = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "m12 15-5-5h10l-5 5Z" })));
+const DropDownIcon = SvgArrowDropDown;
+export {
+  DropDownIcon as default
+};

package/dist/icons/arrow_right.svg.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const SvgArrowRight = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M10 17V7l5 5-5 5Z" })));
+const ArrowRight = SvgArrowRight;
+export {
+  ArrowRight as default
+};

package/dist/icons/check.svg.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const SvgCheck = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "m9.55 18-5.7-5.7 1.425-1.425L9.55 15.15l9.175-9.175L20.15 7.4 9.55 18Z" })));
+const CheckIcon = SvgCheck;
+export {
+  CheckIcon as default
+};

package/dist/icons/close.svg.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const SvgClose = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M6.4 19 5 17.6l5.6-5.6L5 6.4 6.4 5l5.6 5.6L17.6 5 19 6.4 13.4 12l5.6 5.6-1.4 1.4-5.6-5.6L6.4 19Z" })));
+const CloseIcon = SvgClose;
+export {
+  CloseIcon as default
+};

package/dist/icons/code.svg.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const SvgCode = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "m8 18-6-6 6-6 1.425 1.425-4.6 4.6L9.4 16.6 8 18Zm8 0-1.425-1.425 4.6-4.6L14.6 7.4 16 6l6 6-6 6Z" })));
+const CodeIcon = SvgCode;
+export {
+  CodeIcon as default
+};

package/dist/icons/content_copy.svg.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const SvgContentCopy = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M7 18V2h13v16H7Zm2-2h9V4H9v12Zm-6 6V6h2v14h11v2H3Z" })));
+const CopyIcon = SvgContentCopy;
+export {
+  CopyIcon as default
+};

package/dist/icons/delete.svg.js

@@ -0,0 +1,8 @@
+import * as React from "react";
+const SvgDelete = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M5 21V6H4V4h5V3h6v1h5v2h-1v15H5Zm2-2h10V6H7v13Zm2-2h2V8H9v9Zm4 0h2V8h-2v9Z" })));
+const DeleteIcon = SvgDelete;
+export {
+  DeleteIcon as default
+};