@ngockhoi96/ctc 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ngockhoi96 contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,302 @@
+# @ngockhoi96/ctc
+
+Modular, tree-shakeable browser utilities library. Zero dependencies, framework-agnostic.
+
+[![npm version](https://img.shields.io/npm/v/@ngockhoi96/ctc)](https://www.npmjs.com/package/@ngockhoi96/ctc)
+[![Bundle Size](https://img.shields.io/bundlephobia/minzip/@ngockhoi96/ctc)](https://bundlephobia.com/package/@ngockhoi96/ctc)
+[![CI](https://github.com/anIcedAntFA/cttc/actions/workflows/ci.yml/badge.svg)](https://github.com/anIcedAntFA/cttc/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+> All functions are SSR-safe -- safe to import in Next.js, Nuxt, or any server-side environment without crashing.
+
+## Installation
+
+```bash
+# pnpm
+pnpm add @ngockhoi96/ctc
+
+# npm
+npm install @ngockhoi96/ctc
+
+# yarn
+yarn add @ngockhoi96/ctc
+```
+
+## Quick Start
+
+```typescript
+import { copyToClipboard, isClipboardSupported } from '@ngockhoi96/ctc/clipboard'
+
+button.addEventListener('click', async () => {
+  if (isClipboardSupported()) {
+    const success = await copyToClipboard('Hello, world!')
+    console.log(success ? 'Copied!' : 'Copy failed')
+  }
+})
+```
+
+## API Reference
+
+### `copyToClipboard(text, options?)`
+
+Copy text to the clipboard using the modern Clipboard API.
+
+```typescript
+function copyToClipboard(text: string, options?: ClipboardOptions): Promise<boolean>
+```
+
+**Returns:** `true` on success, `false` on any failure (never throws).
+
+**Browser support:** Requires HTTPS (secure context) and a user gesture (click, keydown, etc.). Chrome 66+, Firefox 63+, Safari 13.1+.
+
+```typescript
+import { copyToClipboard } from '@ngockhoi96/ctc/clipboard'
+
+button.addEventListener('click', async () => {
+  const success = await copyToClipboard('Hello, world!')
+  if (!success) {
+    showError('Copy failed -- check HTTPS and permissions')
+  }
+})
+```
+
+**Remarks:**
+
+- Must be called synchronously within a user gesture handler. Programmatic calls from timers or microtasks will be rejected by the browser with `CLIPBOARD_PERMISSION_DENIED`.
+- Returns `false` on HTTP pages with `INSECURE_CONTEXT` error code. Use `copyToClipboardLegacy()` for HTTP environments.
+- On Safari, calling any async operation before `writeText()` in the same microtask may break the user activation window. Keep the call synchronous within the click handler.
+
+---
+
+### `readFromClipboard(options?)`
+
+Read text from the clipboard using the modern Clipboard API.
+
+```typescript
+function readFromClipboard(options?: ClipboardOptions): Promise<string | null>
+```
+
+**Returns:** The clipboard text string on success, `null` on failure (never throws).
+
+**Browser support:** Requires HTTPS (secure context) and a user gesture. May trigger a permission prompt on first call. Chrome 66+, Firefox 63+, Safari 13.1+.
+
+```typescript
+import { readFromClipboard } from '@ngockhoi96/ctc/clipboard'
+
+pasteButton.addEventListener('click', async () => {
+  const text = await readFromClipboard()
+  if (text !== null) {
+    input.value = text
+  }
+})
+```
+
+**Remarks:**
+
+- Chrome prompts for `clipboard-read` permission on the first call. Firefox and Safari show a system-level paste prompt.
+- If the clipboard contains only non-text content (e.g., an image), the read operation fails with `CLIPBOARD_READ_FAILED`.
+
+---
+
+### `isClipboardSupported()`
+
+Check if the Clipboard API is available and usable for write operations in the current context.
+
+```typescript
+function isClipboardSupported(): boolean
+```
+
+**Returns:** `true` if clipboard write operations are supported. Returns `false` in SSR environments, on HTTP pages, or when the Clipboard API is absent.
+
+**Browser support:** Synchronous check, no permissions needed. Chrome 66+, Firefox 63+, Safari 13.1+. Returns `false` on HTTP and in SSR.
+
+```typescript
+import { isClipboardSupported, copyToClipboardLegacy, copyToClipboard } from '@ngockhoi96/ctc/clipboard'
+
+if (isClipboardSupported()) {
+  await copyToClipboard(text)
+} else {
+  copyToClipboardLegacy(text)
+}
+```
+
+**Remarks:**
+
+- Permission state is not checked. A `true` result does not guarantee the user has granted clipboard access. Permission denial is surfaced at call time via `CLIPBOARD_PERMISSION_DENIED`.
+
+---
+
+### `isClipboardReadSupported()`
+
+Check if clipboard read operations are available and usable in the current context.
+
+```typescript
+function isClipboardReadSupported(): boolean
+```
+
+**Returns:** `true` if clipboard read operations are supported. Returns `false` in SSR environments, on HTTP pages, or when the read API is absent.
+
+**Browser support:** Synchronous check, no permissions needed. Chrome 66+, Firefox 63+, Safari 13.1+. Returns `false` on HTTP and in SSR.
+
+```typescript
+import { isClipboardReadSupported, readFromClipboard } from '@ngockhoi96/ctc/clipboard'
+
+if (isClipboardReadSupported()) {
+  const text = await readFromClipboard()
+}
+```
+
+**Remarks:**
+
+- Firefox does not support the Permissions API `clipboard-read` query. This function uses synchronous feature detection only.
+
+---
+
+### `copyToClipboardLegacy(text, options?)`
+
+Copy text to the clipboard using the deprecated `document.execCommand('copy')` API.
+
+```typescript
+function copyToClipboardLegacy(text: string, options?: ClipboardOptions): boolean
+```
+
+**Returns:** `true` on success, `false` on failure (synchronous, never throws).
+
+**Browser support:** Works on HTTP pages via deprecated `execCommand`. Supported in all desktop browsers. Not reliable on iOS Safari. Use only when the modern Clipboard API is unavailable.
+
+```typescript
+import { isClipboardSupported, copyToClipboard, copyToClipboardLegacy } from '@ngockhoi96/ctc/clipboard'
+
+async function copyText(text: string): Promise<boolean> {
+  if (isClipboardSupported()) {
+    return copyToClipboard(text)
+  }
+  return copyToClipboardLegacy(text)
+}
+```
+
+**Remarks:**
+
+- Uses the deprecated `document.execCommand('copy')` API, which is synchronous and text-only.
+- No secure context requirement. This function exists for environments where `copyToClipboard()` is unavailable due to HTTP.
+- Temporarily creates and removes a textarea element in the DOM to perform the copy operation.
+- `execCommand` copy is not reliably supported on iOS Safari. This function may return `false` on iOS Safari without a usable fallback.
+
+## Error Handling
+
+All clipboard functions accept an optional `onError` callback that receives a structured `BrowserUtilsError` object. Functions never throw -- they return `false` or `null` on failure.
+
+### `BrowserUtilsError`
+
+```typescript
+interface BrowserUtilsError {
+  code: ErrorCode
+  message: string
+  cause?: unknown
+}
+
+type ErrorCode =
+  | 'CLIPBOARD_NOT_SUPPORTED'
+  | 'CLIPBOARD_PERMISSION_DENIED'
+  | 'CLIPBOARD_WRITE_FAILED'
+  | 'CLIPBOARD_READ_FAILED'
+  | 'INSECURE_CONTEXT'
+```
+
+### `ClipboardOptions`
+
+```typescript
+interface ClipboardOptions {
+  onError?: (error: BrowserUtilsError) => void
+}
+```
+
+### Error Codes
+
+| Code | Description |
+|------|-------------|
+| `CLIPBOARD_NOT_SUPPORTED` | Clipboard API is unavailable (SSR environment, very old browser, or `navigator.clipboard` missing) |
+| `INSECURE_CONTEXT` | Page is served over HTTP (not HTTPS). The Clipboard API requires a secure context. Use `copyToClipboardLegacy()` instead |
+| `CLIPBOARD_PERMISSION_DENIED` | User denied clipboard permission, or the call was made outside a user gesture |
+| `CLIPBOARD_WRITE_FAILED` | Write operation failed for an unexpected reason |
+| `CLIPBOARD_READ_FAILED` | Read operation failed for an unexpected reason |
+
+### Example: Using `onError`
+
+```typescript
+import { copyToClipboard } from '@ngockhoi96/ctc/clipboard'
+
+await copyToClipboard('text', {
+  onError: (err) => {
+    switch (err.code) {
+      case 'CLIPBOARD_PERMISSION_DENIED':
+        showPermissionPrompt()
+        break
+      case 'INSECURE_CONTEXT':
+        // Fall back to legacy method on HTTP pages
+        copyToClipboardLegacy(text)
+        break
+      default:
+        console.error('Clipboard error:', err.message)
+    }
+  }
+})
+```
+
+Without `onError`, expected failures (`CLIPBOARD_NOT_SUPPORTED`, `INSECURE_CONTEXT`, `CLIPBOARD_PERMISSION_DENIED`) are logged with `console.warn`. Unexpected failures (`CLIPBOARD_WRITE_FAILED`, `CLIPBOARD_READ_FAILED`) are logged with `console.error`.
+
+## Browser Support
+
+| Function | Chrome | Firefox | Safari | HTTP Support |
+|----------|--------|---------|--------|--------------|
+| `copyToClipboard` | 66+ | 63+ | 13.1+ | No (use legacy) |
+| `readFromClipboard` | 66+ | 63+ | 13.1+ | No |
+| `isClipboardSupported` | 66+ | 63+ | 13.1+ | Returns `false` |
+| `isClipboardReadSupported` | 66+ | 63+ | 13.1+ | Returns `false` |
+| `copyToClipboardLegacy` | All | All | Partial | Yes |
+
+All functions require ES2020+ (>95% global browser support).
+
+All functions are SSR-safe and will return `false` or `null` when called in a server-side environment (Node.js, Deno, Bun) without crashing.
+
+## Contributing
+
+Contributions are welcome! Please open an [issue](https://github.com/anIcedAntFA/cttc/issues) for bug reports or feature requests.
+
+### Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Run checks before committing
+pnpm lint && pnpm test && pnpm build
+```
+
+### Commit Format
+
+This project uses [conventional commits](https://www.conventionalcommits.org/) enforced by commitlint:
+
+```
+feat(clipboard): add new utility function
+fix(clipboard): handle edge case in Safari
+chore: update dependencies
+```
+
+### Versioning
+
+This library follows [semantic versioning](https://semver.org/). While pre-1.0 (`0.x.y`), minor version bumps may include breaking changes. Pin to a specific minor version if stability is critical:
+
+```bash
+pnpm add @ngockhoi96/ctc@~0.1.0
+```
+
+### Publishing
+
+Releases are automated via [changesets](https://github.com/changesets/changesets). Merging a changeset to `main` triggers a Version PR. Merging the Version PR publishes to npm automatically.
+
+Maintainers: an `NPM_TOKEN` secret must be configured in GitHub repository settings for automated npm publishing.
+
+## License
+
+[MIT](./LICENSE)

package/dist/clipboard/index.cjs

@@ -0,0 +1,7 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_clipboard = require("../clipboard-Bs9DV14p.cjs");
+exports.copyToClipboard = require_clipboard.copyToClipboard;
+exports.copyToClipboardLegacy = require_clipboard.copyToClipboardLegacy;
+exports.isClipboardReadSupported = require_clipboard.isClipboardReadSupported;
+exports.isClipboardSupported = require_clipboard.isClipboardSupported;
+exports.readFromClipboard = require_clipboard.readFromClipboard;

package/dist/clipboard/index.d.cts

@@ -0,0 +1,2 @@
+import { a as copyToClipboard, c as ErrorCode, i as isClipboardSupported, l as OnErrorCallback, n as copyToClipboardLegacy, o as ClipboardOptions, r as isClipboardReadSupported, s as BrowserUtilsError, t as readFromClipboard } from "../index-CHCHjqWe.cjs";
+export { BrowserUtilsError, ClipboardOptions, ErrorCode, OnErrorCallback, copyToClipboard, copyToClipboardLegacy, isClipboardReadSupported, isClipboardSupported, readFromClipboard };

package/dist/clipboard/index.d.mts

@@ -0,0 +1,2 @@
+import { a as copyToClipboard, c as ErrorCode, i as isClipboardSupported, l as OnErrorCallback, n as copyToClipboardLegacy, o as ClipboardOptions, r as isClipboardReadSupported, s as BrowserUtilsError, t as readFromClipboard } from "../index-B7FFRy7e.mjs";
+export { BrowserUtilsError, ClipboardOptions, ErrorCode, OnErrorCallback, copyToClipboard, copyToClipboardLegacy, isClipboardReadSupported, isClipboardSupported, readFromClipboard };

package/dist/clipboard/index.mjs

@@ -0,0 +1,2 @@
+import { a as copyToClipboard, i as isClipboardSupported, n as copyToClipboardLegacy, r as isClipboardReadSupported, t as readFromClipboard } from "../clipboard-OTP55cvN.mjs";
+export { copyToClipboard, copyToClipboardLegacy, isClipboardReadSupported, isClipboardSupported, readFromClipboard };

package/dist/clipboard-Bs9DV14p.cjs

@@ -0,0 +1,338 @@
+//#region src/lib/env.ts
+/**
+* Check if code is running in a browser environment.
+*
+* @returns `true` if `navigator` and `window` are defined
+*/
+function isBrowser() {
+	return typeof navigator !== "undefined" && typeof window !== "undefined";
+}
+/**
+* Check if the current context is secure (HTTPS or localhost).
+*
+* Clipboard API requires a secure context in modern browsers.
+*
+* @returns `true` if running in a browser with a secure context
+*/
+function isSecureContext() {
+	return isBrowser() && window.isSecureContext === true;
+}
+//#endregion
+//#region src/lib/errors.ts
+/**
+* Error codes that represent expected, recoverable failures.
+*
+* Expected errors are logged with `console.warn`.
+* Unexpected errors are logged with `console.error`.
+*
+* @internal
+*/
+const EXPECTED_ERROR_CODES = new Set([
+	"CLIPBOARD_NOT_SUPPORTED",
+	"INSECURE_CONTEXT",
+	"CLIPBOARD_PERMISSION_DENIED"
+]);
+/**
+* Create a structured browser utils error.
+*
+* @param code - Error code identifying the failure type
+* @param message - Human-readable error description
+* @param cause - Original error that caused this failure
+* @returns A structured BrowserUtilsError object
+*/
+function createError(code, message, cause) {
+	return {
+		code,
+		message,
+		cause
+	};
+}
+/**
+* Invoke the onError callback if provided, otherwise log a warning or error.
+*
+* Expected failures (CLIPBOARD_NOT_SUPPORTED, INSECURE_CONTEXT,
+* CLIPBOARD_PERMISSION_DENIED) are logged with `console.warn`.
+* Unexpected failures (CLIPBOARD_WRITE_FAILED, CLIPBOARD_READ_FAILED) are
+* logged with `console.error` and include the original cause for debugging.
+*
+* @param error - The structured error to handle
+* @param onError - Optional callback for error reporting
+*/
+function handleError(error, onError) {
+	if (onError) {
+		try {
+			onError(error);
+		} catch {}
+		return;
+	}
+	const prefix = "[ngockhoi96]";
+	if (EXPECTED_ERROR_CODES.has(error.code)) console.warn(`${prefix} ${error.code}: ${error.message}`);
+	else console.error(`${prefix} ${error.code}: ${error.message}`, error.cause);
+}
+//#endregion
+//#region src/clipboard/copy.ts
+/**
+* Copy text to the clipboard using the modern Clipboard API.
+*
+* Requires a secure context (HTTPS or localhost) and must be called from
+* within a user gesture handler (click, keydown, etc.).
+*
+* @param text - The text to copy to the clipboard
+* @param options - Optional configuration including `onError` callback
+* @returns `true` on success, `false` on any failure (never throws)
+*
+* @remarks
+* **User gesture requirement:** Must be called synchronously within a user
+* gesture handler. Programmatic calls from timers or microtasks will be
+* rejected by the browser with `CLIPBOARD_PERMISSION_DENIED`.
+*
+* **Secure context:** Returns `false` on HTTP pages with `INSECURE_CONTEXT`
+* error code. Use `copyToClipboardLegacy()` for HTTP environments.
+*
+* **Safari:** Calling any async operation before `writeText()` in the same
+* microtask may break Safari's user activation window. Keep the call
+* synchronous within the click handler.
+*
+* @example
+* ```ts
+* button.addEventListener('click', async () => {
+*   const success = await copyToClipboard('Hello, world!')
+*   if (!success) {
+*     showError('Copy failed — check HTTPS and permissions')
+*   }
+* })
+* ```
+*/
+async function copyToClipboard(text, options) {
+	if (!isBrowser()) {
+		handleError(createError("CLIPBOARD_NOT_SUPPORTED", "Not in a browser environment"), options?.onError);
+		return false;
+	}
+	if (!isSecureContext()) {
+		handleError(createError("INSECURE_CONTEXT", "Clipboard API requires a secure context (HTTPS)"), options?.onError);
+		return false;
+	}
+	if (typeof navigator.clipboard?.writeText !== "function") {
+		handleError(createError("CLIPBOARD_NOT_SUPPORTED", "Clipboard API not available"), options?.onError);
+		return false;
+	}
+	try {
+		await navigator.clipboard.writeText(text);
+		return true;
+	} catch (error) {
+		if (error instanceof DOMException && error.name === "NotAllowedError") handleError(createError("CLIPBOARD_PERMISSION_DENIED", "Clipboard write permission denied", error), options?.onError);
+		else handleError(createError("CLIPBOARD_WRITE_FAILED", "Failed to write to clipboard", error), options?.onError);
+		return false;
+	}
+}
+//#endregion
+//#region src/clipboard/detect.ts
+/**
+* Check if the Clipboard API is available and usable in the current context.
+*
+* Returns `true` only when `navigator.clipboard.writeText` exists AND the
+* page is running in a secure context (HTTPS or localhost). Returns `false`
+* in SSR environments, on HTTP pages, or when the Clipboard API is absent.
+*
+* @returns `true` if clipboard write operations are supported
+*
+* @remarks
+* Permission state is not checked — a `true` result does not guarantee the
+* user has granted clipboard access. Permission denial is surfaced at call
+* time via the `CLIPBOARD_PERMISSION_DENIED` error code on `copyToClipboard`.
+*
+* @example
+* ```ts
+* if (isClipboardSupported()) {
+*   await copyToClipboard(text)
+* } else {
+*   copyToClipboardLegacy(text)
+* }
+* ```
+*/
+function isClipboardSupported() {
+	return isBrowser() && isSecureContext() && typeof navigator.clipboard?.writeText === "function";
+}
+/**
+* Check if clipboard read operations are available and usable in the current context.
+*
+* Returns `true` only when `navigator.clipboard.readText` exists AND the
+* page is running in a secure context (HTTPS or localhost). Returns `false`
+* in SSR environments, on HTTP pages, or when the read API is absent.
+*
+* @returns `true` if clipboard read operations are supported
+*
+* @remarks
+* Permission state is not checked — a `true` result does not guarantee the
+* user has granted clipboard read access. Permission denial is surfaced at
+* call time via the `CLIPBOARD_PERMISSION_DENIED` error code on `readFromClipboard`.
+*
+* Firefox does not support the Permissions API `clipboard-read` query. This
+* function uses synchronous feature detection only — no async permission
+* queries are performed.
+*
+* @example
+* ```ts
+* if (isClipboardReadSupported()) {
+*   const text = await readFromClipboard()
+* }
+* ```
+*/
+function isClipboardReadSupported() {
+	return isBrowser() && isSecureContext() && typeof navigator.clipboard?.readText === "function";
+}
+//#endregion
+//#region src/clipboard/fallback.ts
+/**
+* Copy text to the clipboard using the legacy `document.execCommand` API.
+*
+* Use this function when the modern Clipboard API is unavailable — for
+* example, on HTTP pages (non-HTTPS) or in browsers that do not support
+* `navigator.clipboard`. For HTTPS pages, prefer `copyToClipboard()`.
+*
+* @param text - The text to copy to the clipboard
+* @param options - Optional configuration including `onError` callback
+* @returns `true` on success, `false` on any failure (never throws)
+*
+* @remarks
+* This function uses the deprecated `document.execCommand('copy')` API,
+* which is synchronous and text-only. It temporarily creates and removes a
+* textarea element in the DOM to perform the copy operation.
+*
+* **No secure context requirement:** This function works on HTTP pages.
+* This is by design — it exists for environments where `copyToClipboard()`
+* is unavailable due to missing secure context.
+*
+* **iOS Safari:** `execCommand` copy is not reliably supported on iOS.
+* This function may return `false` on iOS Safari without a usable fallback.
+*
+* @example
+* ```ts
+* if (isClipboardSupported()) {
+*   await copyToClipboard(text)
+* } else {
+*   const success = copyToClipboardLegacy(text)
+*   if (!success) {
+*     showManualCopyInstructions()
+*   }
+* }
+* ```
+*/
+function copyToClipboardLegacy(text, options) {
+	if (!isBrowser()) {
+		handleError(createError("CLIPBOARD_NOT_SUPPORTED", "Not in a browser environment"), options?.onError);
+		return false;
+	}
+	if (!document.body) {
+		handleError(createError("CLIPBOARD_NOT_SUPPORTED", "document.body is not available"), options?.onError);
+		return false;
+	}
+	const textarea = document.createElement("textarea");
+	textarea.style.position = "fixed";
+	textarea.style.top = "0";
+	textarea.style.left = "0";
+	textarea.style.opacity = "0";
+	textarea.style.pointerEvents = "none";
+	textarea.style.fontSize = "16px";
+	textarea.readOnly = true;
+	textarea.value = text;
+	document.body.appendChild(textarea);
+	try {
+		textarea.focus();
+		textarea.setSelectionRange(0, text.length);
+		if (!document.execCommand("copy")) {
+			handleError(createError("CLIPBOARD_WRITE_FAILED", "execCommand copy returned false"), options?.onError);
+			return false;
+		}
+		return true;
+	} catch (error) {
+		handleError(createError("CLIPBOARD_WRITE_FAILED", "execCommand copy threw an error", error), options?.onError);
+		return false;
+	} finally {
+		if (textarea.isConnected) textarea.remove();
+	}
+}
+//#endregion
+//#region src/clipboard/read.ts
+/**
+* Read text from the clipboard using the modern Clipboard API.
+*
+* Requires a secure context (HTTPS or localhost). The browser may prompt
+* the user for permission on the first call.
+*
+* @param options - Optional configuration including `onError` callback
+* @returns The clipboard text on success, `null` on any failure (never throws)
+*
+* @remarks
+* **Permission prompt:** Chrome prompts for `clipboard-read` permission on
+* the first call. Firefox and Safari show a system-level paste prompt.
+* Permission denial is reported via `CLIPBOARD_PERMISSION_DENIED`.
+*
+* **Non-text content:** If the clipboard contains only non-text content
+* (e.g., an image), the browser throws `NotFoundError` which is reported
+* as `CLIPBOARD_READ_FAILED`.
+*
+* @example
+* ```ts
+* button.addEventListener('click', async () => {
+*   const text = await readFromClipboard()
+*   if (text !== null) {
+*     input.value = text
+*   }
+* })
+* ```
+*/
+async function readFromClipboard(options) {
+	if (!isBrowser()) {
+		handleError(createError("CLIPBOARD_NOT_SUPPORTED", "Not in a browser environment"), options?.onError);
+		return null;
+	}
+	if (!isSecureContext()) {
+		handleError(createError("INSECURE_CONTEXT", "Clipboard API requires a secure context (HTTPS)"), options?.onError);
+		return null;
+	}
+	if (typeof navigator.clipboard?.readText !== "function") {
+		handleError(createError("CLIPBOARD_NOT_SUPPORTED", "Clipboard read API not available"), options?.onError);
+		return null;
+	}
+	try {
+		return await navigator.clipboard.readText();
+	} catch (error) {
+		if (error instanceof DOMException && error.name === "NotAllowedError") handleError(createError("CLIPBOARD_PERMISSION_DENIED", "Clipboard read permission denied", error), options?.onError);
+		else handleError(createError("CLIPBOARD_READ_FAILED", "Failed to read from clipboard", error), options?.onError);
+		return null;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "copyToClipboard", {
+	enumerable: true,
+	get: function() {
+		return copyToClipboard;
+	}
+});
+Object.defineProperty(exports, "copyToClipboardLegacy", {
+	enumerable: true,
+	get: function() {
+		return copyToClipboardLegacy;
+	}
+});
+Object.defineProperty(exports, "isClipboardReadSupported", {
+	enumerable: true,
+	get: function() {
+		return isClipboardReadSupported;
+	}
+});
+Object.defineProperty(exports, "isClipboardSupported", {
+	enumerable: true,
+	get: function() {
+		return isClipboardSupported;
+	}
+});
+Object.defineProperty(exports, "readFromClipboard", {
+	enumerable: true,
+	get: function() {
+		return readFromClipboard;
+	}
+});
+
+//# sourceMappingURL=clipboard-Bs9DV14p.cjs.map