tiny-essentials 1.24.0 → 1.24.2

package/dist/v1/libs/TinyHtml/TinyHtmlForm.d.mts

@@ -0,0 +1,129 @@
+export default TinyHtmlForm;
+/**
+ * TinyHtmlForm is a helper for creating and managing <form> elements
+ * with full attribute support and validation.
+ *
+ * @example
+ * const form = new TinyHtmlForm({
+ *   action: '/submit',
+ *   method: 'post',
+ *   enctype: 'multipart/form-data',
+ *   autocomplete: 'on',
+ *   novalidate: true,
+ *   target: '_blank',
+ *   tags: ['form', 'signup'],
+ *   mainClass: 'primary-form'
+ * });
+ *
+ * @extends TinyHtmlTemplate<HTMLFormElement>
+ */
+declare class TinyHtmlForm extends TinyHtmlTemplate<HTMLFormElement> {
+    /**
+     * Creates a new TinyHtmlForm instance.
+     *
+     * The constructor accepts a single `config` object with named options to
+     * configure the created `<form>` element. Validation is performed for each
+     * option and a `TypeError` is thrown when an invalid type or value is
+     * provided. Deprecated attributes are accepted but will emit a console.warn.
+     *
+     * @param {Object} [config={}] - Configuration object.
+     * @param {string} [config.action=""] - The URL that processes the form submission.
+     *   If omitted the form will submit to the current document URL.
+     * @param {'get'|'post'|'dialog'} [config.method='get'] - The HTTP method to submit the form with.
+     *   - `get` (default): form data appended to the action URL.
+     *   - `post`: form data sent in request body; `enctype` is relevant.
+     *   - `dialog`: when the form is inside a `<dialog>`, closes the dialog and fires a submit event without sending data.
+     * @param {'application/x-www-form-urlencoded'|'multipart/form-data'|'text/plain'} [config.enctype]
+     *   The encoding type for form submission (only used when method is `post`).
+     * @param {string} [config.acceptCharset] - The character encoding accepted by the server (e.g. "UTF-8").
+     *   The specification recommends "UTF-8".
+     * @param {'none'|'off'|'sentences'|'on'|'words'|'characters'} [config.autocapitalize]
+     *   Controls automatic capitalization for text inputs inside the form.
+     * @param {'on'|'off'} [config.autocomplete] - Hint to the browser whether autofill is allowed for controls in the form.
+     * @param {string} [config.name] - The form name. Must be a non-empty string when provided.
+     * @param {string} [config.rel] - Space-separated relationship tokens describing the form's link semantics.
+     * @param {boolean} [config.novalidate=false] - When true, disables built-in form validation on submit.
+     * @param {string} [config.target] - Target browsing context for the response.
+     *   Can be one of `_self`, `_blank`, `_parent`, `_top`, `_unfencedTop` or a valid browsing context name
+     *   (pattern: starts with a letter/underscore, then alphanumeric/`-`/`_`).
+     * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes to apply to the form element.
+     * @param {string} [config.mainClass=''] - Main CSS class to append to the element.
+     *
+     * @throws {TypeError} If `action` is provided and is not a string.
+     * @throws {TypeError} If `method` is not one of 'get', 'post' or 'dialog'.
+     * @throws {TypeError} If `enctype` is provided and is not one of the allowed encodings.
+     * @throws {TypeError} If `acceptCharset` is provided and is not a string.
+     * @throws {TypeError} If `autocapitalize` is provided and is not one of the allowed tokens.
+     * @throws {TypeError} If `autocomplete` is provided and is not 'on' or 'off'.
+     * @throws {TypeError} If `name` is provided and is not a non-empty string.
+     * @throws {TypeError} If `rel` is provided and is not a string.
+     * @throws {TypeError} If `novalidate` is not a boolean.
+     * @throws {TypeError} If `target` is not a valid target keyword or a valid browsing context name.
+     */
+    constructor({ action, method, enctype, acceptCharset, autocapitalize, autocomplete, name, rel, novalidate, target, tags, mainClass, }?: {
+        action?: string | undefined;
+        method?: "dialog" | "get" | "post" | undefined;
+        enctype?: "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | undefined;
+        acceptCharset?: string | undefined;
+        autocapitalize?: "none" | "off" | "on" | "sentences" | "words" | "characters" | undefined;
+        autocomplete?: "off" | "on" | undefined;
+        name?: string | undefined;
+        rel?: string | undefined;
+        novalidate?: boolean | undefined;
+        target?: string | undefined;
+        tags?: string | string[] | Set<string> | undefined;
+        mainClass?: string | undefined;
+    });
+    /** @param {string} action */
+    set action(action: string);
+    /** @returns {string|null} */
+    get action(): string | null;
+    /** @param {'get'|'post'|'dialog'} method */
+    set method(method: "get" | "post" | "dialog");
+    /** @returns {string|null} */
+    get method(): string | null;
+    /** @param {'application/x-www-form-urlencoded'|'multipart/form-data'|'text/plain'} enctype */
+    set enctype(enctype: "application/x-www-form-urlencoded" | "multipart/form-data" | "text/plain");
+    /** @returns {string|null} */
+    get enctype(): string | null;
+    /** @param {string} charset */
+    set acceptCharset(charset: string);
+    /** @returns {string|null} */
+    get acceptCharset(): string | null;
+    /** @param {'none'|'off'|'sentences'|'on'|'words'|'characters'} value */
+    set autocapitalize(value: "none" | "off" | "sentences" | "on" | "words" | "characters");
+    /** @returns {string|null} */
+    get autocapitalize(): string | null;
+    /** @param {'on'|'off'} value */
+    set autocomplete(value: "on" | "off");
+    /** @returns {string|null} */
+    get autocomplete(): string | null;
+    /** @param {string} name */
+    set name(name: string);
+    /** @returns {string|null} */
+    get name(): string | null;
+    /** @param {string} rel */
+    set rel(rel: string);
+    /** @returns {string|null} */
+    get rel(): string | null;
+    /** @param {boolean} novalidate */
+    set novalidate(novalidate: boolean);
+    /** @returns {boolean} */
+    get novalidate(): boolean;
+    /** @param {string} target */
+    set target(target: string);
+    /** @returns {string|null} */
+    get target(): string | null;
+    /**
+     * Programmatically submits the form.
+     * @returns {this}
+     */
+    submit(): this;
+    /**
+     * Resets the form.
+     * @returns {this}
+     */
+    reset(): this;
+}
+import TinyHtmlTemplate from './TinyHtmlTemplate.mjs';
+//# sourceMappingURL=TinyHtmlForm.d.mts.map

package/dist/v1/libs/TinyHtml/TinyHtmlForm.mjs

@@ -0,0 +1,228 @@
+import TinyHtmlTemplate from './TinyHtmlTemplate.mjs';
+/**
+ * TinyHtmlForm is a helper for creating and managing <form> elements
+ * with full attribute support and validation.
+ *
+ * @example
+ * const form = new TinyHtmlForm({
+ *   action: '/submit',
+ *   method: 'post',
+ *   enctype: 'multipart/form-data',
+ *   autocomplete: 'on',
+ *   novalidate: true,
+ *   target: '_blank',
+ *   tags: ['form', 'signup'],
+ *   mainClass: 'primary-form'
+ * });
+ *
+ * @extends TinyHtmlTemplate<HTMLFormElement>
+ */
+class TinyHtmlForm extends TinyHtmlTemplate {
+    /**
+     * Creates a new TinyHtmlForm instance.
+     *
+     * The constructor accepts a single `config` object with named options to
+     * configure the created `<form>` element. Validation is performed for each
+     * option and a `TypeError` is thrown when an invalid type or value is
+     * provided. Deprecated attributes are accepted but will emit a console.warn.
+     *
+     * @param {Object} [config={}] - Configuration object.
+     * @param {string} [config.action=""] - The URL that processes the form submission.
+     *   If omitted the form will submit to the current document URL.
+     * @param {'get'|'post'|'dialog'} [config.method='get'] - The HTTP method to submit the form with.
+     *   - `get` (default): form data appended to the action URL.
+     *   - `post`: form data sent in request body; `enctype` is relevant.
+     *   - `dialog`: when the form is inside a `<dialog>`, closes the dialog and fires a submit event without sending data.
+     * @param {'application/x-www-form-urlencoded'|'multipart/form-data'|'text/plain'} [config.enctype]
+     *   The encoding type for form submission (only used when method is `post`).
+     * @param {string} [config.acceptCharset] - The character encoding accepted by the server (e.g. "UTF-8").
+     *   The specification recommends "UTF-8".
+     * @param {'none'|'off'|'sentences'|'on'|'words'|'characters'} [config.autocapitalize]
+     *   Controls automatic capitalization for text inputs inside the form.
+     * @param {'on'|'off'} [config.autocomplete] - Hint to the browser whether autofill is allowed for controls in the form.
+     * @param {string} [config.name] - The form name. Must be a non-empty string when provided.
+     * @param {string} [config.rel] - Space-separated relationship tokens describing the form's link semantics.
+     * @param {boolean} [config.novalidate=false] - When true, disables built-in form validation on submit.
+     * @param {string} [config.target] - Target browsing context for the response.
+     *   Can be one of `_self`, `_blank`, `_parent`, `_top`, `_unfencedTop` or a valid browsing context name
+     *   (pattern: starts with a letter/underscore, then alphanumeric/`-`/`_`).
+     * @param {string|string[]|Set<string>} [config.tags=[]] - Initial CSS classes to apply to the form element.
+     * @param {string} [config.mainClass=''] - Main CSS class to append to the element.
+     *
+     * @throws {TypeError} If `action` is provided and is not a string.
+     * @throws {TypeError} If `method` is not one of 'get', 'post' or 'dialog'.
+     * @throws {TypeError} If `enctype` is provided and is not one of the allowed encodings.
+     * @throws {TypeError} If `acceptCharset` is provided and is not a string.
+     * @throws {TypeError} If `autocapitalize` is provided and is not one of the allowed tokens.
+     * @throws {TypeError} If `autocomplete` is provided and is not 'on' or 'off'.
+     * @throws {TypeError} If `name` is provided and is not a non-empty string.
+     * @throws {TypeError} If `rel` is provided and is not a string.
+     * @throws {TypeError} If `novalidate` is not a boolean.
+     * @throws {TypeError} If `target` is not a valid target keyword or a valid browsing context name.
+     */
+    constructor({ action = '', method = 'get', enctype, acceptCharset, autocapitalize, autocomplete, name, rel, novalidate = false, target, tags = [], mainClass = '', } = {}) {
+        super(document.createElement('form'), tags, mainClass);
+        // action
+        this.action = action;
+        // method
+        this.method = method;
+        // enctype
+        if (enctype !== undefined)
+            this.enctype = enctype;
+        // accept-charset
+        if (acceptCharset !== undefined)
+            this.acceptCharset = acceptCharset;
+        // autocapitalize
+        if (autocapitalize !== undefined)
+            this.autocapitalize = autocapitalize;
+        // autocomplete
+        if (autocomplete !== undefined)
+            this.autocomplete = autocomplete;
+        // name
+        if (name !== undefined)
+            this.name = name;
+        // rel
+        if (rel !== undefined)
+            this.rel = rel;
+        // novalidate
+        this.novalidate = novalidate;
+        // target
+        if (target !== undefined)
+            this.target = target;
+    }
+    /** @param {string} action */
+    set action(action) {
+        if (typeof action !== 'string')
+            throw new TypeError('TinyForm: "action" must be a string.');
+        if (action)
+            this.setAttr('action', action);
+    }
+    /** @returns {string|null} */
+    get action() {
+        return this.attrString('action');
+    }
+    /** @param {'get'|'post'|'dialog'} method */
+    set method(method) {
+        if (typeof method !== 'string')
+            throw new TypeError('TinyForm: "method" must be a string.');
+        const valid = ['get', 'post', 'dialog'];
+        const norm = method.toLowerCase();
+        if (!valid.includes(norm))
+            throw new TypeError(`TinyForm: "method" must be one of ${valid.join(', ')}.`);
+        this.setAttr('method', norm);
+    }
+    /** @returns {string|null} */
+    get method() {
+        return this.attrString('method');
+    }
+    /** @param {'application/x-www-form-urlencoded'|'multipart/form-data'|'text/plain'} enctype */
+    set enctype(enctype) {
+        const valid = ['application/x-www-form-urlencoded', 'multipart/form-data', 'text/plain'];
+        if (!valid.includes(enctype))
+            throw new TypeError(`TinyForm: "enctype" must be one of ${valid.join(', ')}.`);
+        this.setAttr('enctype', enctype);
+    }
+    /** @returns {string|null} */
+    get enctype() {
+        return this.attrString('enctype');
+    }
+    /** @param {string} charset */
+    set acceptCharset(charset) {
+        if (typeof charset !== 'string')
+            throw new TypeError('TinyForm: "acceptCharset" must be a string.');
+        if (charset.toUpperCase() !== 'UTF-8')
+            console.warn('TinyForm: Only "UTF-8" is recommended for accept-charset.');
+        this.setAttr('accept-charset', charset);
+    }
+    /** @returns {string|null} */
+    get acceptCharset() {
+        return this.attrString('accept-charset');
+    }
+    /** @param {'none'|'off'|'sentences'|'on'|'words'|'characters'} value */
+    set autocapitalize(value) {
+        const valid = ['none', 'off', 'sentences', 'on', 'words', 'characters'];
+        if (!valid.includes(value))
+            throw new TypeError(`TinyForm: "autocapitalize" must be one of ${valid.join(', ')}.`);
+        this.setAttr('autocapitalize', value);
+    }
+    /** @returns {string|null} */
+    get autocapitalize() {
+        return this.attrString('autocapitalize');
+    }
+    /** @param {'on'|'off'} value */
+    set autocomplete(value) {
+        if (!['on', 'off'].includes(value))
+            throw new TypeError('TinyForm: "autocomplete" must be "on" or "off".');
+        this.setAttr('autocomplete', value);
+    }
+    /** @returns {string|null} */
+    get autocomplete() {
+        return this.attrString('autocomplete');
+    }
+    /** @param {string} name */
+    set name(name) {
+        if (typeof name !== 'string')
+            throw new TypeError('TinyForm: "name" must be a string.');
+        if (name.trim() === '')
+            throw new TypeError('TinyForm: "name" cannot be empty.');
+        this.setAttr('name', name);
+    }
+    /** @returns {string|null} */
+    get name() {
+        return this.attrString('name');
+    }
+    /** @param {string} rel */
+    set rel(rel) {
+        if (typeof rel !== 'string')
+            throw new TypeError('TinyForm: "rel" must be a string.');
+        this.setAttr('rel', rel);
+    }
+    /** @returns {string|null} */
+    get rel() {
+        return this.attrString('rel');
+    }
+    /** @param {boolean} novalidate */
+    set novalidate(novalidate) {
+        if (typeof novalidate !== 'boolean')
+            throw new TypeError('TinyForm: "novalidate" must be a boolean.');
+        if (novalidate)
+            this.addProp('novalidate');
+        else
+            this.removeProp('novalidate');
+    }
+    /** @returns {boolean} */
+    get novalidate() {
+        return this.hasProp('novalidate');
+    }
+    /** @param {string} target */
+    set target(target) {
+        if (typeof target !== 'string')
+            throw new TypeError('TinyForm: "target" must be a string.');
+        const validTargets = ['_self', '_blank', '_parent', '_top', '_unfencedTop'];
+        const validName = /^[a-zA-Z_][\w-]*$/;
+        if (!validTargets.includes(target) && !validName.test(target))
+            throw new TypeError(`TinyForm: "target" must be a valid context name or one of ${validTargets.join(', ')}.`);
+        this.setAttr('target', target);
+    }
+    /** @returns {string|null} */
+    get target() {
+        return this.attrString('target');
+    }
+    /**
+     * Programmatically submits the form.
+     * @returns {this}
+     */
+    submit() {
+        this.el.submit();
+        return this;
+    }
+    /**
+     * Resets the form.
+     * @returns {this}
+     */
+    reset() {
+        this.el.reset();
+        return this;
+    }
+}
+export default TinyHtmlForm;

package/dist/v1/libs/TinyHtml/TinyHtmlIcon.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var TinyHtmlTemplate = require('./TinyHtmlTemplate.cjs');
+
+/**
+ * TinyIcon is a lightweight helper class for managing icon-like elements
+ * (such as `<i>` or `<span>` tags) with class-based styling.
+ * It extends TinyHtml to provide direct DOM element manipulation.
+ *
+ * @extends TinyHtmlTemplate<HTMLElement>
+ */
+class TinyHtmlIcon extends TinyHtmlTemplate {
+  /** @type {string} */
+  static #defaultTag = 'i';
+
+  /** @returns {string} */
+  static get defaultTag() {
+    return TinyHtmlIcon.#defaultTag;
+  }
+
+  /** @param {string} value */
+  static set defaultTag(value) {
+    if (typeof value !== 'string') throw new TypeError('defaultTag must be a string');
+    TinyHtmlIcon.#defaultTag = value;
+  }
+
+  /**
+   * Creates a new TinyIcon instance.
+   * @param {string|string[]|Set<string>} tags - Initial icon classes to apply.
+   * @param {string} [tagName=TinyHtmlIcon.#defaultTag] - The HTML tag to use for the element (e.g., `i`, `span`).
+   */
+  constructor(tags, tagName = TinyHtmlIcon.#defaultTag) {
+    if (typeof tagName !== 'string') throw new TypeError('TinyIcon: "tagName" must be a string.');
+    super(document.createElement(tagName), tags);
+  }
+}
+
+module.exports = TinyHtmlIcon;

package/dist/v1/libs/TinyHtml/TinyHtmlIcon.d.mts

@@ -0,0 +1,24 @@
+export default TinyHtmlIcon;
+/**
+ * TinyIcon is a lightweight helper class for managing icon-like elements
+ * (such as `<i>` or `<span>` tags) with class-based styling.
+ * It extends TinyHtml to provide direct DOM element manipulation.
+ *
+ * @extends TinyHtmlTemplate<HTMLElement>
+ */
+declare class TinyHtmlIcon extends TinyHtmlTemplate<HTMLElement> {
+    /** @type {string} */
+    static "__#38@#defaultTag": string;
+    /** @param {string} value */
+    static set defaultTag(value: string);
+    /** @returns {string} */
+    static get defaultTag(): string;
+    /**
+     * Creates a new TinyIcon instance.
+     * @param {string|string[]|Set<string>} tags - Initial icon classes to apply.
+     * @param {string} [tagName=TinyHtmlIcon.#defaultTag] - The HTML tag to use for the element (e.g., `i`, `span`).
+     */
+    constructor(tags: string | string[] | Set<string>, tagName?: string);
+}
+import TinyHtmlTemplate from './TinyHtmlTemplate.mjs';
+//# sourceMappingURL=TinyHtmlIcon.d.mts.map

package/dist/v1/libs/TinyHtml/TinyHtmlIcon.mjs

@@ -0,0 +1,33 @@
+import TinyHtmlTemplate from './TinyHtmlTemplate.mjs';
+/**
+ * TinyIcon is a lightweight helper class for managing icon-like elements
+ * (such as `<i>` or `<span>` tags) with class-based styling.
+ * It extends TinyHtml to provide direct DOM element manipulation.
+ *
+ * @extends TinyHtmlTemplate<HTMLElement>
+ */
+class TinyHtmlIcon extends TinyHtmlTemplate {
+    /** @type {string} */
+    static #defaultTag = 'i';
+    /** @returns {string} */
+    static get defaultTag() {
+        return TinyHtmlIcon.#defaultTag;
+    }
+    /** @param {string} value */
+    static set defaultTag(value) {
+        if (typeof value !== 'string')
+            throw new TypeError('defaultTag must be a string');
+        TinyHtmlIcon.#defaultTag = value;
+    }
+    /**
+     * Creates a new TinyIcon instance.
+     * @param {string|string[]|Set<string>} tags - Initial icon classes to apply.
+     * @param {string} [tagName=TinyHtmlIcon.#defaultTag] - The HTML tag to use for the element (e.g., `i`, `span`).
+     */
+    constructor(tags, tagName = TinyHtmlIcon.#defaultTag) {
+        if (typeof tagName !== 'string')
+            throw new TypeError('TinyIcon: "tagName" must be a string.');
+        super(document.createElement(tagName), tags);
+    }
+}
+export default TinyHtmlIcon;

package/dist/v1/libs/TinyHtml/TinyHtmlIframe.cjs

@@ -0,0 +1,222 @@
+'use strict';
+
+var TinyHtmlTemplate = require('./TinyHtmlTemplate.cjs');
+
+/**
+ * TinyHtmlIframe is a helper class for managing <iframe> elements.
+ * It supports all standard attributes with validation and type safety.
+ *
+ * @example
+ * const iframe = new TinyHtmlIframe({
+ *   src: 'https://example.com',
+ *   width: 600,
+ *   height: 400,
+ *   loading: 'lazy',
+ *   sandbox: 'allow-scripts allow-same-origin',
+ *   referrerpolicy: 'no-referrer',
+ * });
+ *
+ * @extends TinyHtmlTemplate<HTMLIFrameElement>
+ */
+class TinyHtmlIframe extends TinyHtmlTemplate {
+  /**
+   * Creates a new TinyHtmlIframe instance with the specified configuration options.
+   *
+   * @param {Object} [config={}] - Configuration object for the iframe element.
+   * @param {string} [config.src] - The URL of the page to embed inside the iframe.
+   * @param {string} [config.srcdoc] - Inline HTML content to display inside the iframe (overrides `src` if provided).
+   * @param {string} [config.name] - A name for the browsing context (used as the target for links or forms).
+   * @param {string} [config.allow] - Permissions policy for the iframe (e.g., `"fullscreen; autoplay"`).
+   * @param {boolean} [config.allowFullScreen=false] - Whether the iframe is allowed to display content in fullscreen mode.
+   * @param {boolean} [config.browsingtopics] - Enables the Browsing Topics API.
+   * @param {boolean} [config.credentialless] - Enables credentialless mode for cross-origin iframes.
+   * @param {string} [config.csp] - Content Security Policy applied specifically to the iframe's content.
+   * @param {string} [config.sandbox] - A space-separated list of sandboxing flags that restrict iframe capabilities.
+   * @param {'no-referrer'|'no-referrer-when-downgrade'|'origin'|'origin-when-cross-origin'|'same-origin'|'strict-origin'|'strict-origin-when-cross-origin'|'unsafe-url'} [config.referrerpolicy] - Referrer policy to control the amount of referrer information sent.
+   * @param {number|string} [config.width] - Width of the iframe in pixels or as a CSS dimension string (e.g., `"100%"`).
+   * @param {number|string} [config.height] - Height of the iframe in pixels or as a CSS dimension string (e.g., `"500px"`).
+   * @param {string} [config.title] - Accessible title for the iframe content.
+   * @param {'lazy'|'eager'} [config.loading] - Loading strategy for the iframe. `"lazy"` defers loading until visible in the viewport.
+   * @param {string|string[]|Set<string>} [config.tags=[]] - Additional tags or identifiers for this instance.
+   * @param {string} [config.mainClass=''] - A main CSS class applied to the iframe element.
+   */
+  constructor({
+    src,
+    srcdoc,
+    name,
+    allow,
+    allowFullScreen = false,
+    browsingtopics,
+    credentialless,
+    csp,
+    sandbox,
+    referrerpolicy,
+    width,
+    height,
+    title,
+    loading,
+    tags = [],
+    mainClass = '',
+  } = {}) {
+    super(document.createElement('iframe'), tags, mainClass);
+
+    if (src !== undefined) this.src = src;
+    if (srcdoc !== undefined) this.srcdoc = srcdoc;
+    if (name !== undefined) this.name = name;
+    if (allow !== undefined) this.allow = allow;
+    this.allowFullScreen = allowFullScreen;
+    if (browsingtopics !== undefined) this.browsingtopics = browsingtopics;
+    if (credentialless !== undefined) this.credentialless = credentialless;
+    if (csp !== undefined) this.csp = csp;
+    if (sandbox !== undefined) this.sandbox = sandbox;
+    if (referrerpolicy !== undefined) this.referrerpolicy = referrerpolicy;
+    if (width !== undefined) this.setWidth(width);
+    if (height !== undefined) this.setHeight(height);
+    if (title !== undefined) this.title = title;
+    if (loading !== undefined) this.loading = loading;
+  }
+
+  // --- attributes ---
+
+  /** @param {string} src */
+  set src(src) {
+    if (typeof src !== 'string') throw new TypeError('TinyIframe: "src" must be a string.');
+    this.setAttr('src', src);
+  }
+  /** @returns {string|null} */
+  get src() {
+    return this.attrString('src');
+  }
+
+  /** @param {string} srcdoc */
+  set srcdoc(srcdoc) {
+    if (typeof srcdoc !== 'string') throw new TypeError('TinyIframe: "srcdoc" must be a string.');
+    this.setAttr('srcdoc', srcdoc);
+  }
+  /** @returns {string|null} */
+  get srcdoc() {
+    return this.attrString('srcdoc');
+  }
+
+  /** @param {string} name */
+  set name(name) {
+    if (typeof name !== 'string') throw new TypeError('TinyIframe: "name" must be a string.');
+    this.setAttr('name', name);
+  }
+  /** @returns {string|null} */
+  get name() {
+    return this.attrString('name');
+  }
+
+  /** @param {string} allow */
+  set allow(allow) {
+    if (typeof allow !== 'string') throw new TypeError('TinyIframe: "allow" must be a string.');
+    this.setAttr('allow', allow);
+  }
+  /** @returns {string|null} */
+  get allow() {
+    return this.attrString('allow');
+  }
+
+  /** @param {boolean} allowFullScreen */
+  set allowFullScreen(allowFullScreen) {
+    if (typeof allowFullScreen !== 'boolean')
+      throw new TypeError('TinyIframe: "allowFullScreen" must be a boolean.');
+    if (allowFullScreen) this.addProp('allowfullscreen');
+    else this.removeProp('allowfullscreen');
+  }
+  /** @returns {boolean} */
+  get allowFullScreen() {
+    return this.hasProp('allowfullscreen');
+  }
+
+  /** @param {boolean} browsingtopics */
+  set browsingtopics(browsingtopics) {
+    if (typeof browsingtopics !== 'boolean')
+      throw new TypeError('TinyIframe: "browsingtopics" must be a boolean.');
+    if (browsingtopics) this.addProp('browsingtopics');
+    else this.removeProp('browsingtopics');
+  }
+  /** @returns {boolean} */
+  get browsingtopics() {
+    return this.hasProp('browsingtopics');
+  }
+
+  /** @param {boolean} credentialless */
+  set credentialless(credentialless) {
+    if (typeof credentialless !== 'boolean')
+      throw new TypeError('TinyIframe: "credentialless" must be a boolean.');
+    if (credentialless) this.addProp('credentialless');
+    else this.removeProp('credentialless');
+  }
+  /** @returns {boolean} */
+  get credentialless() {
+    return this.hasProp('credentialless');
+  }
+
+  /** @param {string} csp */
+  set csp(csp) {
+    if (typeof csp !== 'string') throw new TypeError('TinyIframe: "csp" must be a string.');
+    this.setAttr('csp', csp);
+  }
+  /** @returns {string|null} */
+  get csp() {
+    return this.attrString('csp');
+  }
+
+  /** @param {string} sandbox */
+  set sandbox(sandbox) {
+    if (typeof sandbox !== 'string')
+      throw new TypeError('TinyIframe: "sandbox" must be a string (space-separated tokens).');
+    this.setAttr('sandbox', sandbox);
+  }
+  /** @returns {string|null} */
+  get sandbox() {
+    return this.attrString('sandbox');
+  }
+
+  /** @param {string} referrerpolicy */
+  set referrerpolicy(referrerpolicy) {
+    const valid = [
+      'no-referrer',
+      'no-referrer-when-downgrade',
+      'origin',
+      'origin-when-cross-origin',
+      'same-origin',
+      'strict-origin',
+      'strict-origin-when-cross-origin',
+      'unsafe-url',
+    ];
+    if (!valid.includes(referrerpolicy))
+      throw new TypeError(`TinyIframe: "referrerpolicy" must be one of: ${valid.join(', ')}.`);
+    this.setAttr('referrerpolicy', referrerpolicy);
+  }
+  /** @returns {string|null} */
+  get referrerpolicy() {
+    return this.attrString('referrerpolicy');
+  }
+
+  /** @param {string} title */
+  set title(title) {
+    if (typeof title !== 'string') throw new TypeError('TinyIframe: "title" must be a string.');
+    this.setAttr('title', title);
+  }
+  /** @returns {string|null} */
+  get title() {
+    return this.attrString('title');
+  }
+
+  /** @param {'lazy'|'eager'} loading */
+  set loading(loading) {
+    const valid = ['lazy', 'eager'];
+    if (!valid.includes(loading))
+      throw new TypeError(`TinyIframe: "loading" must be one of: ${valid.join(', ')}.`);
+    this.setAttr('loading', loading);
+  }
+  /** @returns {string|null} */
+  get loading() {
+    return this.attrString('loading');
+  }
+}
+
+module.exports = TinyHtmlIframe;