@soul-refiner/design-system 2.0.0-alpha.2 → 2.0.0-alpha.20

package/dist/node_modules/optics-ts/dist/mjs/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var internals = require('./internals.js');
+
+/* eslint-disable @typescript-eslint/adjacent-overload-signatures, @typescript-eslint/no-unused-vars */
+// This file is generated, do not edit! See ../scripts/generate-index.ts
+function optic() {
+    return internals.optic;
+}
+function get(optic) {
+    return (source) => internals.get(optic._ref, source);
+}
+function preview(optic) {
+    return (source) => internals.preview(optic._ref, source);
+}
+function collect(optic) {
+    return (source) => internals.collect(optic._ref, source);
+}
+function modify(optic) {
+    return (f) => (source) => internals.modify(optic._ref, f, source);
+}
+function set(optic) {
+    return (value) => (source) => internals.set(optic._ref, value, source);
+}
+
+exports.collect = collect;
+exports.get = get;
+exports.modify = modify;
+exports.optic = optic;
+exports.preview = preview;
+exports.set = set;

package/dist/node_modules/optics-ts/dist/mjs/internals.js

@@ -0,0 +1,460 @@
+'use strict';
+
+(undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const id = (x) => x;
+const Left = (value) => ({
+    _tag: 'Left',
+    value,
+});
+const Right = (value) => ({
+    _tag: 'Right',
+    value,
+});
+const either = (mapLeft, mapRight, e) => (e._tag === 'Left' ? mapLeft(e.value) : mapRight(e.value));
+const profunctorFn = {
+    dimap: (f, g, fn) => (x) => g(fn(f(x))),
+    first: (f) => ([x, y]) => [f(x), y],
+    right: (f) => (e) => e._tag === 'Left' ? e : Right(f(e.value)),
+    wander: (f) => (xs) => xs.map(f),
+};
+const monoidFirst = {
+    empty: () => undefined,
+    foldMap: (f, xs) => {
+        for (let i = 0; i < xs.length; i++) {
+            const x = f(xs[i]);
+            if (x != undefined)
+                return x;
+        }
+        return undefined;
+    },
+};
+const monoidArray = {
+    empty: () => [],
+    foldMap: (f, xs) => {
+        let acc = [];
+        xs.forEach((x) => {
+            acc = acc.concat(f(x));
+        });
+        return acc;
+    },
+};
+const profunctorConst = (monoid) => ({
+    dimap: (f, _g, toF) => (x) => toF(f(x)),
+    first: (toF) => ([x, _y]) => toF(x),
+    right: (toF) => (e) => e._tag === 'Left' ? monoid.empty() : toF(e.value),
+    wander: (toF) => (xs) => monoid.foldMap(toF, xs),
+});
+const compositionType = {
+    Equivalence: {
+        Equivalence: 'Equivalence',
+        Iso: 'Iso',
+        Lens: 'Lens',
+        Prism: 'Prism',
+        Traversal: 'Traversal',
+        Getter: 'Getter',
+        AffineFold: 'AffineFold',
+        Fold: 'Fold',
+        Setter: 'Setter',
+    },
+    Iso: {
+        Equivalence: 'Iso',
+        Iso: 'Iso',
+        Lens: 'Lens',
+        Prism: 'Prism',
+        Traversal: 'Traversal',
+        Getter: 'Getter',
+        AffineFold: 'AffineFold',
+        Fold: 'Fold',
+        Setter: 'Setter',
+    },
+    Lens: {
+        Equivalence: 'Lens',
+        Iso: 'Lens',
+        Lens: 'Lens',
+        Prism: 'Prism',
+        Traversal: 'Traversal',
+        Getter: 'Getter',
+        AffineFold: 'AffineFold',
+        Fold: 'Fold',
+        Setter: 'Setter',
+    },
+    Prism: {
+        Equivalence: 'Prism',
+        Iso: 'Prism',
+        Lens: 'Prism',
+        Prism: 'Prism',
+        Traversal: 'Traversal',
+        Getter: 'AffineFold',
+        AffineFold: 'AffineFold',
+        Fold: 'Fold',
+        Setter: 'Setter',
+    },
+    Traversal: {
+        Equivalence: 'Traversal',
+        Iso: 'Traversal',
+        Lens: 'Traversal',
+        Prism: 'Traversal',
+        Traversal: 'Traversal',
+        Getter: 'Fold',
+        AffineFold: 'Fold',
+        Fold: 'Fold',
+        Setter: 'Setter',
+    },
+    Getter: {
+        Equivalence: 'Getter',
+        Iso: 'Getter',
+        Lens: 'Getter',
+        Prism: 'AffineFold',
+        Traversal: 'Fold',
+        Getter: 'Getter',
+        AffineFold: 'AffineFold',
+        Fold: 'Fold',
+        Setter: undefined,
+    },
+    AffineFold: {
+        Equivalence: 'AffineFold',
+        Iso: 'AffineFold',
+        Lens: 'AffineFold',
+        Prism: 'AffineFold',
+        Traversal: 'Fold',
+        Getter: 'AffineFold',
+        AffineFold: 'AffineFold',
+        Fold: 'Fold',
+        Setter: undefined,
+    },
+    Fold: {
+        Equivalence: 'Fold',
+        Iso: 'Fold',
+        Lens: 'Fold',
+        Prism: 'Fold',
+        Traversal: 'Fold',
+        Getter: 'Fold',
+        AffineFold: 'Fold',
+        Fold: 'Fold',
+        Setter: undefined,
+    },
+    Setter: {
+        Equivalence: undefined,
+        Iso: undefined,
+        Lens: undefined,
+        Prism: undefined,
+        Traversal: undefined,
+        Getter: undefined,
+        AffineFold: undefined,
+        Fold: undefined,
+        Setter: undefined,
+    },
+};
+const withTag = (tag, optic) => {
+    const result = optic;
+    result._tag = tag;
+    return result;
+};
+const removable = (optic) => {
+    optic._removable = true;
+    return optic;
+};
+function compose(optic1, optic2, optic3) {
+    switch (arguments.length) {
+        case 2: {
+            const next = (P, optic) => optic1(P, optic2(P, optic));
+            next._tag = compositionType[optic1._tag][optic2._tag];
+            next._removable = optic2._removable || false;
+            return next;
+        }
+        default: {
+            const tag1 = compositionType[optic1._tag][optic2._tag];
+            const next = (P, optic) => optic1(P, optic2(P, optic3(P, optic)));
+            next._tag = compositionType[tag1][optic3._tag];
+            next._removable = optic3._removable || false;
+            return next;
+        }
+    }
+}
+const eq = /* @__PURE__ */ withTag('Equivalence', (_P, optic) => optic);
+const iso = (there, back) => withTag('Iso', (P, optic) => P.dimap(there, back, optic));
+const lens = (view, update) => withTag('Lens', (P, optic) => P.dimap((x) => [view(x), x], update, P.first(optic)));
+const prism = (match, build) => withTag('Prism', (P, optic) => P.dimap(match, (x) => either(id, build, x), P.right(optic)));
+const elems = /* @__PURE__ */ withTag('Traversal', (P, optic) => P.dimap(id, id, P.wander(optic)));
+const to = (fn) => withTag('Getter', (P, optic) => P.dimap(fn, id, optic));
+/////////////////////////////////////////////////////////////////////////////
+const modify = (optic, fn, source) => optic(profunctorFn, fn)(source);
+const set = (optic, value, source) => optic(profunctorFn, () => value)(source);
+const get = (optic, source) => optic(profunctorConst({}), id)(source);
+const preview = (optic, source) => optic(profunctorConst(monoidFirst), id)(source);
+const collect = (optic, source) => optic(profunctorConst(monoidArray), (x) => [x])(source);
+/////////////////////////////////////////////////////////////////////////////
+const indexed = /* @__PURE__ */ iso((value) => value.map((v, k) => [k, v]), (value) => {
+    const sorted = [...value].sort((a, b) => a[0] - b[0]);
+    const result = [];
+    for (let i = 0; i < sorted.length; ++i) {
+        if (i === sorted.length - 1 || sorted[i][0] !== sorted[i + 1][0]) {
+            result.push(sorted[i][1]);
+        }
+    }
+    return result;
+});
+const prop = (key) => lens((source) => source[key], ([value, source]) => (Object.assign(Object.assign({}, source), { [key]: value })));
+const pick = (keys) => lens((source) => {
+    const value = {};
+    for (const key of keys) {
+        value[key] = source[key];
+    }
+    return value;
+}, ([value, source]) => {
+    const result = Object.assign({}, source);
+    for (const key of keys) {
+        delete result[key];
+    }
+    return Object.assign(result, value);
+});
+const nth = (n) => lens((value) => value[n], ([value, source]) => {
+    const result = source.slice();
+    result[n] = value;
+    return result;
+});
+const fst = /* @__PURE__ */ nth(0);
+const when = (pred) => prism((x) => (pred(x) ? Right(x) : Left(x)), id);
+const noMatch = /* @__PURE__ */ Symbol('__no_match__');
+const mustMatch = /* @__PURE__ */ when((source) => source !== noMatch);
+const removeMe = /* @__PURE__ */ Symbol('__remove_me__');
+const at = (i) => removable(compose(lens((source) => (0 <= i && i < source.length ? source[i] : noMatch), ([value, source]) => {
+    if (value === noMatch) {
+        return source;
+    }
+    if (value === removeMe) {
+        if (typeof source === 'string') {
+            return source.substring(0, i) + source.substring(i + 1);
+        }
+        else {
+            return [...source.slice(0, i), ...source.slice(i + 1)];
+        }
+    }
+    if (typeof source === 'string') {
+        if (i === 0) {
+            return value + source.substring(1);
+        }
+        if (i === source.length) {
+            return source.substring(0, i - 1) + value;
+        }
+        return source.substring(0, i) + value + source.substring(i + 1);
+    }
+    else {
+        const result = source.slice();
+        result[i] = value;
+        return result;
+    }
+}), mustMatch));
+const optional = /* @__PURE__ */ prism((source) => (source === undefined ? Left(undefined) : Right(source)), id);
+const guard = (fn) => prism((source) => (fn(source) ? Right(source) : Left(source)), id);
+const find = (predicate) => removable(compose(lens((source) => {
+    const index = source.findIndex(predicate);
+    if (index === -1) {
+        return [noMatch, -1];
+    }
+    return [source[index], index];
+}, ([[value, index], source]) => {
+    if (value === noMatch) {
+        return source;
+    }
+    if (value === removeMe) {
+        return [...source.slice(0, index), ...source.slice(index + 1)];
+    }
+    const result = source.slice();
+    result[index] = value;
+    return result;
+}), fst, mustMatch));
+const filter = (predicate) => compose(lens((source) => {
+    const indexes = source
+        .map((item, index) => (predicate(item) ? index : null))
+        .filter((index) => index != null);
+    return [indexes.map((index) => source[index]), indexes];
+}, ([[values, indexes], source]) => {
+    const sn = source.length, vn = values.length;
+    let si = 0, ii = 0, vi = 0;
+    const result = [];
+    while (si < sn) {
+        if (indexes[ii] === si) {
+            ++ii;
+            if (vi < vn) {
+                result.push(values[vi]);
+                ++vi;
+            }
+        }
+        else {
+            result.push(source[si]);
+        }
+        ++si;
+    }
+    while (vi < vn) {
+        result.push(values[vi++]);
+    }
+    return result;
+}), fst);
+const valueOr = (defaultValue) => lens((source) => (source === undefined ? defaultValue : source), ([value, _source]) => value);
+const partsOf = (traversal) => compose(lens((source) => {
+    const value = collect(traversal, source);
+    return [value, value.length];
+}, ([[value, originalLength], source]) => {
+    if (value.length !== originalLength) {
+        throw new Error('cannot add/remove elements through partsOf');
+    }
+    let i = 0;
+    return modify(traversal, () => value[i++], source);
+}), fst);
+const reread = (fn) => lens((source) => fn(source), ([value, _]) => value);
+const rewrite = (fn) => lens((source) => source, ([value, _]) => fn(value));
+const prependTo = /* @__PURE__ */ lens((_source) => undefined, ([value, source]) => {
+    if (value === undefined)
+        return source;
+    return [value, ...source];
+});
+const appendTo = /* @__PURE__ */ lens((_source) => undefined, ([value, source]) => {
+    if (value === undefined)
+        return source;
+    return [...source, value];
+});
+const chars = /* @__PURE__ */ compose(iso((s) => s.split(''), (a) => a.join('')), elems);
+const words = /* @__PURE__ */ compose(iso((s) => s.split(/\b/), (a) => a.join('')), elems, when((s) => !/\s+/.test(s)));
+/////////////////////////////////////////////////////////////////////////////
+class Optic {
+    constructor(_ref) {
+        this._ref = _ref;
+    }
+    get _tag() {
+        return this._ref._tag;
+    }
+    get _removable() {
+        return this._ref._removable;
+    }
+    compose(other) {
+        return new Optic(compose(this._ref, other._ref));
+    }
+    iso(there, back) {
+        return new Optic(compose(this._ref, iso(there, back)));
+    }
+    lens(view, set) {
+        return new Optic(compose(this._ref, lens(view, ([value, source]) => set(source, value))));
+    }
+    indexed() {
+        return new Optic(compose(this._ref, indexed));
+    }
+    prop(key) {
+        return new Optic(compose(this._ref, prop(key)));
+    }
+    path(...keys) {
+        if (keys.length === 1) {
+            keys = keys[0].split('.');
+        }
+        return new Optic(keys.reduce((ref, key) => compose(ref, prop(key)), this._ref));
+    }
+    pick(keys) {
+        return new Optic(compose(this._ref, pick(keys)));
+    }
+    nth(n) {
+        return new Optic(compose(this._ref, nth(n)));
+    }
+    filter(predicate) {
+        return new Optic(compose(this._ref, filter(predicate)));
+    }
+    valueOr(defaultValue) {
+        return new Optic(compose(this._ref, valueOr(defaultValue)));
+    }
+    partsOf(traversalOrFn) {
+        const traversal = typeof traversalOrFn === 'function' ? traversalOrFn(optic) : traversalOrFn;
+        return new Optic(compose(this._ref, partsOf(traversal._ref)));
+    }
+    reread(fn) {
+        return new Optic(compose(this._ref, reread(fn)));
+    }
+    rewrite(fn) {
+        return new Optic(compose(this._ref, rewrite(fn)));
+    }
+    optional() {
+        return new Optic(compose(this._ref, optional));
+    }
+    guard_() {
+        return (fn) => this.guard(fn);
+    }
+    guard(fn) {
+        return new Optic(compose(this._ref, guard(fn)));
+    }
+    at(i) {
+        return new Optic(compose(this._ref, at(i)));
+    }
+    head() {
+        return new Optic(compose(this._ref, at(0)));
+    }
+    index(i) {
+        return new Optic(compose(this._ref, at(i)));
+    }
+    find(predicate) {
+        return new Optic(compose(this._ref, find(predicate)));
+    }
+    elems() {
+        return new Optic(compose(this._ref, elems));
+    }
+    to(fn) {
+        return new Optic(compose(this._ref, to(fn)));
+    }
+    when(predicate) {
+        return new Optic(compose(this._ref, when(predicate)));
+    }
+    chars() {
+        return new Optic(compose(this._ref, chars));
+    }
+    words() {
+        return new Optic(compose(this._ref, words));
+    }
+    prependTo() {
+        return new Optic(compose(this._ref, prependTo));
+    }
+    appendTo() {
+        return new Optic(compose(this._ref, appendTo));
+    }
+}
+const optic = /* @__PURE__ */ new Optic(eq);
+
+exports.Optic = Optic;
+exports.appendTo = appendTo;
+exports.at = at;
+exports.chars = chars;
+exports.collect = collect;
+exports.compositionType = compositionType;
+exports.elems = elems;
+exports.eq = eq;
+exports.filter = filter;
+exports.find = find;
+exports.get = get;
+exports.guard = guard;
+exports.id = id;
+exports.indexed = indexed;
+exports.iso = iso;
+exports.lens = lens;
+exports.modify = modify;
+exports.nth = nth;
+exports.optic = optic;
+exports.optional = optional;
+exports.partsOf = partsOf;
+exports.pick = pick;
+exports.prependTo = prependTo;
+exports.preview = preview;
+exports.prop = prop;
+exports.reread = reread;
+exports.rewrite = rewrite;
+exports.set = set;
+exports.to = to;
+exports.valueOr = valueOr;
+exports.when = when;
+exports.words = words;

package/dist/node_modules/proxy-compare/dist/index.modern.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const e=Symbol(),t=Symbol(),r="a",n="w";let o=(e,t)=>new Proxy(e,t);const s=Object.getPrototypeOf,c=new WeakMap,l=e=>e&&(c.has(e)?c.get(e):s(e)===Object.prototype||s(e)===Array.prototype),f=e=>"object"==typeof e&&null!==e,i=new WeakMap,a=e=>e[t]||e,u=(c,f,p)=>{if(!l(c))return c;const y=a(c),g=(e=>Object.isFrozen(e)||Object.values(Object.getOwnPropertyDescriptors(e)).some(e=>!e.writable))(y);let h=p&&p.get(y);return h&&h[1].f===g||(h=((o,s)=>{const c={f:s};let l=!1;const f=(e,t)=>{if(!l){let s=c[r].get(o);if(s||(s={},c[r].set(o,s)),e===n)s[n]=!0;else {let r=s[e];r||(r=new Set,s[e]=r),r.add(t);}}},i={get:(e,n)=>n===t?o:(f("k",n),u(Reflect.get(e,n),c[r],c.c)),has:(t,n)=>n===e?(l=!0,c[r].delete(o),!0):(f("h",n),Reflect.has(t,n)),getOwnPropertyDescriptor:(e,t)=>(f("o",t),Reflect.getOwnPropertyDescriptor(e,t)),ownKeys:e=>(f(n),Reflect.ownKeys(e))};return s&&(i.set=i.deleteProperty=()=>!1),[i,c]})(y,g),h[1].p=o(g?(e=>{let t=i.get(e);if(!t){if(Array.isArray(e))t=Array.from(e);else {const r=Object.getOwnPropertyDescriptors(e);Object.values(r).forEach(e=>{e.configurable=!0;}),t=Object.create(s(e),r);}i.set(e,t);}return t})(y):y,h[0]),p&&p.set(y,h)),h[1][r]=f,h[1].c=p,h[1].p},p=(e,t,r,o)=>{if(Object.is(e,t))return !1;if(!f(e)||!f(t))return !0;const s=r.get(a(e));if(!s)return !0;if(o){const r=o.get(e);if(r&&r.n===t)return r.g;o.set(e,{n:t,g:!1});}let c=null;try{for(const r of s.h||[])if(c=Reflect.has(e,r)!==Reflect.has(t,r),c)return c;if(!0===s[n]){if(c=((e,t)=>{const r=Reflect.ownKeys(e),n=Reflect.ownKeys(t);return r.length!==n.length||r.some((e,t)=>e!==n[t])})(e,t),c)return c}else for(const r of s.o||[])if(c=!!Reflect.getOwnPropertyDescriptor(e,r)!=!!Reflect.getOwnPropertyDescriptor(t,r),c)return c;for(const n of s.k||[])if(c=p(e[n],t[n],r,o),c)return c;return null===c&&(c=!0),c}finally{o&&o.set(e,{n:t,g:c});}},w=(e,t,r)=>{const o=[],s=new WeakSet,c=(e,l)=>{if(s.has(e))return;f(e)&&s.add(e);const i=f(e)&&t.get(a(e));if(i){var u,p;if(null==(u=i.h)||u.forEach(e=>{const t=`:has(${String(e)})`;o.push(l?[...l,t]:[t]);}),!0===i[n]){const e=":ownKeys";o.push(l?[...l,e]:[e]);}else {var y;null==(y=i.o)||y.forEach(e=>{const t=`:hasOwn(${String(e)})`;o.push(l?[...l,t]:[t]);});}null==(p=i.k)||p.forEach(t=>{r&&!("value"in(Object.getOwnPropertyDescriptor(e,t)||{}))||c(e[t],l?[...l,t]:[t]);});}else l&&o.push(l);};return c(e),o};
+
+exports.affectedToPathList = w;
+exports.createProxy = u;
+exports.isChanged = p;