@design-edito/tools 0.1.71 → 0.1.72

package/utils/agnostic/regexp/index.d.ts

@@ -0,0 +1,21 @@
+export declare function mergeFlags(...flagStrs: string[]): string;
+export declare function setFlags(regexp: RegExp, _flags: string): RegExp;
+export declare function fromStart(regexp: RegExp, _flags?: string): RegExp;
+export declare function toEnd(regexp: RegExp, _flags?: string): RegExp;
+export declare function fromStartToEnd(regexp: RegExp, _flags?: string): RegExp;
+export declare function stringStartsWith(string: string, _regexp: RegExp): boolean;
+export declare function stringStartsWith(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+export declare function stringStartsWith(string: string, _regexp: RegExp, returnMatches: false): boolean;
+export declare function stringStartsWith(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+export declare function stringStartsWith(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+export declare function stringEndsWith(string: string, _regexp: RegExp): boolean;
+export declare function stringEndsWith(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+export declare function stringEndsWith(string: string, _regexp: RegExp, returnMatches: false): boolean;
+export declare function stringEndsWith(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+export declare function stringEndsWith(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+export declare function stringIs(string: string, _regexp: RegExp): boolean;
+export declare function stringIs(string: string, _regexp: RegExp, returnMatches: true): RegExpMatchArray | null;
+export declare function stringIs(string: string, _regexp: RegExp, returnMatches: false): boolean;
+export declare function stringIs(string: string, _regexp: RegExp, returnMatches: false, _flags: string): boolean;
+export declare function stringIs(string: string, _regexp: RegExp, returnMatches: true, _flags: string): RegExpMatchArray | null;
+export declare function stringsToRegexp(strings: string[]): RegExp;

package/utils/agnostic/regexp/index.js

@@ -0,0 +1 @@
+function i(...t){let n=new Set;return t.forEach(e=>e.split("").forEach(r=>n.add(r))),[...n.values()].join("")}function M(t,n){let e=i(t.flags,n);return new RegExp(`${t.source}`,e)}function x(t,n="g"){let e=i(t.flags,n);return new RegExp(`^(${t.source})`,e)}function c(t,n="g"){let e=i(t.flags,n);return new RegExp(`(${t.source})$`,e)}function R(t,n="g"){let e=i(t.flags,n);return x(c(t,e),e)}function d(t,n,e=!0,r="g"){let s=x(n,r);return e?t.match(s):s.test(t)}function _(t,n,e=!0,r="g"){let s=c(n,r);return e?t.match(s):s.test(t)}function b(t,n,e=!1,r="g"){let s=R(n,r);return e?t.match(s):s.test(t)}function W(t){let n=a(t),e=f(n,!1);return new RegExp(e)}function l(t){return t.replace(/\s/igm,"\\s").replace(/\n/igm,"\\n").replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}function a(t,n=new Map){return t.sort((r,s)=>r.length-s.length).forEach(r=>{let[s,...g]=r,E=g.length===0;if(s===void 0)return;let p=[...n.keys()].find(o=>new RegExp(`^(${l(o)})`).test(r)),u=p!==void 0?n.get(p)?.subRootsMap:void 0;if(p===void 0||u===void 0){let o=new Map;return a([g.join("")],o),n.set(s,{subRootsMap:o,isWordEnd:E})}a([g.join("")],u)}),n}function f(t,n){let e=[...t.entries()];if(e.length===0)return"";let r=e.map(([s,g])=>`${l(s)}${f(g.subRootsMap,g.isWordEnd)}`).join("|");return n?`(${r})?`:`(${r})`}export{x as fromStart,R as fromStartToEnd,i as mergeFlags,M as setFlags,_ as stringEndsWith,b as stringIs,d as stringStartsWith,W as stringsToRegexp,c as toEnd};

package/utils/agnostic/replace-all/index.d.ts

@@ -0,0 +1 @@
+export default function replaceAll(input: string, pattern: string | RegExp, replacer: string | ((substring: string, ...args: any[]) => string), maxOps?: number): string;

package/utils/agnostic/replace-all/index.js

@@ -0,0 +1 @@
+function l(s,n,e,g=1e3){let t=s,i=0;for(;t.match(n)&&i<g;)i++,t=t.replace(n,e);return t}export{l as default};

package/utils/agnostic/responsive-harmonics/index.d.ts

@@ -0,0 +1,10 @@
+export declare function getHarmonic(min: number, max: number, level: number, steps: number): number;
+type ScaleDescriptor = {
+    screenBounds: [number, number];
+    lowLevel: [number, number];
+    highLevel: [number, number];
+    steps: number;
+    clamp?: boolean;
+};
+export declare function createScale(descriptor: ScaleDescriptor): (level: number) => string | undefined;
+export {};

package/utils/agnostic/responsive-harmonics/index.js

@@ -0,0 +1 @@
+import{a as c}from"../../../chunks/chunk-BW5CY5YB.js";function p(e,n,t,r){if(e===0)return console.warn("Cannot generate harmonics if min value is zero"),NaN;if(r<1)return console.warn("Cannot generate harmonics if steps is lower than one"),NaN;let o=n/e,u=1/parseInt(`${r}`),i=Math.pow(o,u);return e*Math.pow(i,t)}function h(e,n,t,r){let o=(r-n)/(t-e),u=n-e*o;return{slope:o,yIntercept:u}}function v(e){let{slope:n,yIntercept:t}=e,r=c(100*n,3),o=c(t,2);return`calc(${r}vw + ${o}px)`}function g(e){let{screenBounds:[n,t],lowLevel:[r,o],highLevel:[u,i],steps:s,clamp:b}=e;return function(m){if(s<2)return;let a=p(r,u,m-1,s-1),l=p(o,i,m-1,s-1);if(a===void 0||l===void 0)return;let d=h(n,a,t,l),f=v(d);return b===!0?`clamp(${c(a,2)}px, ${f}, ${c(l,2)}px)`:f}}export{g as createScale,p as getHarmonic};

package/utils/agnostic/round-numbers/index.d.ts

@@ -0,0 +1 @@
+export default function roundNumbers(number: number, nbDecimals: number): number;

package/utils/agnostic/round-numbers/index.js

@@ -0,0 +1 @@
+import{a}from"../../../chunks/chunk-BW5CY5YB.js";export{a as default};

package/utils/agnostic/selector-to-element/index.d.ts

@@ -0,0 +1 @@
+export default function selectorToElement(selector: string, documentObj?: Document): Promise<HTMLElement>;

package/utils/agnostic/selector-to-element/index.js

@@ -0,0 +1 @@
+import{c as o}from"../../../chunks/chunk-LCLAV6Q2.js";async function x(e,m){let i=m??await o(),l=/^[A-Za-z]+/,d=/#[A-Za-z]+[\w\-\:]*/,r=/\.[A-Za-z]+[\w\-]*/,u=/\[[A-Za-z]+[\w\-]*(="[\w\-]+")?\]/,a=e.match(l)??[],n=e.match(d)??[],p=e.match(r)??[],g=e.match(u)??[],h=a[a.length-1]??"div",s=n[n.length-1]??null,f=p.map(t=>t.replace(/^\./,"")),A=g.map(t=>t.replace(/^\[/,"").replace(/\]$/,"").split("=")),c=i.createElement(h);return s!==null&&(c.id=s),c.classList.add(...f),A.forEach(([t,w=""])=>{t!==void 0&&c.setAttribute(t,w)}),c}export{x as default};

package/utils/agnostic/silent-log/index.d.ts

@@ -0,0 +1,53 @@
+export declare function makeTextBlock(text: string, vPadding?: number, hPadding?: number): string;
+export declare const styles: {
+    regular: (text: string) => string;
+    light: (text: string) => string;
+    danger: (text: string) => string;
+    important: (text: string) => string;
+    title: (text: string) => string;
+    info: (text: string) => string;
+    error: (text: string) => string;
+    warning: (text: string) => string;
+};
+type ConsoleMethod = 'assert' | 'count' | 'countReset' | 'debug' | 'dir' | 'dirxml' | 'error' | 'group' | 'groupCollapsed' | 'groupEnd' | 'info' | 'log' | 'table' | 'time' | 'timeEnd' | 'trace' | 'warn';
+type ConsoleMethodsParams = {
+    assert: Parameters<typeof console.assert>;
+    count: Parameters<typeof console.count>;
+    countReset: Parameters<typeof console.countReset>;
+    debug: Parameters<typeof console.debug>;
+    dir: Parameters<typeof console.dir>;
+    dirxml: Parameters<typeof console.dirxml>;
+    error: Parameters<typeof console.error>;
+    group: Parameters<typeof console.group>;
+    groupCollapsed: Parameters<typeof console.groupCollapsed>;
+    groupEnd: Parameters<typeof console.groupEnd>;
+    info: Parameters<typeof console.info>;
+    log: Parameters<typeof console.log>;
+    table: Parameters<typeof console.table>;
+    time: Parameters<typeof console.time>;
+    timeEnd: Parameters<typeof console.timeEnd>;
+    trace: Parameters<typeof console.trace>;
+    warn: Parameters<typeof console.warn>;
+};
+declare class Log<T extends ConsoleMethod = ConsoleMethod> {
+    type: T;
+    data: ConsoleMethodsParams[T];
+    time: Date;
+    stack: string;
+    constructor(type: T, data: ConsoleMethodsParams[T]);
+    get displayTime(): string;
+    get elapsedTimeMs(): number;
+    get displayStack(): string;
+}
+export default class Logger {
+    _private_threads: Map<string, Log[]>;
+    constructor();
+    dir(thread: string | undefined, ...args: ConsoleMethodsParams['dir']): void;
+    error(thread?: string, ...args: ConsoleMethodsParams['error']): void;
+    log(thread?: string, ...args: ConsoleMethodsParams['log']): void;
+    warn(thread?: string, ...args: ConsoleMethodsParams['warn']): void;
+    setLog<T extends ConsoleMethod>(threadName: string, type: T, data: ConsoleMethodsParams[T]): this;
+    print(this: Logger, threadFilter?: string, withStack?: boolean): void;
+    printThreads(this: Logger, withStack?: boolean): void;
+}
+export {};

package/utils/agnostic/silent-log/index.js

@@ -0,0 +1,9 @@
+import a from"chalk";function d(t,e=1,o=e){let n=t.split(`
+`),r=Math.max(...n.map(i=>i.length)),s=new Array(n.length+2*e).fill(null).map(()=>new Array(r+o*2).fill(" "));return n.forEach((i,g)=>{let h=i.split("");s[g+e]?.splice(o,h.length,...h)}),s.map(i=>i.join("")).join(`
+`)}var u={regular:t=>t,light:t=>a.grey(t),danger:t=>a.bold.bgRed.whiteBright(d(`/!\\
+
+${t}
+`,2,6)),important:t=>a.bold(t),title:t=>`# ${a.bold.underline(`${t}
+`)}`,info:t=>a.blueBright(t),error:t=>a.red(t),warning:t=>a.yellow(t)},p=new Date,l=class{type;data;time;stack;constructor(e,o){this.type=e,this.data=o,this.time=new Date,this.stack=new Error().stack??""}get displayTime(){return this.time.toLocaleDateString("en-US",{year:"numeric",month:"short",day:"numeric",weekday:"short",hour:"numeric",minute:"numeric",second:"numeric"})+`:${this.time.getMilliseconds()}`}get elapsedTimeMs(){return(this.time.getTime()-p.getTime())/1e3}get displayStack(){return this.stack.split(`
+`).map(e=>e.trim()).slice(4).join(`
+`)}},c=class{_private_threads=new Map;constructor(){this.dir=this.dir.bind(this),this.error=this.error.bind(this),this.log=this.log.bind(this),this.warn=this.warn.bind(this),this.setLog=this.setLog.bind(this),this.print=this.print.bind(this),this.printThreads=this.printThreads.bind(this)}dir(e="",...o){this.setLog(e,"dir",o)}error(e="",...o){this.setLog(e,"error",o)}log(e="",...o){this.setLog(e,"log",o)}warn(e="",...o){this.setLog(e,"warn",o)}setLog(e,o,n){let r=new l(o,n),s=this._private_threads.get(e)??[];return this._private_threads.set(e,[...s,r]),this}print(e,o){[...this._private_threads.entries()].map(([r,s])=>s.map(i=>({threadName:r,log:i}))).flat().sort((r,s)=>r.log.time.getTime()-s.log.time.getTime()).filter(({threadName:r})=>e===void 0?!0:r===e).forEach(({threadName:r,log:s})=>{console.log(`%c${r}`,"font-weight: 800; color: white; background: black; padding: 4px;",`+${s.elapsedTimeMs}s \u2013`,s.displayTime),o===!0&&console.log(`%c${s.displayStack}`,"color: grey; font-size: inherit;"),console[s.type](...s.data),console.log("")})}printThreads(e){[...this._private_threads.entries()].forEach(([o,n])=>{console.group(`%c${o}`,"font-weight: 800; color: white; background: black; padding: 4px;"),n.forEach(r=>{console.log(`+${r.elapsedTimeMs}s \u2013`,r.displayTime),e===!0&&console.log(`%c${r.displayStack}`,"color: grey; font-size: inherit;"),console[r.type](...r.data),console.log("")}),console.groupEnd()})}};export{c as default,d as makeTextBlock,u as styles};

package/utils/agnostic/str-to-nodes/index.d.ts

@@ -0,0 +1,7 @@
+import { Options as SanitizerOptions } from '~/utils/agnostic/clientside-html-sanitizer';
+type Options = {
+    sanitize?: SanitizerOptions;
+    documentObj?: Document;
+};
+export default function strToNodes(dirtyStr: string, options?: Options): Promise<Node[]>;
+export {};

package/utils/agnostic/str-to-nodes/index.js

@@ -0,0 +1 @@
+import{b as i}from"../../../chunks/chunk-EFFU6KXJ.js";import{c as o}from"../../../chunks/chunk-LCLAV6Q2.js";async function a(n,e){let s=e?.documentObj??await o(),r=e?.sanitize!==void 0?await i(n,e.sanitize):n,t=s.createElement("div");return t.innerHTML=r,Array.from(t.childNodes).filter(d=>[Node.ELEMENT_NODE,Node.TEXT_NODE].includes(d.nodeType))}export{a as default};

package/utils/agnostic/string-matches/index.d.ts

@@ -0,0 +1,4 @@
+export default function stringMatches(input: string, matcher: string | RegExp): boolean;
+export { stringMatches };
+export declare function stringMatchesSome(input: string, matchers: string | RegExp | Array<string | RegExp>): boolean;
+export declare function stringMatchesEvery(input: string, matchers: string | RegExp | Array<string | RegExp>): boolean;

package/utils/agnostic/string-matches/index.js

@@ -0,0 +1 @@
+import{a,b,c}from"../../../chunks/chunk-KNE7WIIW.js";export{a as default,a as stringMatches,c as stringMatchesEvery,b as stringMatchesSome};

package/utils/agnostic/string-normalize-indent/index.d.ts

@@ -0,0 +1 @@
+export default function stringNormalizeIndent(input: string, indentLevel?: number): string;

package/utils/agnostic/string-normalize-indent/index.js

@@ -0,0 +1,3 @@
+function r(i,t=0){let s=" ".repeat(t);return i.split(`
+`).map(e=>e.replace(/^\s*/igm,"")).map(e=>{let n=e.match(/^\|+/igm)?.[0].length??0,p=e.slice(n);return" ".repeat(n)+p}).map(e=>s+e).join(`
+`)}export{r as default};

package/utils/agnostic/throttle-debounce/index.d.ts

@@ -0,0 +1,30 @@
+type BasicFunction = (...args: any[]) => any;
+/**
+ * Returns a throttled version of the function passed as an argument
+ * @param toThrottleFunc - The function that has to be throttled
+ * @param delayMs - The throttle delay in ms
+ */
+export declare function throttle<T extends BasicFunction = BasicFunction>(toThrottleFunc: T, delayMs: number): {
+    throttled: (...args: any[]) => {
+        returnValue: ReturnType<T> | undefined;
+        lastExecutedOn: number;
+        delayMs: number;
+        isCached: boolean;
+    };
+    setDelay: (delayMs: number) => void;
+};
+/**
+ * Returns a debounced version of the function passed as an argument
+ * @param toDebounceFunc - The function that has to be debounced
+ * @param delayMs - The debounce delay in ms
+ */
+export declare function debounce<T extends BasicFunction = BasicFunction>(toDebounceFunc: T, delayMs: number): {
+    debounced: (...args: any[]) => {
+        returnValue: ReturnType<T> | undefined;
+        lastExecutedOn: number;
+        delayMs: number;
+        isCached: boolean;
+    };
+    setDelay: (delayMs: number) => void;
+};
+export {};

package/utils/agnostic/throttle-debounce/index.js

@@ -0,0 +1 @@
+function T(s,c){let t=c,o=[],n=0,l,e=null;function r(){e!==null&&(clearTimeout(e),e=null);let a=Date.now(),i=n+t-a;e=setTimeout(()=>{e=null,l=s(...o),n=a},i)??null}function m(...a){let u=Date.now();return o=a,u-n>=c?(l=s(...o),n=u,{returnValue:l,lastExecutedOn:n,delayMs:t,isCached:!1}):(e===null&&r(),{returnValue:l,lastExecutedOn:n,delayMs:t,isCached:!0})}function d(a){t=a,e!==null&&r()}return{throttled:m,setDelay:d}}function y(s,c){let t=c,o=[],n=0,l=0,e,r=null;function m(){typeof r=="number"&&(clearTimeout(r),r=null);let u=Date.now(),x=n+t-u;r=setTimeout(()=>{r=null,e=s(...o),l=u},x)??null}function d(...u){let i=Date.now();return o=u,i-n>=t?(n=i,e=s(...o),l=i,{returnValue:e,lastExecutedOn:l,delayMs:t,isCached:!1}):(n=i,m(),{returnValue:e,lastExecutedOn:l,delayMs:t,isCached:!0})}function a(u){t=u,r!==null&&m()}return{debounced:d,setDelay:a}}export{y as debounce,T as throttle};

package/utils/agnostic/throttle-debounce/types.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { setTimeout } from 'node:timers';
+export type Timeout = ReturnType<typeof setTimeout>;

package/utils/agnostic/to-alphanum/index.d.ts

@@ -0,0 +1 @@
+export default function toAlphanum(string: string, replacer?: string): string;

package/utils/agnostic/to-alphanum/index.js

@@ -0,0 +1 @@
+function g(e,n=""){let t=e.replace(/[^a-z0-9]/igm,n);return n.length===0?t:t.replace(new RegExp(`${n}+`,"igm"),n)}export{g as default};

package/utils/agnostic/transition/index.d.ts

@@ -0,0 +1,39 @@
+export type Callback = (val: number, timeMs: number) => void;
+export declare enum Ease {
+    LINEAR = "linear",
+    EASE_IN_QUAD = "ease-in-quad",
+    EASE_OUT_QUAD = "ease-out-quad",
+    EASE_IN_OUT_QUAD = "ease-in-out-quad",
+    EASE_IN_CUBIC = "ease-in-cubic",
+    EASE_OUT_CUBIC = "ease-out-cubic",
+    EASE_IN_OUT_CUBIC = "ease-in-out-cubic",
+    EASE_IN_QUART = "ease-in-quart",
+    EASE_OUT_QUART = "ease-out-quart",
+    EASE_IN_OUT_QUART = "ease-in-out-quart",
+    EASE_IN_QUINT = "ease-in-quint",
+    EASE_OUT_QUINT = "ease-out-quint",
+    EASE_IN_OUT_QUINT = "ease-in-out-quint",
+    EASE_IN_SINE = "ease-in-sine",
+    EASE_OUT_SINE = "ease-out-sine",
+    EASE_IN_OUT_SINE = "ease-in-out-sine",
+    EASE_IN_EXPO = "ease-in-expo",
+    EASE_OUT_EXPO = "ease-out-expo",
+    EASE_IN_OUT_EXPO = "ease-in-out-expo",
+    EASE_IN_CIRC = "ease-in-circ",
+    EASE_OUT_CIRC = "ease-out-circ",
+    EASE_IN_OUT_CIRC = "ease-in-out-circ",
+    EASE_IN_BACK = "ease-in-back",
+    EASE_OUT_BACK = "ease-out-back",
+    EASE_IN_OUT_BACK = "ease-in-out-back",
+    EASE_IN_ELASTIC = "ease-in-elastic",
+    EASE_OUT_ELASTIC = "ease-out-elastic",
+    EASE_IN_OUT_ELASTIC = "ease-in-out-elastic",
+    EASE_IN_BOUNCE = "ease-in-bounce",
+    EASE_OUT_BOUNCE = "ease-out-bounce",
+    EASE_IN_OUT_BOUNCE = "ease-in-out-bounce"
+}
+export type EasingFunction = (progress: number) => number;
+export type EasingDictionary = Record<string, EasingFunction>;
+export default function transition(to: number, durationMs: number, callbackOrEase: Ease | Callback, callback?: Callback): Promise<void>;
+export declare const easingFunctions: EasingDictionary;
+export declare const easings: Record<Ease, ((ratio: number) => number) | undefined>;

package/utils/agnostic/transition/index.js

@@ -0,0 +1 @@
+import{a as T}from"../../../chunks/chunk-PCAKH6ZJ.js";var f=(n=>(n.LINEAR="linear",n.EASE_IN_QUAD="ease-in-quad",n.EASE_OUT_QUAD="ease-out-quad",n.EASE_IN_OUT_QUAD="ease-in-out-quad",n.EASE_IN_CUBIC="ease-in-cubic",n.EASE_OUT_CUBIC="ease-out-cubic",n.EASE_IN_OUT_CUBIC="ease-in-out-cubic",n.EASE_IN_QUART="ease-in-quart",n.EASE_OUT_QUART="ease-out-quart",n.EASE_IN_OUT_QUART="ease-in-out-quart",n.EASE_IN_QUINT="ease-in-quint",n.EASE_OUT_QUINT="ease-out-quint",n.EASE_IN_OUT_QUINT="ease-in-out-quint",n.EASE_IN_SINE="ease-in-sine",n.EASE_OUT_SINE="ease-out-sine",n.EASE_IN_OUT_SINE="ease-in-out-sine",n.EASE_IN_EXPO="ease-in-expo",n.EASE_OUT_EXPO="ease-out-expo",n.EASE_IN_OUT_EXPO="ease-in-out-expo",n.EASE_IN_CIRC="ease-in-circ",n.EASE_OUT_CIRC="ease-out-circ",n.EASE_IN_OUT_CIRC="ease-in-out-circ",n.EASE_IN_BACK="ease-in-back",n.EASE_OUT_BACK="ease-out-back",n.EASE_IN_OUT_BACK="ease-in-out-back",n.EASE_IN_ELASTIC="ease-in-elastic",n.EASE_OUT_ELASTIC="ease-out-elastic",n.EASE_IN_OUT_ELASTIC="ease-in-out-elastic",n.EASE_IN_BOUNCE="ease-in-bounce",n.EASE_OUT_BOUNCE="ease-out-bounce",n.EASE_IN_OUT_BOUNCE="ease-in-out-bounce",n))(f||{});async function m(e,U,E,p){let N=R[typeof E=="string"?E:"linear"];if(N===void 0)return;let S=p??(typeof E=="function"?E:void 0);if(S===void 0)return;let b=Date.now(),l=new Array(e).fill(null).map((i,I)=>{let r=(I+1)/e,s=N(r);return{time:b+s*U,step:s*e}});for(let{time:i,step:I}of l){let r=Date.now(),s=i-r;s<=0||await T(s),S(I,i)}}var a=Math.pow,o=Math.sqrt,u=Math.sin,C=Math.cos,_=Math.PI,A=1.70158,c=A*1.525,Q=A+1,d=2*_/3,B=2*_/4.5,O=function(e){return e<1/2.75?7.5625*e*e:e<2/2.75?7.5625*(e-=1.5/2.75)*e+.75:e<2.5/2.75?7.5625*(e-=2.25/2.75)*e+.9375:7.5625*(e-=2.625/2.75)*e+.984375},t={linear:e=>e,easeInQuad:e=>e*e,easeOutQuad:e=>1-(1-e)*(1-e),easeInOutQuad:e=>e<.5?2*e*e:1-a(-2*e+2,2)/2,easeInCubic:e=>e*e*e,easeOutCubic:e=>1-a(1-e,3),easeInOutCubic:e=>e<.5?4*e*e*e:1-a(-2*e+2,3)/2,easeInQuart:e=>e*e*e*e,easeOutQuart:e=>1-a(1-e,4),easeInOutQuart:e=>e<.5?8*e*e*e*e:1-a(-2*e+2,4)/2,easeInQuint:e=>e*e*e*e*e,easeOutQuint:e=>1-a(1-e,5),easeInOutQuint:e=>e<.5?16*e*e*e*e*e:1-a(-2*e+2,5)/2,easeInSine:e=>1-C(e*_/2),easeOutSine:e=>u(e*_/2),easeInOutSine:e=>-(C(_*e)-1)/2,easeInExpo:e=>e===0?0:a(2,10*e-10),easeOutExpo:e=>e===1?1:1-a(2,-10*e),easeInOutExpo:e=>e===0?0:e===1?1:e<.5?a(2,20*e-10)/2:(2-a(2,-20*e+10))/2,easeInCirc:e=>1-o(1-a(e,2)),easeOutCirc:e=>o(1-a(e-1,2)),easeInOutCirc:e=>e<.5?(1-o(1-a(2*e,2)))/2:(o(1-a(-2*e+2,2))+1)/2,easeInBack:e=>Q*e*e*e-A*e*e,easeOutBack:e=>1+Q*a(e-1,3)+A*a(e-1,2),easeInOutBack:e=>e<.5?a(2*e,2)*((c+1)*2*e-c)/2:(a(2*e-2,2)*((c+1)*(e*2-2)+c)+2)/2,easeInElastic:e=>e===0?0:e===1?1:-a(2,10*e-10)*u((e*10-10.75)*d),easeOutElastic:e=>e===0?0:e===1?1:a(2,-10*e)*u((e*10-.75)*d)+1,easeInOutElastic:e=>e===0?0:e===1?1:e<.5?-(a(2,20*e-10)*u((20*e-11.125)*B))/2:a(2,-20*e+10)*u((20*e-11.125)*B)/2+1,easeInBounce:e=>1-O(1-e),easeOutBounce:O,easeInOutBounce:e=>e<.5?(1-O(1-2*e))/2:(1+O(2*e-1))/2},R={linear:t.linear,"ease-in-quad":t.easeInQuad,"ease-out-quad":t.easeOutQuad,"ease-in-out-quad":t.easeInOutQuad,"ease-in-cubic":t.easeInCubic,"ease-out-cubic":t.easeOutCubic,"ease-in-out-cubic":t.easeInOutCubic,"ease-in-quart":t.easeInQuart,"ease-out-quart":t.easeOutQuart,"ease-in-out-quart":t.easeInOutQuart,"ease-in-quint":t.easeInQuint,"ease-out-quint":t.easeOutQuint,"ease-in-out-quint":t.easeInOutQuint,"ease-in-sine":t.easeInSine,"ease-out-sine":t.easeOutSine,"ease-in-out-sine":t.easeInOutSine,"ease-in-expo":t.easeInExpo,"ease-out-expo":t.easeOutExpo,"ease-in-out-expo":t.easeInOutExpo,"ease-in-circ":t.easeInCirc,"ease-out-circ":t.easeOutCirc,"ease-in-out-circ":t.easeInOutCirc,"ease-in-back":t.easeInBack,"ease-out-back":t.easeOutBack,"ease-in-out-back":t.easeInOutBack,"ease-in-elastic":t.easeInElastic,"ease-out-elastic":t.easeOutElastic,"ease-in-out-elastic":t.easeInOutElastic,"ease-in-bounce":t.easeInBounce,"ease-out-bounce":t.easeOutBounce,"ease-in-out-bounce":t.easeInOutBounce};export{f as Ease,m as default,t as easingFunctions,R as easings};

package/utils/agnostic/wait/index.d.ts

@@ -0,0 +1 @@
+export default function wait(durationMs: number): Promise<unknown>;

package/utils/agnostic/wait/index.js

@@ -0,0 +1 @@
+import{a}from"../../../chunks/chunk-PCAKH6ZJ.js";export{a as default};

package/utils/browser/dynamic-css/index.d.ts

@@ -0,0 +1,4 @@
+export declare function injectCssRule(rule: string, force?: boolean): string;
+export declare function injectCssRule(rule: string, name: string, force?: boolean): string;
+export declare function removeCssRule(name: string): void;
+export declare function injectStylesheet(href: string, onLoad?: (event?: Event) => void, targetSelector?: string): HTMLLinkElement;

package/utils/browser/dynamic-css/index.js

@@ -0,0 +1,2 @@
+var o=new Map;function u(n,r,s){let e=typeof r=="string"?r:n,t=r===!0||s===!0,a=o.get(e);return(t===!0||a===void 0)&&(o.set(e,n),c()),e}function d(n){o.delete(n)&&c()}function c(){let n="__dynamic-styles";Array.from(document.querySelectorAll(`.${n}`)).forEach(s=>{let e=s.getAttribute("data-name");if(e===null||o.get(e)===void 0)return s.remove()}),o.forEach((s,e)=>{let t=e.replace(/[^\w]/igm,""),a=document.querySelector(`.${n}[data-name="${t}"]`),l=`/* ${e.replace(/[^\w]/,"-")} */
+${s}`;if(a!==null)a.innerHTML=l;else{let i=document.createElement("style");i.classList.add(n),i.setAttribute("data-name",t),i.innerHTML=l,document.head.append(i)}})}function g(n,r,s){let e=s!==void 0?document.querySelector(s)??document.head:document.head,t=document.createElement("link");return t.setAttribute("rel","stylesheet"),t.setAttribute("href",n),r!==void 0&&t.addEventListener("load",r),e.appendChild(t),t}export{u as injectCssRule,g as injectStylesheet,d as removeCssRule};

package/utils/browser/get-current-downlink/index.d.ts

@@ -0,0 +1 @@
+export default function getCurrentDownlink(): number | undefined;

package/utils/browser/get-current-downlink/index.js

@@ -0,0 +1 @@
+function o(){let n=window.navigator;return(n?.connection??n?.mozConnection??n?.webkitConnection)?.downlink}export{o as default};

package/utils/browser/get-node-ancestors/index.d.ts

@@ -0,0 +1 @@
+export default function getNodeAncestors(node: Node): Element[];

package/utils/browser/get-node-ancestors/index.js

@@ -0,0 +1 @@
+function l(t){let n=[],e=t.parentElement;for(;e!==null;)n.push(e),e=e.parentElement;return n}export{l as default};

package/utils/node/is-in-directory/index.d.ts

@@ -0,0 +1 @@
+export default function isInDirectory(childPath: string, parentPath: string): boolean;

package/utils/node/is-in-directory/index.js

@@ -0,0 +1 @@
+import e from"node:path";function n(r,i){let t=e.relative(i,r);return t!==""&&!t.startsWith("..")}export{n as default};

package/utils/node/list-subpaths/index.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { Stats } from 'node:fs';
+export type ChildType = 'file' | 'directory' | 'symlink';
+export type ChildDetails = {
+    type: ChildType;
+    hidden: boolean;
+    realPath: string;
+};
+export type Options = {
+    directories?: boolean;
+    files?: boolean;
+    symlinks?: boolean;
+    hidden?: boolean;
+    followSimlinks?: boolean;
+    dedupeSimlinksContents?: boolean;
+    maxDepth?: number;
+    returnRelative?: boolean;
+    exclude?: RegExp | string | (RegExp | string)[] | null;
+    include?: RegExp | string | (RegExp | string)[] | null;
+    filter?: ((path: string, details: ChildDetails) => boolean | Promise<boolean>);
+};
+export declare const defaultOptions: Required<Options>;
+export declare const fillOptions: (input: Options) => Required<Options>;
+export type Context = {
+    depth?: number;
+    lstats?: Stats | null;
+    rootPath?: string | null;
+};
+export declare const defaultContext: Required<Context>;
+export declare const fillContext: (input: Context) => Required<Context>;
+export default function listSubpaths(...args: Parameters<typeof listAbsoluteSubpaths>): Promise<string[]>;
+declare function listAbsoluteSubpaths(inputPath: string, _options?: Options, __private_context?: Context): Promise<string[]>;
+export {};

package/utils/node/list-subpaths/index.js

@@ -0,0 +1 @@
+import{b as x}from"../../../chunks/chunk-KNE7WIIW.js";import{promises as a}from"node:fs";import h from"node:path";var P={directories:!0,files:!0,symlinks:!0,hidden:!0,followSimlinks:!1,dedupeSimlinksContents:!1,maxDepth:1/0,returnRelative:!1,exclude:null,include:null,filter:()=>!0},S=s=>({...P,...s}),v={depth:0,lstats:null,rootPath:null},O=s=>({...v,...s});async function E(...s){let[c,u]=s,t=S(u??{}),e=await p(...s);return t.returnRelative?e.map(i=>h.relative(c,i)):e}async function p(s,c={},u={}){let t=S(c),e=O(u);e.rootPath===null&&(e.rootPath=s);let i=[];if(e.depth>t.maxDepth)return i;try{if(!(e.lstats??await a.lstat(s)).isDirectory())return i}catch{return i}let k=await a.readdir(s);return await Promise.all(k.map(async d=>{let o=h.join(s,d),R=h.relative(e.rootPath??s,o),r=await a.lstat(o);try{let n=r.isDirectory(),l=r.isSymbolicLink(),f=!n&&!l,w=h.basename(o).startsWith("."),g=n?"directory":l?"symlink":"file";if(n&&t.directories===!1)throw!0;if(l&&t.symlinks===!1||f&&t.files===!1||w&&t.hidden===!1)throw!1;let m=l?await a.realpath(o):o,y=t.returnRelative?R:o,C=x(y,t.exclude??[]),D=x(y,t.include??[]);if(C&&!D)throw!1;if(!await t.filter(y,{type:g,hidden:w,realPath:m}))throw!0;if(l)if(t.followSimlinks===!1)i.push(o);else{let b=await p(m,t,{...e,depth:e.depth+1});i.push(m,...b)}else if(n){let b=await p(o,t,{...e,depth:e.depth+1,lstats:r});i.push(o,...b)}else i.push(o)}catch(n){if(typeof n!="boolean")throw new Error("This try/catch block should only throw booleans");if(!n)return[];let f=await p(o,t,{...e,depth:e.depth+1,lstats:r});i.push(...f)}})),t.dedupeSimlinksContents?Array.from(new Set(i)):i}export{E as default,v as defaultContext,P as defaultOptions,O as fillContext,S as fillOptions};

package/utils/node/process-exit/index.d.ts

@@ -0,0 +1,5 @@
+export declare const forceExitEvents: string[];
+export declare function beforeForcedExit(callback: () => void | Promise<void>): void;
+export declare function beforeExit(callback: () => void | Promise<void>): void;
+export declare function onExit(callback: () => void | Promise<void>): void;
+export declare function anyway(callback: () => void | Promise<void>): void;

package/utils/node/process-exit/index.js

@@ -0,0 +1 @@
+var i=["SIGINT","SIGTERM","uncaughtException"];function t(o){i.forEach(e=>process.on(e,o))}function r(o){process.on("beforeExit",o)}function n(o){process.on("exit",o)}function s(o){t(o),r(o),n(o)}export{s as anyway,r as beforeExit,t as beforeForcedExit,i as forceExitEvents,n as onExit};

package/utils/node/read-write-file/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { promises as fs } from 'node:fs';
+type Path = Parameters<typeof fs.writeFile>[0];
+type ReadFileData = Awaited<ReturnType<typeof fs.readFile>>;
+type WriteFileData = Parameters<typeof fs.writeFile>[1];
+type ReadOptions = Parameters<typeof fs.readFile>[1];
+type WriteOptions = Parameters<typeof fs.writeFile>[2];
+export type EditorFunc = (curr: ReadFileData) => WriteFileData;
+export default function readWriteFile(path: Path, editor: EditorFunc, ...options: [ReadOptions?, WriteOptions?]): Promise<string | NodeJS.ArrayBufferView | Iterable<string | NodeJS.ArrayBufferView> | AsyncIterable<string | NodeJS.ArrayBufferView> | import("stream").Stream>;
+export {};

package/utils/node/read-write-file/index.js

@@ -0,0 +1 @@
+import{promises as r}from"node:fs";async function d(e,s,...t){let[i,o]=t,p=await r.readFile(e,i),a=s(p),n=t.length===2?o:i;return await r.writeFile(e,a,n),a}export{d as default};

package/chunks/chunk-236C4IHT.js

@@ -1,98 +0,0 @@
-import {
-  extractColorsFromImage
-} from "./chunk-ZRWVPWQC.js";
-import {
-  clamp
-} from "./chunk-OSAXBA7G.js";
-import {
-  saturateColor
-} from "./chunk-MB7HWF22.js";
-import {
-  complementColor
-} from "./chunk-2POD3TAX.js";
-import {
-  lightenColor
-} from "./chunk-U57Q62IN.js";
-import {
-  shuffle
-} from "./chunk-VJJIYJMY.js";
-
-// src/node/images/transform/operations/_utils/frame/create-color-palette/index.ts
-function densifyPalette(RGBColors, types, ligthenIntensity, saturateIntensity) {
-  const densifiedPalette = [];
-  const complementaryRGBColors = RGBColors.map((color) => complementColor(color));
-  if (!types) {
-    return RGBColors;
-  }
-  if (types.includes("default")) {
-    densifiedPalette.push(...RGBColors);
-  }
-  if (types.includes("default-lighten")) {
-    densifiedPalette.push(...RGBColors.map((RGBColor) => lightenColor(RGBColor, ligthenIntensity || 0)));
-  }
-  if (types.includes("default-saturate")) {
-    densifiedPalette.push(...RGBColors.map((RGBColor) => saturateColor(RGBColor, saturateIntensity)));
-  }
-  if (types.includes("complementary")) {
-    densifiedPalette.push(...complementaryRGBColors);
-  }
-  if (types.includes("complementary-lighten")) {
-    densifiedPalette.push(...complementaryRGBColors.map((RGBColor) => lightenColor(RGBColor, ligthenIntensity || 0)));
-  }
-  if (types.includes("complementary-saturate")) {
-    densifiedPalette.push(...RGBColors.map((RGBColor) => saturateColor(RGBColor, saturateIntensity)));
-  }
-  return densifiedPalette;
-}
-function createColorPalette(image, createPalette) {
-  if (!createPalette) {
-    return [
-      [0, 0, 0],
-      [0, 0, 0],
-      [0, 0, 0],
-      [0, 0, 0],
-      [0, 0, 0]
-    ];
-  }
-  const colorPalette = [];
-  if ("extract" in createPalette && createPalette.extract) {
-    colorPalette.push(
-      ...extractColorsFromImage(
-        {
-          buffer: image.buffer,
-          dimensions: image.dimensions,
-          nbChannels: image.nbChannels
-        },
-        createPalette.extract.nbColor
-      )
-    );
-  }
-  if ("use" in createPalette && createPalette.use) {
-    colorPalette.push(...createPalette.use.RGBColors);
-  }
-  if ("densify" in createPalette && createPalette.densify) {
-    colorPalette.push(
-      ...densifyPalette(
-        colorPalette,
-        createPalette.densify.types,
-        createPalette.densify.ligthenIntensity,
-        createPalette.densify.saturateIntensity
-      )
-    );
-  }
-  if ("compose" in createPalette && createPalette.compose) {
-    if ("nbColor" in createPalette.compose) {
-      const maxNbColor = createPalette.compose.nbColor ? clamp(createPalette.compose.nbColor, 0, colorPalette.length) : colorPalette.length;
-      colorPalette.splice(0, maxNbColor);
-    }
-    if ("mix" in createPalette.compose) {
-      return shuffle(colorPalette);
-    }
-  }
-  return colorPalette;
-}
-
-export {
-  densifyPalette,
-  createColorPalette
-};

package/chunks/chunk-26QQ56SS.js

@@ -1,36 +0,0 @@
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  unknownToString
-} from "./chunk-FENXVJYO.js";
-import {
-  __export
-} from "./chunk-NZLE2WMY.js";
-
-// src/node/@aws-s3/storage/file/download/index.ts
-var download_exports = {};
-__export(download_exports, {
-  download: () => download
-});
-async function download(sourcePath, bucketName, s3, options) {
-  const { downloadSettings } = options ?? {};
-  const params = {
-    ...downloadSettings,
-    Bucket: bucketName,
-    Key: sourcePath
-  };
-  try {
-    const data = await s3.getObject(params).promise();
-    const stream = data.Body;
-    return Outcome.makeSuccess(stream);
-  } catch (err) {
-    const errStr = unknownToString(err);
-    return Outcome.makeFailure(errStr);
-  }
-}
-
-export {
-  download,
-  download_exports
-};