@askdkc/dsh-cli 0.11.3

package/lib/types/utils/fileTarget.d.ts

@@ -0,0 +1,46 @@
+/** Our custom OSC 8 scheme carrying a raw display path (URI-encoded). */
+export declare const FILE_LINK_SCHEME = "dsh-file:";
+/** Encode a display path into a `dsh-file:` link URL. */
+export declare function fileLinkUrl(path: string): string;
+/**
+ * Decode a `dsh-file:` link URL back to the raw display path. Returns
+ * undefined for anything that is not a well-formed dsh-file URL.
+ */
+export declare function parseFileLinkUrl(url: string): string | undefined;
+/**
+ * Resolve a target (raw display path) against the session's base directory:
+ * absolute paths and `~` pass through (with ~ expanded), everything else is
+ * joined onto the base. Pure, so it is unit-testable without a workspace.
+ */
+export declare function resolveTargetPath(path: string, baseDir: string): string;
+/**
+ * Convert a `file://` URL to a local path. Wraps node:url.fileURLToPath —
+ * undefined when the URL is not a valid file URL.
+ */
+export declare function fileUrlToPath(url: string): string | undefined;
+/**
+ * Conservative heuristic: does this text look like a file path worth
+ * making clickable? Requires a slash separator, no whitespace, no URL/email
+ * shape, and either a path anchor (`./`, `../`, `/`, `~/`, drive letter)
+ * with a real path shape (another separator or an extension — a bare
+ * anchored word like `/a` or `x.com/a` is too ambiguous), or a plausible
+ * file extension. Length-capped so huge tokens (base64, logs) never get
+ * linked.
+ */
+export declare function looksLikeFilePath(text: string): boolean;
+/**
+ * Best-effort existence hint: does `path` exist on disk? Used to decide
+ * whether to render a path as clickable in contexts where the raw text is
+ * ambiguous; never throws.
+ */
+export declare function pathExistsOnDisk(path: string): boolean;
+/**
+ * Replace every path-looking span in `text` via `wrap(path, display)`.
+ * Trailing sentence punctuation stays OUTSIDE the wrapped display (so
+ * "src/foo.ts." links `src/foo.ts` and keeps the period). Spans that fail
+ * `looksLikeFilePath` are returned unchanged.
+ * @param text - plain text to scan (no ANSI).
+ * @param wrap - builds the clickable rendering for one path.
+ */
+export declare function linkifyFilePaths(text: string, wrap: (path: string, display: string) => string): string;
+//# sourceMappingURL=fileTarget.d.ts.map

package/lib/types/utils/fileTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileTarget.d.ts","sourceRoot":"","sources":["../../../src/utils/fileTarget.ts"],"names":[],"mappings":"AAuBA,yEAAyE;AACzE,eAAO,MAAM,gBAAgB,cAAc,CAAA;AAE3C,yDAAyD;AACzD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAOhE;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAWvE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAM7D;AA0BD;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAoBvD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMtD;AAWD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,MAAM,GAC9C,MAAM,CAcR"}

package/lib/types/utils/fileTarget.js

@@ -0,0 +1,178 @@
+/**
+ * Clickable file targets: turning path-like text in AI output into
+ * clickable targets, and resolving those targets back to absolute paths at
+ * click time.
+ *
+ * Two URL shapes are produced / accepted:
+ * - `dsh-file:<encodeURIComponent(path)>` — our own scheme. The payload is
+ *   the RAW displayed path (possibly relative, possibly Windows-style), so
+ *   nothing is lost in transit and it resolves against the CURRENT
+ *   workspace at click time (paths in a long-lived session may outlive the
+ *   cwd they were written under).
+ * - `file://…` — real file URLs the model may emit in markdown; decoded
+ *   with node:url and treated the same way.
+ *
+ * `looksLikeFilePath` is deliberately conservative: it must be obviously a
+ * path (slash + no whitespace + anchor or extension), otherwise prose like
+ * "and/or" or "2024/01/15" would light up as clickable everywhere.
+ */
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+/** Our custom OSC 8 scheme carrying a raw display path (URI-encoded). */
+export const FILE_LINK_SCHEME = 'dsh-file:';
+/** Encode a display path into a `dsh-file:` link URL. */
+export function fileLinkUrl(path) {
+    return FILE_LINK_SCHEME + encodeURIComponent(path);
+}
+/**
+ * Decode a `dsh-file:` link URL back to the raw display path. Returns
+ * undefined for anything that is not a well-formed dsh-file URL.
+ */
+export function parseFileLinkUrl(url) {
+    if (!url.startsWith(FILE_LINK_SCHEME))
+        return undefined;
+    try {
+        return decodeURIComponent(url.slice(FILE_LINK_SCHEME.length));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resolve a target (raw display path) against the session's base directory:
+ * absolute paths and `~` pass through (with ~ expanded), everything else is
+ * joined onto the base. Pure, so it is unit-testable without a workspace.
+ */
+export function resolveTargetPath(path, baseDir) {
+    if (path === '')
+        return path;
+    if (path.startsWith('~/'))
+        return resolve(homedir(), path.slice(2));
+    if (path === '~')
+        return homedir();
+    // Windows drive-absolute (`C:\…`, `C:/…`) is absolute regardless of
+    // platform; node:path.isAbsolute handles the current platform only, so
+    // probe both separators explicitly.
+    if (/^[A-Za-z]:[\\/]/.test(path) || path.startsWith('/') || path.startsWith('\\')) {
+        return path;
+    }
+    return resolve(baseDir, path);
+}
+/**
+ * Convert a `file://` URL to a local path. Wraps node:url.fileURLToPath —
+ * undefined when the URL is not a valid file URL.
+ */
+export function fileUrlToPath(url) {
+    try {
+        return fileURLToPath(url);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Known source/config/data file extensions — the conservative allowlist. */
+const FILE_EXTENSION_RE = /\.([A-Za-z0-9]{1,6})$/u;
+/** A path is worth linking when it carries one of these anchors, or has a
+ *  known-extension tail. */
+const PATH_ANCHOR_RE = /^(\.{1,2}[\\/]|[\\/]|~[\\/]|[A-Za-z]:[\\/])/u;
+/** Stoplist for extension-like tails that are TLDs / prose words, not
+ *  file extensions (`github.com/foo` must not link as a file). */
+const NON_EXTENSION_TAILS = new Set([
+    'com', 'org', 'net', 'io', 'dev', 'app', 'edu', 'gov', 'mil', 'co', 'uk', 'cn',
+]);
+/** A dot-suffix of up to 6 alphanumerics is a plausible extension when at
+ *  least 4 chars precede it (`a/b.x`-style prose fragments and short
+ *  `x/y.ts` guesses must not false-positive). */
+function hasPlausibleExtension(stripped) {
+    const extMatch = FILE_EXTENSION_RE.exec(stripped);
+    if (extMatch === null)
+        return false;
+    const ext = extMatch[1].toLowerCase();
+    if (NON_EXTENSION_TAILS.has(ext))
+        return false;
+    return stripped.slice(0, extMatch.index).length >= 4;
+}
+/**
+ * Conservative heuristic: does this text look like a file path worth
+ * making clickable? Requires a slash separator, no whitespace, no URL/email
+ * shape, and either a path anchor (`./`, `../`, `/`, `~/`, drive letter)
+ * with a real path shape (another separator or an extension — a bare
+ * anchored word like `/a` or `x.com/a` is too ambiguous), or a plausible
+ * file extension. Length-capped so huge tokens (base64, logs) never get
+ * linked.
+ */
+export function looksLikeFilePath(text) {
+    const t = text.trim();
+    if (t.length < 2 || t.length > 200)
+        return false;
+    if (!t.includes('/') && !t.includes('\\'))
+        return false;
+    if (/\s/u.test(t))
+        return false;
+    if (/[<>"'`|?*]/.test(t))
+        return false;
+    // URLs (any scheme://, incl. file://) and emails are handled by their
+    // own linkifiers.
+    if (/^[a-z][a-z0-9+.-]*:\/\//iu.test(t) || /^www\./iu.test(t))
+        return false;
+    if (t.includes('@'))
+        return false;
+    if (/[#\u0000-\u001f]/u.test(t))
+        return false;
+    // Strip one layer of trailing punctuation so "foo/bar.ts." still links.
+    const stripped = t.replace(/[.,;:!?]+$/u, '');
+    if (stripped === '')
+        return false;
+    const separators = (stripped.match(/[\\/]/gu) ?? []).length;
+    if (PATH_ANCHOR_RE.test(stripped)) {
+        return separators >= 2 || hasPlausibleExtension(stripped);
+    }
+    return hasPlausibleExtension(stripped);
+}
+/**
+ * Best-effort existence hint: does `path` exist on disk? Used to decide
+ * whether to render a path as clickable in contexts where the raw text is
+ * ambiguous; never throws.
+ */
+export function pathExistsOnDisk(path) {
+    try {
+        return existsSync(path);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Candidate-span scanner: anchored paths (`./`, `../`, `/`, `~/`, drive)
+ * run to the end of the word; everything else must contain a slash AND a
+ * dot-extension tail. This is only a pre-filter — every span is then
+ * verified by `looksLikeFilePath` before it becomes clickable.
+ */
+const PATH_SPAN_RE = /(?:\.{1,2}[\\/]|[\\/]|~[\\/]|[A-Za-z]:[\\/])[^\s<>"'`|?#]*|(?:[^\s<>"'`|?#]*[\\/][^\s<>"'`|?#]*\.[A-Za-z0-9]{1,6})/gu;
+/**
+ * Replace every path-looking span in `text` via `wrap(path, display)`.
+ * Trailing sentence punctuation stays OUTSIDE the wrapped display (so
+ * "src/foo.ts." links `src/foo.ts` and keeps the period). Spans that fail
+ * `looksLikeFilePath` are returned unchanged.
+ * @param text - plain text to scan (no ANSI).
+ * @param wrap - builds the clickable rendering for one path.
+ */
+export function linkifyFilePaths(text, wrap) {
+    return text.replace(PATH_SPAN_RE, (match, offset, full) => {
+        // The slash-anchor branch would otherwise match inside URLs
+        // (`https:/…` matches `/…`): a span glued to a scheme colon or a `//`
+        // run is part of a URL, never a path. offset is available because the
+        // regex has no capture groups.
+        if (offset > 0) {
+            const prev = full[offset - 1];
+            if (prev === ':' || prev === '/')
+                return match;
+        }
+        const display = match.replace(/[.,;:!?]+$/u, '');
+        if (display === '' || !looksLikeFilePath(display))
+            return match;
+        return wrap(display, display) + match.slice(display.length);
+    });
+}

package/lib/types/utils/fold-long-lines.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Per-line character budget for transcript text.
+ *
+ * A single source line longer than this is clipped BEFORE it reaches the
+ * layout engine. Wrapping is what costs: one minified-JS line, a 300k-char
+ * pasted log line, or a file written through a tool call turns into
+ * thousands of visual rows, and the per-frame wrap + measure over that text
+ * (not the row count) is what stalls the transcript. Clipping at the source
+ * keeps the rendered line count — and therefore the layout work — bounded
+ * no matter what the model, the user, or a tool pastes in.
+ *
+ * 1000 characters is roughly ten terminal rows at a common width: long
+ * enough that ordinary prose, commands and URLs never notice, short enough
+ * that the pathological single line cannot dominate a frame. The exact
+ * threshold is a display choice, not a contract — `Ctrl+O` (global
+ * transcript expansion) always paints the raw text.
+ */
+export declare const LONG_LINE_MAX_CHARS = 1000;
+export type LongLineFold = {
+    /** Text to render. Identity-equal to the input when nothing was folded. */
+    readonly text: string;
+    /** Characters elided across every folded line (0 → nothing folded). */
+    readonly hiddenChars: number;
+    /** Number of lines that were clipped. */
+    readonly foldedLines: number;
+};
+/**
+ * Clip every line of `text` longer than `max` characters, appending an
+ * inline localized fold marker (`long-line-folded`) to the clipped line.
+ *
+ * Line boundaries are preserved (never re-flowed, never merged), so the
+ * result stays valid input for the markdown renderer and for diff-style
+ * line pairing. The caller decides WHEN to fold (e.g. not while the global
+ * expansion is on); this function is a pure, allocation-free fast path when
+ * no line exceeds the budget.
+ */
+export declare function foldLongLines(text: string, max?: number): LongLineFold;
+//# sourceMappingURL=fold-long-lines.d.ts.map

package/lib/types/utils/fold-long-lines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fold-long-lines.d.ts","sourceRoot":"","sources":["../../../src/utils/fold-long-lines.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,OAAO,CAAA;AAEvC,MAAM,MAAM,YAAY,GAAG;IACzB,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,uEAAuE;IACvE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,yCAAyC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B,CAAA;AAUD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAA4B,GAAG,YAAY,CAgD3F"}

package/lib/types/utils/fold-long-lines.js

@@ -0,0 +1,91 @@
+import { t } from '../i18n.js';
+/**
+ * Per-line character budget for transcript text.
+ *
+ * A single source line longer than this is clipped BEFORE it reaches the
+ * layout engine. Wrapping is what costs: one minified-JS line, a 300k-char
+ * pasted log line, or a file written through a tool call turns into
+ * thousands of visual rows, and the per-frame wrap + measure over that text
+ * (not the row count) is what stalls the transcript. Clipping at the source
+ * keeps the rendered line count — and therefore the layout work — bounded
+ * no matter what the model, the user, or a tool pastes in.
+ *
+ * 1000 characters is roughly ten terminal rows at a common width: long
+ * enough that ordinary prose, commands and URLs never notice, short enough
+ * that the pathological single line cannot dominate a frame. The exact
+ * threshold is a display choice, not a contract — `Ctrl+O` (global
+ * transcript expansion) always paints the raw text.
+ */
+export const LONG_LINE_MAX_CHARS = 1000;
+/** Compact count for the fold marker: exact below 10k, `12.3k`/`1.2m`
+ *  above (the status bar's own token/char presentation). */
+function formatCount(value) {
+    if (value < 10_000)
+        return String(value);
+    if (value < 1_000_000)
+        return `${(value / 1_000).toFixed(value < 100_000 ? 1 : 0)}k`;
+    return `${(value / 1_000_000).toFixed(1)}m`;
+}
+/**
+ * Clip every line of `text` longer than `max` characters, appending an
+ * inline localized fold marker (`long-line-folded`) to the clipped line.
+ *
+ * Line boundaries are preserved (never re-flowed, never merged), so the
+ * result stays valid input for the markdown renderer and for diff-style
+ * line pairing. The caller decides WHEN to fold (e.g. not while the global
+ * expansion is on); this function is a pure, allocation-free fast path when
+ * no line exceeds the budget.
+ */
+export function foldLongLines(text, max = LONG_LINE_MAX_CHARS) {
+    if (text === '' || max <= 0)
+        return { text, hiddenChars: 0, foldedLines: 0 };
+    // Common case (an ordinary message): no line can exceed the budget, so the
+    // whole scan is skipped. This is the path every short row takes.
+    if (text.length <= max)
+        return { text, hiddenChars: 0, foldedLines: 0 };
+    let out;
+    let lineStart = 0;
+    let hiddenChars = 0;
+    let foldedLines = 0;
+    for (;;) {
+        const newline = text.indexOf('\n', lineStart);
+        const lineEnd = newline === -1 ? text.length : newline;
+        const folded = lineEnd - lineStart > max;
+        if (folded) {
+            // First fold: everything before this line is untouched, so it is
+            // copied over in one slice and every later line is appended in order.
+            if (out === undefined) {
+                out = [];
+                if (lineStart > 0)
+                    out.push(text.slice(0, lineStart));
+            }
+        }
+        if (out !== undefined) {
+            if (folded) {
+                let end = lineStart + max;
+                // Never split a surrogate pair: an astral character (emoji, rare CJK)
+                // is two UTF-16 code units, and half of one renders as U+FFFD.
+                const lead = text.charCodeAt(end - 1);
+                const trail = text.charCodeAt(end);
+                if (lead >= 0xD800 && lead <= 0xDBFF && trail >= 0xDC00 && trail <= 0xDFFF)
+                    end--;
+                const hidden = lineEnd - end;
+                hiddenChars += hidden;
+                foldedLines++;
+                out.push(text.slice(lineStart, end));
+                out.push(` ${t('long-line-folded', { n: formatCount(hidden) })}`);
+            }
+            else {
+                out.push(text.slice(lineStart, lineEnd));
+            }
+            if (newline !== -1)
+                out.push('\n');
+        }
+        if (newline === -1)
+            break;
+        lineStart = newline + 1;
+    }
+    if (out === undefined)
+        return { text, hiddenChars: 0, foldedLines: 0 };
+    return { text: out.join(''), hiddenChars, foldedLines };
+}

package/lib/types/utils/fullscreen.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Whether mouse click handling is disabled. dsh-tui reads its own environment
+ * flag (`DSH_TUI_DISABLE_MOUSE`) for this decision.
+ * @returns True when DSH_TUI_DISABLE_MOUSE is set to a truthy value.
+ */
+export declare function isMouseClicksDisabled(): boolean;
+//# sourceMappingURL=fullscreen.d.ts.map

package/lib/types/utils/fullscreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fullscreen.d.ts","sourceRoot":"","sources":["../../../src/utils/fullscreen.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAE/C"}

package/lib/types/utils/fullscreen.js

@@ -0,0 +1,9 @@
+import { isEnvTruthy } from './envUtils.js';
+/**
+ * Whether mouse click handling is disabled. dsh-tui reads its own environment
+ * flag (`DSH_TUI_DISABLE_MOUSE`) for this decision.
+ * @returns True when DSH_TUI_DISABLE_MOUSE is set to a truthy value.
+ */
+export function isMouseClicksDisabled() {
+    return isEnvTruthy(process.env.DSH_TUI_DISABLE_MOUSE);
+}

package/lib/types/utils/imageResize.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Inbound image adaptation for the composer's staging gate.
+ *
+ * The upstream attachment store admits images by media type, byte budget,
+ * pixel budget and a per-side dimension cap (`maxImageDimension`). Two kinds
+ * of paste used to fail with no user-side recourse: one that exceeds the
+ * dimension cap, and one whose format the deployment does not accept. This
+ * module measures the bytes BEFORE staging and produces an admissible pair
+ * (bytes + media type) through sharp — an optionalDependency, absent on
+ * minimal installs, which must degrade with a clear error, not a crash.
+ *
+ * Sizing probe is pure byte inspection (PNG/JPEG/WebP/GIF). Formats the
+ * probe cannot identify return null and MUST be forced through an actual
+ * decode for measurement — the #432 review gap was letting an
+ * "unrecognized but under the byte cap" image through, where a
+ * large-resolution small-byte WebP/GIF would sail past the probe and be
+ * rejected by upstream afterwards.
+ *
+ * The single entry point is {@link adaptImageForAdmission}: it decides
+ * whether anything has to change (resample, re-encode, or both) and reports
+ * exactly what it did, so the caller can tell the user instead of silently
+ * rewriting their image.
+ */
+export interface ImageSizeProbe {
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Measure intrinsic pixel dimensions from the encoded bytes alone — no
+ * decode, no dependencies. Recognizes PNG / JPEG / WebP (VP8X, VP8,
+ * VP8L) / GIF; anything else returns null, which callers MUST treat as
+ * "unknown, force a real decode" — never as "small enough".
+ */
+export declare function probeImageSize(bytes: Uint8Array): ImageSizeProbe | null;
+/** The admission limits that matter for resampling decisions. */
+export interface ResizeLimits {
+    /** Maximum intrinsic width AND height, per side, in pixels. */
+    readonly maxImageDimension: number;
+    /** Maximum width × height in pixels. */
+    readonly maxImagePixels: number;
+}
+/** Whether a measured image already satisfies the dimension/pixel caps. */
+export declare function withinDimensionLimits(size: ImageSizeProbe, limits: ResizeLimits): boolean;
+/**
+ * Target dimensions that bring an oversized image inside `limits` while
+ * preserving the aspect ratio: scale down by the largest of the three
+ * required factors (per-side, per-side, total-pixels).
+ */
+export declare function downscaleTarget(size: ImageSizeProbe, limits: ResizeLimits): ImageSizeProbe;
+export type AdaptOutcome = {
+    readonly kind: 'unchanged';
+} | {
+    readonly kind: 'adapted';
+    readonly data: Uint8Array;
+    /** Media type of the produced bytes (equals the source's when accepted). */
+    readonly mediaType: string;
+    readonly width: number;
+    readonly height: number;
+    /** The source exceeded the caps and was resampled. */
+    readonly resized: boolean;
+    /** An alpha channel was composited onto {@link OPAQUE_BACKGROUND}. */
+    readonly flattened: boolean;
+} | {
+    /** Nothing could be produced. Only `sharp-missing` is a degradation a
+     * caller may tolerate (the optional dependency is absent, so nothing could
+     * be measured at all); every other reason is a definite refusal that must
+     * be reported instead of handed to the store. */
+    readonly kind: 'unavailable';
+    readonly reason: 'sharp-missing' | 'decode-failed' | 'animated-unsupported';
+    readonly detail: string;
+};
+/**
+ * Produce bytes the profile can admit, and report what had to change.
+ *
+ * Both triggers are size-independent by design: a media type the profile does
+ * not accept is converted even when it fits the pixel caps (a small PNG must
+ * not be refused while a large one succeeds), and an image the byte probe
+ * cannot measure is decoded so its real dimensions decide. The probe still
+ * short-circuits the common case — bytes it proves to be inside the caps in an
+ * accepted format are returned untouched, with no encoder loaded.
+ *
+ * Aspect ratio is preserved by {@link downscaleTarget}. An animated source is
+ * REFUSED whenever this gate would have to touch its bytes: re-encoding a
+ * multi-page image here cannot promise frames, delays and loop survive, and
+ * silently returning a still is a data loss the store's own refusal (the
+ * behaviour without this gate) never inflicted. Animated images that need no
+ * change pass through untouched.
+ */
+export declare function adaptImageForAdmission(bytes: Uint8Array, sourceMediaType: string, limits: ResizeLimits, acceptedMediaTypes: readonly string[]): Promise<AdaptOutcome>;
+//# sourceMappingURL=imageResize.d.ts.map

package/lib/types/utils/imageResize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imageResize.d.ts","sourceRoot":"","sources":["../../../src/utils/imageResize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAiFD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,cAAc,GAAG,IAAI,CAevE;AAED,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC3B,+DAA+D;IAC/D,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAA;IAClC,wCAAwC;IACxC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;CAChC;AAED,2EAA2E;AAC3E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAIzF;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,YAAY,GAAG,cAAc,CAW1F;AAqCD,MAAM,MAAM,YAAY,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAE,GAC9B;IACA,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,sEAAsE;IACtE,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;CAC5B,GACC;IACA;;;qDAGiD;IACjD,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe,GAAG,sBAAsB,CAAA;IAC3E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAA;AAgCH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,UAAU,EACjB,eAAe,EAAE,MAAM,EACvB,MAAM,EAAE,YAAY,EACpB,kBAAkB,EAAE,SAAS,MAAM,EAAE,GACpC,OAAO,CAAC,YAAY,CAAC,CAqDvB"}