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

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

@@ -1,31 +0,0 @@
-'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

@@ -1,460 +0,0 @@
-'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

@@ -1,7 +0,0 @@
-'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;