@design-edito/tools 0.0.33 → 0.1.1

package/agnostic/arrays/index.d.ts

@@ -0,0 +1,11 @@
+import { isArrayOf as isArrayOfFunc } from './is-array-of';
+export declare namespace Arrays {
+    type Filler<T = any> = (pos?: number) => T;
+    export function make<T>(filler: Filler<T>, length: number): T[];
+    export function findDuplicates<T>(arr: T[], stopAtFirst?: boolean): T[];
+    export const randomPickErrorSybol: unique symbol;
+    export type RandomPickErrorSymbol = typeof randomPickErrorSybol;
+    export function randomPick<T>(arr: T[], exclude?: T[]): T | RandomPickErrorSymbol;
+    export const isArrayOf: typeof isArrayOfFunc;
+    export {};
+}

package/{utils/agnostic → agnostic/arrays}/is-array-of/index.d.ts

@@ -1,5 +1,5 @@
-import { ConstructorFunction } from '~/utils/agnostic/is-constructor-function';
+import { ConstructorFunction } from '~/agnostic/misc/is-constructor-function';
 type TypeCheckerFunction = (input: unknown) => boolean;
 type TypeChecker = ConstructorFunction | TypeCheckerFunction;
-export default function isArrayOf<T extends unknown = unknown>(input: unknown, _types?: TypeChecker | TypeChecker[]): input is T[];
+export declare function isArrayOf<T extends unknown = unknown>(input: unknown, _types?: TypeChecker | TypeChecker[]): input is T[];
 export {};

package/agnostic/arrays/is-array-of/index.js

@@ -0,0 +1,23 @@
+import {
+  isConstructorFunction
+} from "../../../chunks/chunk-RCO57B6F.js";
+
+// src/agnostic/arrays/is-array-of/index.ts
+function isArrayOf(input, _types = []) {
+  if (!Array.isArray(input)) return false;
+  const types = Array.isArray(_types) ? _types : [_types];
+  if (types.length === 0) return true;
+  return input.every((entry) => {
+    return types.some((typeChecker) => {
+      const isConstructor = isConstructorFunction(typeChecker);
+      if (!isConstructor) return typeChecker(entry);
+      if (typeChecker === Number) return typeof entry === "number";
+      if (typeChecker === String) return typeof entry === "string";
+      if (typeChecker === Boolean) return typeof entry === "boolean";
+      if (isConstructor) return entry instanceof typeChecker;
+    });
+  });
+}
+export {
+  isArrayOf
+};

package/agnostic/async/index.d.ts

@@ -0,0 +1,8 @@
+import { timeoutCall as timeoutCallFunc } from './timeout-call';
+import { Transitions as TransitionsNamespace } from './transitions';
+import { wait as waitFunc } from './wait';
+export declare namespace Async {
+    const timeoutCall: typeof timeoutCallFunc;
+    export import Transitions = TransitionsNamespace;
+    const wait: typeof waitFunc;
+}

package/agnostic/async/index.js

@@ -0,0 +1,20 @@
+import {
+  timeoutCall
+} from "../../chunks/chunk-4VC5PT5T.js";
+import {
+  Transitions
+} from "../../chunks/chunk-4GDNHUCZ.js";
+import {
+  wait
+} from "../../chunks/chunk-DQNJQBC6.js";
+
+// src/agnostic/async/index.ts
+var Async;
+((Async2) => {
+  Async2.timeoutCall = timeoutCall;
+  Async2.Transitions = Transitions;
+  Async2.wait = wait;
+})(Async || (Async = {}));
+export {
+  Async
+};

package/agnostic/async/timeout-call/index.d.ts

@@ -0,0 +1 @@
+export declare function timeoutCall<T extends any>(callback: () => T, timeoutMs: number): Promise<unknown>;

package/agnostic/async/timeout-call/index.js

@@ -0,0 +1,6 @@
+import {
+  timeoutCall
+} from "../../../chunks/chunk-4VC5PT5T.js";
+export {
+  timeoutCall
+};

package/agnostic/async/transitions/index.d.ts

@@ -0,0 +1,41 @@
+export declare namespace Transitions {
+    type Callback = (val: number, timeMs: number) => void;
+    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"
+    }
+    type EasingFunction = (progress: number) => number;
+    type EasingDictionary = Record<string, EasingFunction>;
+    function transition(to: number, durationMs: number, callbackOrEase: Ease | Callback, callback?: Callback): Promise<void>;
+    const easingFunctions: EasingDictionary;
+    const easings: Record<Ease, ((ratio: number) => number) | undefined>;
+}

package/agnostic/async/transitions/index.js

@@ -0,0 +1,7 @@
+import {
+  Transitions
+} from "../../../chunks/chunk-4GDNHUCZ.js";
+import "../../../chunks/chunk-DQNJQBC6.js";
+export {
+  Transitions
+};

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

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

package/agnostic/async/wait/index.js

@@ -0,0 +1,6 @@
+import {
+  wait
+} from "../../../chunks/chunk-DQNJQBC6.js";
+export {
+  wait
+};

package/agnostic/booleans/index.d.ts

@@ -0,0 +1,8 @@
+import { Falsy as FalsyType, NotFalsy as NotFalsyType, isFalsy as isFalsyFunc, isNotFalsy as isNotFalsyFunc } from './is-falsy';
+export declare namespace Booleans {
+    type Falsy = FalsyType;
+    type NotFalsy<T> = NotFalsyType<T>;
+    const falsyValues: FalsyType[];
+    const isFalsy: typeof isFalsyFunc;
+    const isNotFalsy: typeof isNotFalsyFunc;
+}

package/agnostic/booleans/index.js

@@ -0,0 +1,17 @@
+import {
+  falsyValues,
+  isFalsy,
+  isNotFalsy
+} from "../../chunks/chunk-QXAJXTXV.js";
+import "../../chunks/chunk-HC6ZOHCS.js";
+
+// src/agnostic/booleans/index.ts
+var Booleans;
+((Booleans2) => {
+  Booleans2.falsyValues = falsyValues;
+  Booleans2.isFalsy = isFalsy;
+  Booleans2.isNotFalsy = isNotFalsy;
+})(Booleans || (Booleans = {}));
+export {
+  Booleans
+};

package/{utils/agnostic → agnostic/booleans}/is-falsy/index.d.ts

@@ -1,8 +1,7 @@
-import { Nullish } from '~/utils/agnostic/is-nullish';
+import { Nullish } from '~/agnostic/misc/is-nullish';
 export type Falsy = Nullish | false | '' | 0 | -0 | typeof NaN | 0n;
 export type NotFalsy<T> = Exclude<T, Exclude<Falsy, number>>;
 declare const falsyValues: Falsy[];
 export { falsyValues };
 export declare function isFalsy<T>(val: T | Falsy): val is Falsy;
 export declare function isNotFalsy<T>(val: T): val is NotFalsy<T>;
-export default isFalsy;

package/agnostic/booleans/is-falsy/index.js

@@ -0,0 +1,11 @@
+import {
+  falsyValues,
+  isFalsy,
+  isNotFalsy
+} from "../../../chunks/chunk-QXAJXTXV.js";
+import "../../../chunks/chunk-HC6ZOHCS.js";
+export {
+  falsyValues,
+  isFalsy,
+  isNotFalsy
+};

package/agnostic/css/bem/index.d.ts

@@ -0,0 +1,7 @@
+import BEMClass from './BEM';
+import getNamesArrFunc from './getNamesArr';
+export declare namespace Bem {
+    const BEM: typeof BEMClass;
+    function bem(blockNameArg: any): BEMClass;
+    const getNamesArr: typeof getNamesArrFunc;
+}

package/agnostic/css/bem/index.js

@@ -0,0 +1,9 @@
+import {
+  Bem
+} from "../../../chunks/chunk-7YW5HL6N.js";
+import "../../../chunks/chunk-QXAJXTXV.js";
+import "../../../chunks/chunk-HC6ZOHCS.js";
+import "../../../chunks/chunk-W5A2TON3.js";
+export {
+  Bem
+};

package/{utils/agnostic → agnostic/css}/generate-nice-color/index.d.ts

@@ -1,3 +1,2 @@
 export declare const niceColors: string[];
 export declare const generateNiceColor: () => string | undefined;
-export default generateNiceColor;

package/agnostic/css/generate-nice-color/index.js

@@ -0,0 +1,8 @@
+import {
+  generateNiceColor,
+  niceColors
+} from "../../../chunks/chunk-EDVNAV3G.js";
+export {
+  generateNiceColor,
+  niceColors
+};

package/agnostic/css/index.d.ts

@@ -0,0 +1,14 @@
+import { Bem as BemNamespace } from './bem';
+import { isValidClassName as isValidClassNameFunc } from './is-valid-css-class-name';
+import { StylesSetItem as StylesSetItemType, StylesSet as StylesSetFunc, StylesSetCompProps as StylesSetCompPropsFype, StylesSetComp as StylesSetCompFunc } from './styles-set';
+export declare namespace Css {
+    export import Bem = BemNamespace;
+    const niceColors: string[];
+    const generateNiceColor: () => string | undefined;
+    const classNameRegex: RegExp;
+    const isValidClassName: typeof isValidClassNameFunc;
+    type StylesSetItem = StylesSetItemType;
+    const StylesSet: typeof StylesSetFunc;
+    type StylesSetCompProps = StylesSetCompPropsFype;
+    const StylesSetComp: typeof StylesSetCompFunc;
+}

package/agnostic/css/index.js

@@ -0,0 +1,177 @@
+import {
+  Random
+} from "../../chunks/chunk-WLL3FNVL.js";
+import {
+  register
+} from "../../chunks/chunk-KQT5CTGF.js";
+import {
+  Crossenv
+} from "../../chunks/chunk-GJOU3UAL.js";
+import "../../chunks/chunk-MT74WIQR.js";
+import {
+  Bem
+} from "../../chunks/chunk-7YW5HL6N.js";
+import "../../chunks/chunk-QXAJXTXV.js";
+import "../../chunks/chunk-HC6ZOHCS.js";
+import {
+  generateNiceColor,
+  niceColors
+} from "../../chunks/chunk-EDVNAV3G.js";
+import {
+  classNameRegex,
+  isValidClassName
+} from "../../chunks/chunk-W5A2TON3.js";
+
+// src/agnostic/css/styles-set/index.tsx
+import { Component } from "react";
+import { render as reactRender } from "react-dom";
+import {
+  createRoot as reactCreateRoot
+} from "react-dom/client";
+import { Fragment, jsx } from "react/jsx-runtime";
+var StylesSet = class _StylesSet {
+  static defaultPrivateIDAttribute = "data-styleset-private-id";
+  static defaultPublicIDAttribute = "data-styleset-public-id";
+  _items = /* @__PURE__ */ new Map();
+  get items() {
+    const sortedItemsArray = Array.from(this._items).map(([privateId, item]) => {
+      return {
+        targetPosition: this.getTargetPosition(privateId) ?? 0,
+        privateId,
+        item
+      };
+    }).sort((a, b) => a.targetPosition - b.targetPosition).map(({ item, privateId }) => [privateId, item]);
+    const sortedItemsMap = new Map(sortedItemsArray);
+    return sortedItemsMap;
+  }
+  tagsPrivateIDAttribute = _StylesSet.defaultPrivateIDAttribute;
+  tagsPublicIDAttribute = _StylesSet.defaultPublicIDAttribute;
+  getTargetPosition(privateId) {
+    const orderedStyles = Array.from(this._items).map(([privateId2, data]) => ({ privateId: privateId2, data })).sort((a, b) => {
+      const aPos = a.data.position ?? 0;
+      const bPos = b.data.position ?? 0;
+      return aPos - bPos;
+    });
+    const foundIndex = orderedStyles.findIndex((item) => item.privateId === privateId);
+    return foundIndex === -1 ? null : foundIndex;
+  }
+  setTagsPrivateIDAttribute(str) {
+    this.tagsPrivateIDAttribute = str;
+    return this;
+  }
+  setTagsPublicIDAttribute(str) {
+    this.tagsPublicIDAttribute = str;
+    return this;
+  }
+  getById(id) {
+    const found = Array.from(this._items.values()).find((entry) => entry.id === id);
+    if (found === void 0) return void 0;
+    return found;
+  }
+  generateUniquePrivateId() {
+    const existingIds = Array.from(this._items.keys());
+    const generated = Random.randomHash(12);
+    if (existingIds.includes(generated)) return this.generateUniquePrivateId();
+    return generated;
+  }
+  getComp() {
+    const items = this.items;
+    const comp = /* @__PURE__ */ jsx(
+      StylesSetComp,
+      {
+        items,
+        privateIDAttribute: this.tagsPrivateIDAttribute,
+        publicIDAttribute: this.tagsPublicIDAttribute
+      }
+    );
+    return comp;
+  }
+  _rendered = /* @__PURE__ */ new Map();
+  render(element) {
+    const root = reactCreateRoot(element);
+    root.render(this.getComp());
+    this._rendered.set(element, root);
+    return this;
+  }
+  unmount(element) {
+    if (!this._rendered.has(element)) return this;
+    const root = this._rendered.get(element);
+    if (root === void 0) return this;
+    root.unmount();
+    this._rendered.delete(element);
+    return this;
+  }
+  updateRendered() {
+    this._rendered.forEach((root) => root.render(this.getComp()));
+    return this;
+  }
+  addItem(item, abortIfIdExists = true) {
+    const existing = Array.from(this._items.entries()).map(([privateId2, entry]) => ({ privateId: privateId2, entry })).find(({ entry }) => entry.id !== void 0 && entry.id === item.id);
+    if (existing !== void 0) {
+      if (abortIfIdExists) return this;
+      this._items.delete(existing.privateId);
+    }
+    const privateId = this.generateUniquePrivateId();
+    this._items.set(privateId, item);
+    this.updateRendered();
+    return this;
+  }
+  removeItem(idOrPosition) {
+    if (typeof idOrPosition === "string") {
+      const existing = Array.from(this._items.entries()).map(([privateId, entry]) => ({ privateId, entry })).find(({ entry }) => entry.id !== void 0 && entry.id === idOrPosition);
+      if (existing === void 0) return this;
+      this._items.delete(existing.privateId);
+      this.updateRendered();
+      return this;
+    }
+    const toRemove = Array.from(this._items).map(([privateId, entry]) => ({ privateId, entry })).at(idOrPosition);
+    if (toRemove === void 0) return this;
+    this._items.delete(toRemove.privateId);
+    this.updateRendered();
+    return this;
+  }
+  async getDomString(documentObj) {
+    const actualDocumentObj = documentObj ?? Crossenv.getDocument();
+    if (actualDocumentObj === null) throw register.getError("no-window-document-on-runtime" /* NO_DOCUMENT */);
+    return new Promise((resolve) => {
+      const tempElt = actualDocumentObj.createElement("div");
+      reactRender(this.getComp(), tempElt, () => resolve(tempElt.innerHTML));
+    });
+  }
+};
+var StylesSetComp = class extends Component {
+  render() {
+    const { props } = this;
+    const items = props.items ?? /* @__PURE__ */ new Map();
+    const pidAttr = props.privateIDAttribute ?? StylesSet.defaultPrivateIDAttribute;
+    const idAttr = props.publicIDAttribute ?? StylesSet.defaultPublicIDAttribute;
+    return /* @__PURE__ */ jsx(Fragment, { children: Array.from(items).map(([privateId, itemData]) => {
+      const customAttributes = { [pidAttr]: privateId, [idAttr]: itemData.id };
+      if (itemData.type === "url") return /* @__PURE__ */ jsx(
+        "link",
+        {
+          onLoad: itemData.onLoad,
+          rel: "stylesheet",
+          href: itemData.content,
+          ...customAttributes
+        }
+      );
+      return /* @__PURE__ */ jsx("style", { ...customAttributes, children: itemData.content });
+    }) });
+  }
+};
+
+// src/agnostic/css/index.ts
+var Css;
+((Css2) => {
+  Css2.Bem = Bem;
+  Css2.niceColors = niceColors;
+  Css2.generateNiceColor = generateNiceColor;
+  Css2.classNameRegex = classNameRegex;
+  Css2.isValidClassName = isValidClassName;
+  Css2.StylesSet = StylesSet;
+  Css2.StylesSetComp = StylesSetComp;
+})(Css || (Css = {}));
+export {
+  Css
+};

package/agnostic/css/is-valid-css-class-name/index.d.ts

@@ -0,0 +1,2 @@
+export declare const classNameRegex: RegExp;
+export declare function isValidClassName(string: string): boolean;

package/agnostic/css/is-valid-css-class-name/index.js

@@ -0,0 +1,8 @@
+import {
+  classNameRegex,
+  isValidClassName
+} from "../../../chunks/chunk-W5A2TON3.js";
+export {
+  classNameRegex,
+  isValidClassName
+};

package/agnostic/css/styles-set/index.d.ts

@@ -0,0 +1,37 @@
+import { JSX, Component } from 'react';
+export type StylesSetItem = {
+    type: 'string' | 'url';
+    content: string;
+    id?: string;
+    position?: number;
+    onLoad?: () => void;
+};
+export declare class StylesSet {
+    static defaultPrivateIDAttribute: string;
+    static defaultPublicIDAttribute: string;
+    private _items;
+    get items(): Map<string, StylesSetItem>;
+    tagsPrivateIDAttribute: string;
+    tagsPublicIDAttribute: string;
+    private getTargetPosition;
+    setTagsPrivateIDAttribute(str: string): this;
+    setTagsPublicIDAttribute(str: string): this;
+    getById(id: string): StylesSetItem | undefined;
+    generateUniquePrivateId(): string;
+    getComp(): JSX.Element;
+    private _rendered;
+    render(element: Element): this;
+    unmount(element: Element): this;
+    updateRendered(): this;
+    addItem(item: StylesSetItem, abortIfIdExists?: boolean): this;
+    removeItem(idOrPosition: string | number): this;
+    getDomString(documentObj?: Document): Promise<string>;
+}
+export type StylesSetCompProps = {
+    items?: StylesSet['items'];
+    privateIDAttribute?: StylesSet['tagsPrivateIDAttribute'];
+    publicIDAttribute?: StylesSet['tagsPublicIDAttribute'];
+};
+export declare class StylesSetComp extends Component<StylesSetCompProps> {
+    render(): import("react/jsx-runtime").JSX.Element;
+}

package/agnostic/errors/index.d.ts

@@ -0,0 +1,30 @@
+type AnyFunc = (...args: any[]) => any;
+type ParamsOfNullableFunc<F extends AnyFunc | undefined | null> = F extends AnyFunc ? Parameters<F> : [];
+type ReturnTypeOfNullableFunc<F extends AnyFunc | undefined | null> = F extends AnyFunc ? ReturnType<F> : undefined;
+export declare namespace Errors {
+    type ErrFactory<Params extends any[] = any[], Details = any> = {
+        message: string;
+        makeDetails?: (...params: Params) => Details;
+    };
+    type ErrData<RS extends RegisterSource, C extends keyof RS> = {
+        code: C;
+        message: RS[C]['message'];
+        details: ReturnTypeOfNullableFunc<RS[C]['makeDetails']>;
+    };
+    type RegisterSource<P extends any[] = any[], D = any> = {
+        [code: string]: ErrFactory<P, D>;
+    };
+    class CustomError<RS extends RegisterSource, C extends keyof RS> extends Error {
+        code: ErrData<RS, C>['code'];
+        details: ErrData<RS, C>['details'];
+        constructor(data: ErrData<RS, C>);
+    }
+    class Register<RS extends RegisterSource> {
+        private _source;
+        constructor(source: RS);
+        getFactory<C extends keyof RS>(code: C): RS[C];
+        getData<C extends keyof RS>(code: C, ...params: ParamsOfNullableFunc<RS[C]['makeDetails']>): ErrData<RS, C>;
+        getError<C extends keyof RS>(code: C, ...params: ParamsOfNullableFunc<RS[C]['makeDetails']>): CustomError<RS, C>;
+    }
+}
+export {};

package/agnostic/errors/index.js

@@ -0,0 +1,6 @@
+import {
+  Errors
+} from "../../chunks/chunk-MT74WIQR.js";
+export {
+  Errors
+};

package/agnostic/html/get-node-ancestors/index.d.ts

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

package/agnostic/html/get-node-ancestors/index.js

@@ -0,0 +1,6 @@
+import {
+  getNodeAncestors
+} from "../../../chunks/chunk-SQZGZ3VT.js";
+export {
+  getNodeAncestors
+};

package/agnostic/html/get-position-inside-parent/index.d.ts

@@ -0,0 +1 @@
+export declare function getPositionInsideParent(node: Node): number | null;

package/agnostic/html/get-position-inside-parent/index.js

@@ -0,0 +1,6 @@
+import {
+  getPositionInsideParent
+} from "../../../chunks/chunk-VTPRO4NJ.js";
+export {
+  getPositionInsideParent
+};

package/agnostic/html/index.d.ts

@@ -0,0 +1,17 @@
+import { getNodeAncestors as getNodeAncestorsFunc } from './get-node-ancestors';
+import { getPositionInsideParent as getPositionInsideParentFunc } from './get-position-inside-parent';
+import { InsertNodePosition as InsertNodePositionType, insertNode as insertNodeFunc } from './insert-node';
+import { Placeholders as PlaceholdersNamespace } from './placeholders';
+import { Sanitize as SanitizeNamespace } from './sanitize';
+import { selectorToElement as selectorToElementFunc } from './selector-to-element';
+import { stringToNodes as stringToNodesFunc } from './string-to-nodes';
+export declare namespace Html {
+    const getNodeAncestors: typeof getNodeAncestorsFunc;
+    const getPositionInsideParent: typeof getPositionInsideParentFunc;
+    type InsertNodePosition = InsertNodePositionType;
+    const insertNode: typeof insertNodeFunc;
+    export import Placeholders = PlaceholdersNamespace;
+    export import Sanitize = SanitizeNamespace;
+    const selectorToElement: typeof selectorToElementFunc;
+    const stringToNodes: typeof stringToNodesFunc;
+}

package/agnostic/html/index.js

@@ -0,0 +1,39 @@
+import {
+  Placeholders
+} from "../../chunks/chunk-VYW4IADX.js";
+import {
+  selectorToElement
+} from "../../chunks/chunk-XN3PZIVL.js";
+import {
+  stringToNodes
+} from "../../chunks/chunk-NRJQKVQV.js";
+import {
+  getNodeAncestors
+} from "../../chunks/chunk-SQZGZ3VT.js";
+import {
+  Sanitize
+} from "../../chunks/chunk-IFD7GSGK.js";
+import {
+  getPositionInsideParent
+} from "../../chunks/chunk-VTPRO4NJ.js";
+import {
+  insertNode
+} from "../../chunks/chunk-XA4HVHJ4.js";
+import "../../chunks/chunk-KQT5CTGF.js";
+import "../../chunks/chunk-GJOU3UAL.js";
+import "../../chunks/chunk-MT74WIQR.js";
+
+// src/agnostic/html/index.ts
+var Html;
+((Html2) => {
+  Html2.getNodeAncestors = getNodeAncestors;
+  Html2.getPositionInsideParent = getPositionInsideParent;
+  Html2.insertNode = insertNode;
+  Html2.Placeholders = Placeholders;
+  Html2.Sanitize = Sanitize;
+  Html2.selectorToElement = selectorToElement;
+  Html2.stringToNodes = stringToNodes;
+})(Html || (Html = {}));
+export {
+  Html
+};

package/agnostic/html/insert-node/index.d.ts

@@ -0,0 +1,2 @@
+export type InsertNodePosition = 'after' | 'before' | 'startof' | 'endof';
+export declare function insertNode(node: Node, position: InsertNodePosition, reference: Node): void;

package/agnostic/html/insert-node/index.js

@@ -0,0 +1,6 @@
+import {
+  insertNode
+} from "../../../chunks/chunk-XA4HVHJ4.js";
+export {
+  insertNode
+};

package/agnostic/html/placeholders/index.d.ts

@@ -0,0 +1,9 @@
+export declare namespace Placeholders {
+    const EightKiloByteOfLoremIpsumSentences: string[];
+    const generateSentence: () => string | undefined;
+    const generateSentences: (amount?: number) => (string | undefined)[];
+    const generateTitle: () => string;
+    const generateIntertitle: () => string;
+    const generateParagraph: () => string;
+    const generateContentPage: (len?: number) => string;
+}

package/agnostic/html/placeholders/index.js

@@ -0,0 +1,6 @@
+import {
+  Placeholders
+} from "../../../chunks/chunk-VYW4IADX.js";
+export {
+  Placeholders
+};

package/agnostic/html/sanitize/index.d.ts

@@ -0,0 +1,24 @@
+export declare namespace Sanitize {
+    type AttributeNameValPair = {
+        attributeName: string | RegExp;
+        attributeValues?: Array<string | RegExp>;
+    };
+    type Options = {
+        inputFreeTransform?: (input: string) => string;
+        keepComments?: boolean;
+        allowedTags?: string[];
+        forbiddenTags?: string[];
+        allowedAttributes?: {
+            [tagName: string]: AttributeNameValPair[];
+        };
+        forbiddenAttributes?: {
+            [tagName: string]: AttributeNameValPair[];
+        };
+        depth?: number;
+        verbose?: boolean;
+        documentObj?: Document;
+    };
+    const defaultOptions: Options;
+    function sanitize(inputStr: string, options?: Options): string;
+    function sanitizeElement(element: Element, options?: Options): Element | null;
+}