@tldraw/utils 5.1.0 → 5.2.0-next.b91d4a4551c9

package/dist-cjs/index.d.ts

@@ -88,6 +88,12 @@ export declare function bind<This extends object, T extends (...args: any[]) =>
  * function returns a Promise that resolves with the result of the original function. Includes a
  * cancel method to prevent execution if needed.
  *
+ * Calling `cancel()` while a call is pending rejects the returned promise with an `Error`
+ * whose message is `'Debounced function was cancelled'`. Callers that discard the promise
+ * are not affected — internal handling suppresses the unhandled-rejection warning — but
+ * any code that `await`s or chains `.then()` on the promise must be prepared to handle the
+ * rejection.
+ *
  * @param callback - The function to debounce (can be sync or async)
  * @param wait - The delay in milliseconds before executing the function
  * @returns A debounced function that returns a Promise and includes a cancel method
@@ -103,15 +109,19 @@ export declare function bind<This extends object, T extends (...args: any[]) =>
  * debouncedSearch('react hooks') // This cancels the previous call
  * debouncedSearch('react typescript') // Only this will execute
  *
- * // Cancel pending execution
+ * // Cancel pending execution — any in-flight promise rejects
  * debouncedSearch.cancel()
  *
- * // With async/await
+ * // With async/await — wrap in try/catch if you might cancel
  * const saveData = debounce(async (data: any) => {
  *   return await api.save(data)
  * }, 1000)
  *
- * const result = await saveData({name: 'John'})
+ * try {
+ *   const result = await saveData({name: 'John'})
+ * } catch (err) {
+ *   // handle cancellation or callback error
+ * }
  * ```
  *
  * @public
@@ -1658,7 +1668,7 @@ export declare function rotateArray<T>(arr: T[], offset: number): T[];
  *
  * @public
  */
-export declare const safeParseUrl: (url: string, baseUrl?: string | undefined | URL) => undefined | URL;
+export declare function safeParseUrl(url: string, baseUrl?: string | URL): undefined | URL;
 
 /* Excluded from this release type: setInLocalStorage */
 

package/dist-cjs/index.js

@@ -171,7 +171,7 @@ var import_version2 = require("./lib/version");
 var import_warn = require("./lib/warn");
 (0, import_version.registerTldrawLibraryVersion)(
   "@tldraw/utils",
-  "5.1.0",
+  "5.2.0-next.b91d4a4551c9",
   "cjs"
 );
 //# sourceMappingURL=index.js.map

package/dist-cjs/lib/debounce.js

@@ -21,6 +21,7 @@ __export(debounce_exports, {
   debounce: () => debounce
 });
 module.exports = __toCommonJS(debounce_exports);
+var import_function = require("./function");
 function debounce(callback, wait) {
   let state = void 0;
   const fn = (...args) => {
@@ -47,7 +48,10 @@ function debounce(callback, wait) {
   fn.cancel = () => {
     if (!state) return;
     clearTimeout(state.timeout);
+    const s = state;
     state = void 0;
+    s.promise.catch(import_function.noop);
+    s.reject(new Error("Debounced function was cancelled"));
   };
   return fn;
 }

package/dist-cjs/lib/debounce.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/debounce.ts"],
-  "sourcesContent": ["import type { Awaitable } from './types'\n\n/**\n * Create a debounced version of a function that delays execution until after a specified wait time.\n *\n * Debouncing ensures that a function is only executed once after a specified delay,\n * even if called multiple times in rapid succession. Each new call resets the timer. The debounced\n * function returns a Promise that resolves with the result of the original function. Includes a\n * cancel method to prevent execution if needed.\n *\n * @param callback - The function to debounce (can be sync or async)\n * @param wait - The delay in milliseconds before executing the function\n * @returns A debounced function that returns a Promise and includes a cancel method\n *\n * @example\n * ```ts\n * // Debounce a search function\n * const searchAPI = (query: string) => fetch(`/search?q=${query}`)\n * const debouncedSearch = debounce(searchAPI, 300)\n *\n * // Multiple rapid calls will only execute the last one after 300ms\n * debouncedSearch('react').then(result => console.log(result))\n * debouncedSearch('react hooks') // This cancels the previous call\n * debouncedSearch('react typescript') // Only this will execute\n *\n * // Cancel pending execution\n * debouncedSearch.cancel()\n *\n * // With async/await\n * const saveData = debounce(async (data: any) => {\n *   return await api.save(data)\n * }, 1000)\n *\n * const result = await saveData({name: 'John'})\n * ```\n *\n * @public\n * @see source - https://gist.github.com/ca0v/73a31f57b397606c9813472f7493a940\n */\nexport function debounce<T extends unknown[], U>(\n\tcallback: (...args: T) => Awaitable<U>,\n\twait: number\n) {\n\tlet state:\n\t\t| undefined\n\t\t| {\n\t\t\t\t// eslint-disable-next-line no-restricted-globals\n\t\t\t\ttimeout: ReturnType<typeof setTimeout>\n\t\t\t\tpromise: Promise<U>\n\t\t\t\tresolve(value: U | PromiseLike<U>): void\n\t\t\t\treject(value: any): void\n\t\t\t\tlatestArgs: T\n\t\t  } = undefined\n\n\tconst fn = (...args: T): Promise<U> => {\n\t\tif (!state) {\n\t\t\tstate = {} as any\n\t\t\tstate!.promise = new Promise((resolve, reject) => {\n\t\t\t\tstate!.resolve = resolve\n\t\t\t\tstate!.reject = reject\n\t\t\t})\n\t\t}\n\t\tclearTimeout(state!.timeout)\n\t\tstate!.latestArgs = args\n\t\t// It's up to the consumer of debounce to call `cancel`\n\t\t// eslint-disable-next-line no-restricted-globals\n\t\tstate!.timeout = setTimeout(() => {\n\t\t\tconst s = state!\n\t\t\tstate = undefined\n\t\t\ttry {\n\t\t\t\ts.resolve(callback(...s.latestArgs))\n\t\t\t} catch (e) {\n\t\t\t\ts.reject(e)\n\t\t\t}\n\t\t}, wait)\n\n\t\treturn state!.promise\n\t}\n\tfn.cancel = () => {\n\t\tif (!state) return\n\t\tclearTimeout(state.timeout)\n\t\tstate = undefined\n\t}\n\treturn fn\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAuCO,SAAS,SACf,UACA,MACC;AACD,MAAI,QASG;AAEP,QAAM,KAAK,IAAI,SAAwB;AACtC,QAAI,CAAC,OAAO;AACX,cAAQ,CAAC;AACT,YAAO,UAAU,IAAI,QAAQ,CAAC,SAAS,WAAW;AACjD,cAAO,UAAU;AACjB,cAAO,SAAS;AAAA,MACjB,CAAC;AAAA,IACF;AACA,iBAAa,MAAO,OAAO;AAC3B,UAAO,aAAa;AAGpB,UAAO,UAAU,WAAW,MAAM;AACjC,YAAM,IAAI;AACV,cAAQ;AACR,UAAI;AACH,UAAE,QAAQ,SAAS,GAAG,EAAE,UAAU,CAAC;AAAA,MACpC,SAAS,GAAG;AACX,UAAE,OAAO,CAAC;AAAA,MACX;AAAA,IACD,GAAG,IAAI;AAEP,WAAO,MAAO;AAAA,EACf;AACA,KAAG,SAAS,MAAM;AACjB,QAAI,CAAC,MAAO;AACZ,iBAAa,MAAM,OAAO;AAC1B,YAAQ;AAAA,EACT;AACA,SAAO;AACR;",
+  "sourcesContent": ["import { noop } from './function'\nimport type { Awaitable } from './types'\n\n/**\n * Create a debounced version of a function that delays execution until after a specified wait time.\n *\n * Debouncing ensures that a function is only executed once after a specified delay,\n * even if called multiple times in rapid succession. Each new call resets the timer. The debounced\n * function returns a Promise that resolves with the result of the original function. Includes a\n * cancel method to prevent execution if needed.\n *\n * Calling `cancel()` while a call is pending rejects the returned promise with an `Error`\n * whose message is `'Debounced function was cancelled'`. Callers that discard the promise\n * are not affected \u2014 internal handling suppresses the unhandled-rejection warning \u2014 but\n * any code that `await`s or chains `.then()` on the promise must be prepared to handle the\n * rejection.\n *\n * @param callback - The function to debounce (can be sync or async)\n * @param wait - The delay in milliseconds before executing the function\n * @returns A debounced function that returns a Promise and includes a cancel method\n *\n * @example\n * ```ts\n * // Debounce a search function\n * const searchAPI = (query: string) => fetch(`/search?q=${query}`)\n * const debouncedSearch = debounce(searchAPI, 300)\n *\n * // Multiple rapid calls will only execute the last one after 300ms\n * debouncedSearch('react').then(result => console.log(result))\n * debouncedSearch('react hooks') // This cancels the previous call\n * debouncedSearch('react typescript') // Only this will execute\n *\n * // Cancel pending execution \u2014 any in-flight promise rejects\n * debouncedSearch.cancel()\n *\n * // With async/await \u2014 wrap in try/catch if you might cancel\n * const saveData = debounce(async (data: any) => {\n *   return await api.save(data)\n * }, 1000)\n *\n * try {\n *   const result = await saveData({name: 'John'})\n * } catch (err) {\n *   // handle cancellation or callback error\n * }\n * ```\n *\n * @public\n * @see source - https://gist.github.com/ca0v/73a31f57b397606c9813472f7493a940\n */\nexport function debounce<T extends unknown[], U>(\n\tcallback: (...args: T) => Awaitable<U>,\n\twait: number\n) {\n\tlet state:\n\t\t| undefined\n\t\t| {\n\t\t\t\t// eslint-disable-next-line no-restricted-globals\n\t\t\t\ttimeout: ReturnType<typeof setTimeout>\n\t\t\t\tpromise: Promise<U>\n\t\t\t\tresolve(value: U | PromiseLike<U>): void\n\t\t\t\treject(value: any): void\n\t\t\t\tlatestArgs: T\n\t\t  } = undefined\n\n\tconst fn = (...args: T): Promise<U> => {\n\t\tif (!state) {\n\t\t\tstate = {} as any\n\t\t\tstate!.promise = new Promise((resolve, reject) => {\n\t\t\t\tstate!.resolve = resolve\n\t\t\t\tstate!.reject = reject\n\t\t\t})\n\t\t}\n\t\tclearTimeout(state!.timeout)\n\t\tstate!.latestArgs = args\n\t\t// It's up to the consumer of debounce to call `cancel`\n\t\t// eslint-disable-next-line no-restricted-globals\n\t\tstate!.timeout = setTimeout(() => {\n\t\t\tconst s = state!\n\t\t\tstate = undefined\n\t\t\ttry {\n\t\t\t\ts.resolve(callback(...s.latestArgs))\n\t\t\t} catch (e) {\n\t\t\t\ts.reject(e)\n\t\t\t}\n\t\t}, wait)\n\n\t\treturn state!.promise\n\t}\n\tfn.cancel = () => {\n\t\tif (!state) return\n\t\tclearTimeout(state.timeout)\n\t\tconst s = state\n\t\tstate = undefined\n\t\t// Attach a no-op handler so callers that discard the promise don't\n\t\t// trigger an unhandled-rejection warning. Consumers that did `.then`,\n\t\t// `.catch`, or `await` on the returned promise still observe the\n\t\t// rejection through their own chain.\n\t\ts.promise.catch(noop)\n\t\ts.reject(new Error('Debounced function was cancelled'))\n\t}\n\treturn fn\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,sBAAqB;AAkDd,SAAS,SACf,UACA,MACC;AACD,MAAI,QASG;AAEP,QAAM,KAAK,IAAI,SAAwB;AACtC,QAAI,CAAC,OAAO;AACX,cAAQ,CAAC;AACT,YAAO,UAAU,IAAI,QAAQ,CAAC,SAAS,WAAW;AACjD,cAAO,UAAU;AACjB,cAAO,SAAS;AAAA,MACjB,CAAC;AAAA,IACF;AACA,iBAAa,MAAO,OAAO;AAC3B,UAAO,aAAa;AAGpB,UAAO,UAAU,WAAW,MAAM;AACjC,YAAM,IAAI;AACV,cAAQ;AACR,UAAI;AACH,UAAE,QAAQ,SAAS,GAAG,EAAE,UAAU,CAAC;AAAA,MACpC,SAAS,GAAG;AACX,UAAE,OAAO,CAAC;AAAA,MACX;AAAA,IACD,GAAG,IAAI;AAEP,WAAO,MAAO;AAAA,EACf;AACA,KAAG,SAAS,MAAM;AACjB,QAAI,CAAC,MAAO;AACZ,iBAAa,MAAM,OAAO;AAC1B,UAAM,IAAI;AACV,YAAQ;AAKR,MAAE,QAAQ,MAAM,oBAAI;AACpB,MAAE,OAAO,IAAI,MAAM,kCAAkC,CAAC;AAAA,EACvD;AACA,SAAO;AACR;",
   "names": []
 }

package/dist-cjs/lib/function.js

@@ -35,6 +35,6 @@ function omitFromStackTrace(fn) {
   };
   return wrappedFn;
 }
-const noop = () => {
-};
+function noop() {
+}
 //# sourceMappingURL=function.js.map

package/dist-cjs/lib/function.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/function.ts"],
-  "sourcesContent": ["/**\n * When a function is wrapped in `omitFromStackTrace`, if it throws an error the stack trace won't\n * include the function itself or any stack frames above it. Useful for assertion-style function\n * where the error will ideally originate from the call-site rather than within the implementation\n * of the assert fn.\n *\n * Only works in platforms that support `Error.captureStackTrace` (ie v8).\n *\n * @param fn - The function to wrap and exclude from stack traces\n * @returns A wrapped version of the function that omits itself from error stack traces\n * @example\n * ```ts\n * const assertPositive = omitFromStackTrace((value: number) => {\n *   if (value <= 0) throw new Error('Value must be positive')\n *   return value\n * })\n *\n * assertPositive(-1) // Error stack trace will point to this line, not inside assertPositive\n * ```\n * @internal\n */\nexport function omitFromStackTrace<Args extends Array<unknown>, Return>(\n\tfn: (...args: Args) => Return\n): (...args: Args) => Return {\n\tconst wrappedFn = (...args: Args) => {\n\t\ttry {\n\t\t\treturn fn(...args)\n\t\t} catch (error) {\n\t\t\tif (error instanceof Error && Error.captureStackTrace) {\n\t\t\t\tError.captureStackTrace(error, wrappedFn)\n\t\t\t}\n\t\t\tthrow error\n\t\t}\n\t}\n\n\treturn wrappedFn\n}\n\n/**\n * Does nothing, but it's really really good at it.\n * @internal\n */\nexport const noop: () => void = () => {}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,SAAS,mBACf,IAC4B;AAC5B,QAAM,YAAY,IAAI,SAAe;AACpC,QAAI;AACH,aAAO,GAAG,GAAG,IAAI;AAAA,IAClB,SAAS,OAAO;AACf,UAAI,iBAAiB,SAAS,MAAM,mBAAmB;AACtD,cAAM,kBAAkB,OAAO,SAAS;AAAA,MACzC;AACA,YAAM;AAAA,IACP;AAAA,EACD;AAEA,SAAO;AACR;AAMO,MAAM,OAAmB,MAAM;AAAC;",
+  "sourcesContent": ["/**\n * When a function is wrapped in `omitFromStackTrace`, if it throws an error the stack trace won't\n * include the function itself or any stack frames above it. Useful for assertion-style function\n * where the error will ideally originate from the call-site rather than within the implementation\n * of the assert fn.\n *\n * Only works in platforms that support `Error.captureStackTrace` (ie v8).\n *\n * @param fn - The function to wrap and exclude from stack traces\n * @returns A wrapped version of the function that omits itself from error stack traces\n * @example\n * ```ts\n * const assertPositive = omitFromStackTrace((value: number) => {\n *   if (value <= 0) throw new Error('Value must be positive')\n *   return value\n * })\n *\n * assertPositive(-1) // Error stack trace will point to this line, not inside assertPositive\n * ```\n * @internal\n */\nexport function omitFromStackTrace<Args extends Array<unknown>, Return>(\n\tfn: (...args: Args) => Return\n): (...args: Args) => Return {\n\tconst wrappedFn = (...args: Args) => {\n\t\ttry {\n\t\t\treturn fn(...args)\n\t\t} catch (error) {\n\t\t\tif (error instanceof Error && Error.captureStackTrace) {\n\t\t\t\tError.captureStackTrace(error, wrappedFn)\n\t\t\t}\n\t\t\tthrow error\n\t\t}\n\t}\n\n\treturn wrappedFn\n}\n\n/**\n * Does nothing, but it's really really good at it.\n * @internal\n */\nexport function noop(): void {}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,SAAS,mBACf,IAC4B;AAC5B,QAAM,YAAY,IAAI,SAAe;AACpC,QAAI;AACH,aAAO,GAAG,GAAG,IAAI;AAAA,IAClB,SAAS,OAAO;AACf,UAAI,iBAAiB,SAAS,MAAM,mBAAmB;AACtD,cAAM,kBAAkB,OAAO,SAAS;AAAA,MACzC;AACA,YAAM;AAAA,IACP;AAAA,EACD;AAEA,SAAO;AACR;AAMO,SAAS,OAAa;AAAC;",
   "names": []
 }

package/dist-cjs/lib/media/avif.js

@@ -21,8 +21,8 @@ __export(avif_exports, {
   isAvifAnimated: () => isAvifAnimated
 });
 module.exports = __toCommonJS(avif_exports);
-const isAvifAnimated = (buffer) => {
+function isAvifAnimated(buffer) {
   const view = new Uint8Array(buffer);
   return view[3] === 44;
-};
+}
 //# sourceMappingURL=avif.js.map

package/dist-cjs/lib/media/avif.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/media/avif.ts"],
-  "sourcesContent": ["/**\n * Determines whether an ArrayBuffer contains an animated AVIF image.\n *\n * This function performs a simple check by examining the 4th byte of the buffer.\n * AVIF animation is indicated when the byte at index 3 equals 44.\n *\n * @param buffer - The ArrayBuffer containing the AVIF image data to analyze\n * @returns True if the buffer contains an animated AVIF, false otherwise\n *\n * @example\n * ```typescript\n * // Check if an AVIF file is animated\n * const response = await fetch('image.avif')\n * const buffer = await response.arrayBuffer()\n * const isAnimated = isAvifAnimated(buffer)\n * if (isAnimated) {\n *   console.log('This AVIF contains animation!')\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Use with file input\n * const fileInput = document.querySelector('input[type=\"file\"]')\n * fileInput.addEventListener('change', async (event) => {\n *   const file = event.target.files[0]\n *   const buffer = await file.arrayBuffer()\n *   const hasAnimation = isAvifAnimated(buffer)\n *   console.log(hasAnimation ? 'Animated AVIF' : 'Static AVIF')\n * })\n * ```\n *\n * @public\n */\nexport const isAvifAnimated = (buffer: ArrayBuffer) => {\n\tconst view = new Uint8Array(buffer)\n\treturn view[3] === 44\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkCO,MAAM,iBAAiB,CAAC,WAAwB;AACtD,QAAM,OAAO,IAAI,WAAW,MAAM;AAClC,SAAO,KAAK,CAAC,MAAM;AACpB;",
+  "sourcesContent": ["/**\n * Determines whether an ArrayBuffer contains an animated AVIF image.\n *\n * This function performs a simple check by examining the 4th byte of the buffer.\n * AVIF animation is indicated when the byte at index 3 equals 44.\n *\n * @param buffer - The ArrayBuffer containing the AVIF image data to analyze\n * @returns True if the buffer contains an animated AVIF, false otherwise\n *\n * @example\n * ```typescript\n * // Check if an AVIF file is animated\n * const response = await fetch('image.avif')\n * const buffer = await response.arrayBuffer()\n * const isAnimated = isAvifAnimated(buffer)\n * if (isAnimated) {\n *   console.log('This AVIF contains animation!')\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Use with file input\n * const fileInput = document.querySelector('input[type=\"file\"]')\n * fileInput.addEventListener('change', async (event) => {\n *   const file = event.target.files[0]\n *   const buffer = await file.arrayBuffer()\n *   const hasAnimation = isAvifAnimated(buffer)\n *   console.log(hasAnimation ? 'Animated AVIF' : 'Static AVIF')\n * })\n * ```\n *\n * @public\n */\nexport function isAvifAnimated(buffer: ArrayBuffer) {\n\tconst view = new Uint8Array(buffer)\n\treturn view[3] === 44\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkCO,SAAS,eAAe,QAAqB;AACnD,QAAM,OAAO,IAAI,WAAW,MAAM;AAClC,SAAO,KAAK,CAAC,MAAM;AACpB;",
   "names": []
 }

package/dist-cjs/lib/network.js

@@ -29,9 +29,9 @@ async function fetch(input, init) {
     ...init
   });
 }
-const Image = (width, height) => {
+function Image(width, height) {
   const img = new window.Image(width, height);
   img.referrerPolicy = "strict-origin-when-cross-origin";
   return img;
-};
+}
 //# sourceMappingURL=network.js.map

package/dist-cjs/lib/network.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/network.ts"],
-  "sourcesContent": ["/**\n * Just a wrapper around `window.fetch` that sets the `referrerPolicy` to `strict-origin-when-cross-origin`.\n *\n * @param input - A Request object or string containing the URL to fetch\n * @param init - Optional request initialization options\n * @returns Promise that resolves to the Response object\n * @internal\n */\nexport async function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {\n\t// eslint-disable-next-line tldraw/no-restricted-properties\n\treturn window.fetch(input, {\n\t\t// We want to make sure that the referrer is not sent to other domains.\n\t\treferrerPolicy: 'strict-origin-when-cross-origin',\n\t\t...init,\n\t})\n}\n\n/**\n * Just a wrapper around `new Image`, and yeah, it's a bit strange that it's in the network.ts file\n * but the main concern here is the referrerPolicy and setting it correctly.\n *\n * @param width - Optional width for the image element\n * @param height - Optional height for the image element\n * @returns HTMLImageElement with referrerPolicy set to 'strict-origin-when-cross-origin'\n * @internal\n */\nexport const Image = (width?: number, height?: number) => {\n\t// eslint-disable-next-line tldraw/no-restricted-properties\n\tconst img = new window.Image(width, height)\n\timg.referrerPolicy = 'strict-origin-when-cross-origin'\n\treturn img\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,eAAsB,MAAM,OAA0B,MAAuC;AAE5F,SAAO,OAAO,MAAM,OAAO;AAAA;AAAA,IAE1B,gBAAgB;AAAA,IAChB,GAAG;AAAA,EACJ,CAAC;AACF;AAWO,MAAM,QAAQ,CAAC,OAAgB,WAAoB;AAEzD,QAAM,MAAM,IAAI,OAAO,MAAM,OAAO,MAAM;AAC1C,MAAI,iBAAiB;AACrB,SAAO;AACR;",
+  "sourcesContent": ["/**\n * Just a wrapper around `window.fetch` that sets the `referrerPolicy` to `strict-origin-when-cross-origin`.\n *\n * @param input - A Request object or string containing the URL to fetch\n * @param init - Optional request initialization options\n * @returns Promise that resolves to the Response object\n * @internal\n */\nexport async function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {\n\t// eslint-disable-next-line tldraw/no-restricted-properties\n\treturn window.fetch(input, {\n\t\t// We want to make sure that the referrer is not sent to other domains.\n\t\treferrerPolicy: 'strict-origin-when-cross-origin',\n\t\t...init,\n\t})\n}\n\n/**\n * Just a wrapper around `new Image`, and yeah, it's a bit strange that it's in the network.ts file\n * but the main concern here is the referrerPolicy and setting it correctly.\n *\n * @param width - Optional width for the image element\n * @param height - Optional height for the image element\n * @returns HTMLImageElement with referrerPolicy set to 'strict-origin-when-cross-origin'\n * @internal\n */\nexport function Image(width?: number, height?: number) {\n\t// eslint-disable-next-line tldraw/no-restricted-properties\n\tconst img = new window.Image(width, height)\n\timg.referrerPolicy = 'strict-origin-when-cross-origin'\n\treturn img\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAQA,eAAsB,MAAM,OAA0B,MAAuC;AAE5F,SAAO,OAAO,MAAM,OAAO;AAAA;AAAA,IAE1B,gBAAgB;AAAA,IAChB,GAAG;AAAA,EACJ,CAAC;AACF;AAWO,SAAS,MAAM,OAAgB,QAAiB;AAEtD,QAAM,MAAM,IAAI,OAAO,MAAM,OAAO,MAAM;AAC1C,MAAI,iBAAiB;AACrB,SAAO;AACR;",
   "names": []
 }

package/dist-cjs/lib/url.js

@@ -21,11 +21,11 @@ __export(url_exports, {
   safeParseUrl: () => safeParseUrl
 });
 module.exports = __toCommonJS(url_exports);
-const safeParseUrl = (url, baseUrl) => {
+function safeParseUrl(url, baseUrl) {
   try {
     return new URL(url, baseUrl);
   } catch {
     return;
   }
-};
+}
 //# sourceMappingURL=url.js.map

package/dist-cjs/lib/url.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/url.ts"],
-  "sourcesContent": ["/**\n * Safely parses a URL string without throwing exceptions on invalid input.\n * Returns a URL object for valid URLs or undefined for invalid ones.\n *\n * @param url - The URL string to parse\n * @param baseUrl - Optional base URL to resolve relative URLs against\n * @returns A URL object if parsing succeeds, undefined if it fails\n *\n * @example\n * ```ts\n * // Valid absolute URL\n * const url1 = safeParseUrl('https://example.com')\n * if (url1) {\n *   console.log(`Valid URL: ${url1.href}`) // \"Valid URL: https://example.com/\"\n * }\n *\n * // Invalid URL\n * const url2 = safeParseUrl('not-a-url')\n * console.log(url2) // undefined\n *\n * // Relative URL with base\n * const url3 = safeParseUrl('/path', 'https://example.com')\n * if (url3) {\n *   console.log(url3.href) // \"https://example.com/path\"\n * }\n *\n * // Error handling\n * function handleUserUrl(input: string) {\n *   const url = safeParseUrl(input)\n *   if (url) {\n *     return url\n *   } else {\n *     console.log('Invalid URL provided')\n *     return null\n *   }\n * }\n * ```\n *\n * @public\n */\nexport const safeParseUrl = (url: string, baseUrl?: string | URL) => {\n\ttry {\n\t\treturn new URL(url, baseUrl)\n\t} catch {\n\t\treturn\n\t}\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAwCO,MAAM,eAAe,CAAC,KAAa,YAA2B;AACpE,MAAI;AACH,WAAO,IAAI,IAAI,KAAK,OAAO;AAAA,EAC5B,QAAQ;AACP;AAAA,EACD;AACD;",
+  "sourcesContent": ["/**\n * Safely parses a URL string without throwing exceptions on invalid input.\n * Returns a URL object for valid URLs or undefined for invalid ones.\n *\n * @param url - The URL string to parse\n * @param baseUrl - Optional base URL to resolve relative URLs against\n * @returns A URL object if parsing succeeds, undefined if it fails\n *\n * @example\n * ```ts\n * // Valid absolute URL\n * const url1 = safeParseUrl('https://example.com')\n * if (url1) {\n *   console.log(`Valid URL: ${url1.href}`) // \"Valid URL: https://example.com/\"\n * }\n *\n * // Invalid URL\n * const url2 = safeParseUrl('not-a-url')\n * console.log(url2) // undefined\n *\n * // Relative URL with base\n * const url3 = safeParseUrl('/path', 'https://example.com')\n * if (url3) {\n *   console.log(url3.href) // \"https://example.com/path\"\n * }\n *\n * // Error handling\n * function handleUserUrl(input: string) {\n *   const url = safeParseUrl(input)\n *   if (url) {\n *     return url\n *   } else {\n *     console.log('Invalid URL provided')\n *     return null\n *   }\n * }\n * ```\n *\n * @public\n */\nexport function safeParseUrl(url: string, baseUrl?: string | URL) {\n\ttry {\n\t\treturn new URL(url, baseUrl)\n\t} catch {\n\t\treturn\n\t}\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAwCO,SAAS,aAAa,KAAa,SAAwB;AACjE,MAAI;AACH,WAAO,IAAI,IAAI,KAAK,OAAO;AAAA,EAC5B,QAAQ;AACP;AAAA,EACD;AACD;",
   "names": []
 }

package/dist-esm/index.d.mts

@@ -88,6 +88,12 @@ export declare function bind<This extends object, T extends (...args: any[]) =>
  * function returns a Promise that resolves with the result of the original function. Includes a
  * cancel method to prevent execution if needed.
  *
+ * Calling `cancel()` while a call is pending rejects the returned promise with an `Error`
+ * whose message is `'Debounced function was cancelled'`. Callers that discard the promise
+ * are not affected — internal handling suppresses the unhandled-rejection warning — but
+ * any code that `await`s or chains `.then()` on the promise must be prepared to handle the
+ * rejection.
+ *
  * @param callback - The function to debounce (can be sync or async)
  * @param wait - The delay in milliseconds before executing the function
  * @returns A debounced function that returns a Promise and includes a cancel method
@@ -103,15 +109,19 @@ export declare function bind<This extends object, T extends (...args: any[]) =>
  * debouncedSearch('react hooks') // This cancels the previous call
  * debouncedSearch('react typescript') // Only this will execute
  *
- * // Cancel pending execution
+ * // Cancel pending execution — any in-flight promise rejects
  * debouncedSearch.cancel()
  *
- * // With async/await
+ * // With async/await — wrap in try/catch if you might cancel
  * const saveData = debounce(async (data: any) => {
  *   return await api.save(data)
  * }, 1000)
  *
- * const result = await saveData({name: 'John'})
+ * try {
+ *   const result = await saveData({name: 'John'})
+ * } catch (err) {
+ *   // handle cancellation or callback error
+ * }
  * ```
  *
  * @public
@@ -1658,7 +1668,7 @@ export declare function rotateArray<T>(arr: T[], offset: number): T[];
  *
  * @public
  */
-export declare const safeParseUrl: (url: string, baseUrl?: string | undefined | URL) => undefined | URL;
+export declare function safeParseUrl(url: string, baseUrl?: string | URL): undefined | URL;
 
 /* Excluded from this release type: setInLocalStorage */
 

package/dist-esm/index.mjs

@@ -102,7 +102,7 @@ import { registerTldrawLibraryVersion as registerTldrawLibraryVersion2 } from ".
 import { warnDeprecatedGetter, warnOnce } from "./lib/warn.mjs";
 registerTldrawLibraryVersion(
   "@tldraw/utils",
-  "5.1.0",
+  "5.2.0-next.b91d4a4551c9",
   "esm"
 );
 export {

package/dist-esm/lib/debounce.mjs

@@ -1,3 +1,4 @@
+import { noop } from "./function.mjs";
 function debounce(callback, wait) {
   let state = void 0;
   const fn = (...args) => {
@@ -24,7 +25,10 @@ function debounce(callback, wait) {
   fn.cancel = () => {
     if (!state) return;
     clearTimeout(state.timeout);
+    const s = state;
     state = void 0;
+    s.promise.catch(noop);
+    s.reject(new Error("Debounced function was cancelled"));
   };
   return fn;
 }

package/dist-esm/lib/debounce.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/debounce.ts"],
-  "sourcesContent": ["import type { Awaitable } from './types'\n\n/**\n * Create a debounced version of a function that delays execution until after a specified wait time.\n *\n * Debouncing ensures that a function is only executed once after a specified delay,\n * even if called multiple times in rapid succession. Each new call resets the timer. The debounced\n * function returns a Promise that resolves with the result of the original function. Includes a\n * cancel method to prevent execution if needed.\n *\n * @param callback - The function to debounce (can be sync or async)\n * @param wait - The delay in milliseconds before executing the function\n * @returns A debounced function that returns a Promise and includes a cancel method\n *\n * @example\n * ```ts\n * // Debounce a search function\n * const searchAPI = (query: string) => fetch(`/search?q=${query}`)\n * const debouncedSearch = debounce(searchAPI, 300)\n *\n * // Multiple rapid calls will only execute the last one after 300ms\n * debouncedSearch('react').then(result => console.log(result))\n * debouncedSearch('react hooks') // This cancels the previous call\n * debouncedSearch('react typescript') // Only this will execute\n *\n * // Cancel pending execution\n * debouncedSearch.cancel()\n *\n * // With async/await\n * const saveData = debounce(async (data: any) => {\n *   return await api.save(data)\n * }, 1000)\n *\n * const result = await saveData({name: 'John'})\n * ```\n *\n * @public\n * @see source - https://gist.github.com/ca0v/73a31f57b397606c9813472f7493a940\n */\nexport function debounce<T extends unknown[], U>(\n\tcallback: (...args: T) => Awaitable<U>,\n\twait: number\n) {\n\tlet state:\n\t\t| undefined\n\t\t| {\n\t\t\t\t// eslint-disable-next-line no-restricted-globals\n\t\t\t\ttimeout: ReturnType<typeof setTimeout>\n\t\t\t\tpromise: Promise<U>\n\t\t\t\tresolve(value: U | PromiseLike<U>): void\n\t\t\t\treject(value: any): void\n\t\t\t\tlatestArgs: T\n\t\t  } = undefined\n\n\tconst fn = (...args: T): Promise<U> => {\n\t\tif (!state) {\n\t\t\tstate = {} as any\n\t\t\tstate!.promise = new Promise((resolve, reject) => {\n\t\t\t\tstate!.resolve = resolve\n\t\t\t\tstate!.reject = reject\n\t\t\t})\n\t\t}\n\t\tclearTimeout(state!.timeout)\n\t\tstate!.latestArgs = args\n\t\t// It's up to the consumer of debounce to call `cancel`\n\t\t// eslint-disable-next-line no-restricted-globals\n\t\tstate!.timeout = setTimeout(() => {\n\t\t\tconst s = state!\n\t\t\tstate = undefined\n\t\t\ttry {\n\t\t\t\ts.resolve(callback(...s.latestArgs))\n\t\t\t} catch (e) {\n\t\t\t\ts.reject(e)\n\t\t\t}\n\t\t}, wait)\n\n\t\treturn state!.promise\n\t}\n\tfn.cancel = () => {\n\t\tif (!state) return\n\t\tclearTimeout(state.timeout)\n\t\tstate = undefined\n\t}\n\treturn fn\n}\n"],
-  "mappings": "AAuCO,SAAS,SACf,UACA,MACC;AACD,MAAI,QASG;AAEP,QAAM,KAAK,IAAI,SAAwB;AACtC,QAAI,CAAC,OAAO;AACX,cAAQ,CAAC;AACT,YAAO,UAAU,IAAI,QAAQ,CAAC,SAAS,WAAW;AACjD,cAAO,UAAU;AACjB,cAAO,SAAS;AAAA,MACjB,CAAC;AAAA,IACF;AACA,iBAAa,MAAO,OAAO;AAC3B,UAAO,aAAa;AAGpB,UAAO,UAAU,WAAW,MAAM;AACjC,YAAM,IAAI;AACV,cAAQ;AACR,UAAI;AACH,UAAE,QAAQ,SAAS,GAAG,EAAE,UAAU,CAAC;AAAA,MACpC,SAAS,GAAG;AACX,UAAE,OAAO,CAAC;AAAA,MACX;AAAA,IACD,GAAG,IAAI;AAEP,WAAO,MAAO;AAAA,EACf;AACA,KAAG,SAAS,MAAM;AACjB,QAAI,CAAC,MAAO;AACZ,iBAAa,MAAM,OAAO;AAC1B,YAAQ;AAAA,EACT;AACA,SAAO;AACR;",
+  "sourcesContent": ["import { noop } from './function'\nimport type { Awaitable } from './types'\n\n/**\n * Create a debounced version of a function that delays execution until after a specified wait time.\n *\n * Debouncing ensures that a function is only executed once after a specified delay,\n * even if called multiple times in rapid succession. Each new call resets the timer. The debounced\n * function returns a Promise that resolves with the result of the original function. Includes a\n * cancel method to prevent execution if needed.\n *\n * Calling `cancel()` while a call is pending rejects the returned promise with an `Error`\n * whose message is `'Debounced function was cancelled'`. Callers that discard the promise\n * are not affected \u2014 internal handling suppresses the unhandled-rejection warning \u2014 but\n * any code that `await`s or chains `.then()` on the promise must be prepared to handle the\n * rejection.\n *\n * @param callback - The function to debounce (can be sync or async)\n * @param wait - The delay in milliseconds before executing the function\n * @returns A debounced function that returns a Promise and includes a cancel method\n *\n * @example\n * ```ts\n * // Debounce a search function\n * const searchAPI = (query: string) => fetch(`/search?q=${query}`)\n * const debouncedSearch = debounce(searchAPI, 300)\n *\n * // Multiple rapid calls will only execute the last one after 300ms\n * debouncedSearch('react').then(result => console.log(result))\n * debouncedSearch('react hooks') // This cancels the previous call\n * debouncedSearch('react typescript') // Only this will execute\n *\n * // Cancel pending execution \u2014 any in-flight promise rejects\n * debouncedSearch.cancel()\n *\n * // With async/await \u2014 wrap in try/catch if you might cancel\n * const saveData = debounce(async (data: any) => {\n *   return await api.save(data)\n * }, 1000)\n *\n * try {\n *   const result = await saveData({name: 'John'})\n * } catch (err) {\n *   // handle cancellation or callback error\n * }\n * ```\n *\n * @public\n * @see source - https://gist.github.com/ca0v/73a31f57b397606c9813472f7493a940\n */\nexport function debounce<T extends unknown[], U>(\n\tcallback: (...args: T) => Awaitable<U>,\n\twait: number\n) {\n\tlet state:\n\t\t| undefined\n\t\t| {\n\t\t\t\t// eslint-disable-next-line no-restricted-globals\n\t\t\t\ttimeout: ReturnType<typeof setTimeout>\n\t\t\t\tpromise: Promise<U>\n\t\t\t\tresolve(value: U | PromiseLike<U>): void\n\t\t\t\treject(value: any): void\n\t\t\t\tlatestArgs: T\n\t\t  } = undefined\n\n\tconst fn = (...args: T): Promise<U> => {\n\t\tif (!state) {\n\t\t\tstate = {} as any\n\t\t\tstate!.promise = new Promise((resolve, reject) => {\n\t\t\t\tstate!.resolve = resolve\n\t\t\t\tstate!.reject = reject\n\t\t\t})\n\t\t}\n\t\tclearTimeout(state!.timeout)\n\t\tstate!.latestArgs = args\n\t\t// It's up to the consumer of debounce to call `cancel`\n\t\t// eslint-disable-next-line no-restricted-globals\n\t\tstate!.timeout = setTimeout(() => {\n\t\t\tconst s = state!\n\t\t\tstate = undefined\n\t\t\ttry {\n\t\t\t\ts.resolve(callback(...s.latestArgs))\n\t\t\t} catch (e) {\n\t\t\t\ts.reject(e)\n\t\t\t}\n\t\t}, wait)\n\n\t\treturn state!.promise\n\t}\n\tfn.cancel = () => {\n\t\tif (!state) return\n\t\tclearTimeout(state.timeout)\n\t\tconst s = state\n\t\tstate = undefined\n\t\t// Attach a no-op handler so callers that discard the promise don't\n\t\t// trigger an unhandled-rejection warning. Consumers that did `.then`,\n\t\t// `.catch`, or `await` on the returned promise still observe the\n\t\t// rejection through their own chain.\n\t\ts.promise.catch(noop)\n\t\ts.reject(new Error('Debounced function was cancelled'))\n\t}\n\treturn fn\n}\n"],
+  "mappings": "AAAA,SAAS,YAAY;AAkDd,SAAS,SACf,UACA,MACC;AACD,MAAI,QASG;AAEP,QAAM,KAAK,IAAI,SAAwB;AACtC,QAAI,CAAC,OAAO;AACX,cAAQ,CAAC;AACT,YAAO,UAAU,IAAI,QAAQ,CAAC,SAAS,WAAW;AACjD,cAAO,UAAU;AACjB,cAAO,SAAS;AAAA,MACjB,CAAC;AAAA,IACF;AACA,iBAAa,MAAO,OAAO;AAC3B,UAAO,aAAa;AAGpB,UAAO,UAAU,WAAW,MAAM;AACjC,YAAM,IAAI;AACV,cAAQ;AACR,UAAI;AACH,UAAE,QAAQ,SAAS,GAAG,EAAE,UAAU,CAAC;AAAA,MACpC,SAAS,GAAG;AACX,UAAE,OAAO,CAAC;AAAA,MACX;AAAA,IACD,GAAG,IAAI;AAEP,WAAO,MAAO;AAAA,EACf;AACA,KAAG,SAAS,MAAM;AACjB,QAAI,CAAC,MAAO;AACZ,iBAAa,MAAM,OAAO;AAC1B,UAAM,IAAI;AACV,YAAQ;AAKR,MAAE,QAAQ,MAAM,IAAI;AACpB,MAAE,OAAO,IAAI,MAAM,kCAAkC,CAAC;AAAA,EACvD;AACA,SAAO;AACR;",
   "names": []
 }

package/dist-esm/lib/function.mjs

@@ -11,8 +11,8 @@ function omitFromStackTrace(fn) {
   };
   return wrappedFn;
 }
-const noop = () => {
-};
+function noop() {
+}
 export {
   noop,
   omitFromStackTrace

package/dist-esm/lib/function.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/function.ts"],
-  "sourcesContent": ["/**\n * When a function is wrapped in `omitFromStackTrace`, if it throws an error the stack trace won't\n * include the function itself or any stack frames above it. Useful for assertion-style function\n * where the error will ideally originate from the call-site rather than within the implementation\n * of the assert fn.\n *\n * Only works in platforms that support `Error.captureStackTrace` (ie v8).\n *\n * @param fn - The function to wrap and exclude from stack traces\n * @returns A wrapped version of the function that omits itself from error stack traces\n * @example\n * ```ts\n * const assertPositive = omitFromStackTrace((value: number) => {\n *   if (value <= 0) throw new Error('Value must be positive')\n *   return value\n * })\n *\n * assertPositive(-1) // Error stack trace will point to this line, not inside assertPositive\n * ```\n * @internal\n */\nexport function omitFromStackTrace<Args extends Array<unknown>, Return>(\n\tfn: (...args: Args) => Return\n): (...args: Args) => Return {\n\tconst wrappedFn = (...args: Args) => {\n\t\ttry {\n\t\t\treturn fn(...args)\n\t\t} catch (error) {\n\t\t\tif (error instanceof Error && Error.captureStackTrace) {\n\t\t\t\tError.captureStackTrace(error, wrappedFn)\n\t\t\t}\n\t\t\tthrow error\n\t\t}\n\t}\n\n\treturn wrappedFn\n}\n\n/**\n * Does nothing, but it's really really good at it.\n * @internal\n */\nexport const noop: () => void = () => {}\n"],
-  "mappings": "AAqBO,SAAS,mBACf,IAC4B;AAC5B,QAAM,YAAY,IAAI,SAAe;AACpC,QAAI;AACH,aAAO,GAAG,GAAG,IAAI;AAAA,IAClB,SAAS,OAAO;AACf,UAAI,iBAAiB,SAAS,MAAM,mBAAmB;AACtD,cAAM,kBAAkB,OAAO,SAAS;AAAA,MACzC;AACA,YAAM;AAAA,IACP;AAAA,EACD;AAEA,SAAO;AACR;AAMO,MAAM,OAAmB,MAAM;AAAC;",
+  "sourcesContent": ["/**\n * When a function is wrapped in `omitFromStackTrace`, if it throws an error the stack trace won't\n * include the function itself or any stack frames above it. Useful for assertion-style function\n * where the error will ideally originate from the call-site rather than within the implementation\n * of the assert fn.\n *\n * Only works in platforms that support `Error.captureStackTrace` (ie v8).\n *\n * @param fn - The function to wrap and exclude from stack traces\n * @returns A wrapped version of the function that omits itself from error stack traces\n * @example\n * ```ts\n * const assertPositive = omitFromStackTrace((value: number) => {\n *   if (value <= 0) throw new Error('Value must be positive')\n *   return value\n * })\n *\n * assertPositive(-1) // Error stack trace will point to this line, not inside assertPositive\n * ```\n * @internal\n */\nexport function omitFromStackTrace<Args extends Array<unknown>, Return>(\n\tfn: (...args: Args) => Return\n): (...args: Args) => Return {\n\tconst wrappedFn = (...args: Args) => {\n\t\ttry {\n\t\t\treturn fn(...args)\n\t\t} catch (error) {\n\t\t\tif (error instanceof Error && Error.captureStackTrace) {\n\t\t\t\tError.captureStackTrace(error, wrappedFn)\n\t\t\t}\n\t\t\tthrow error\n\t\t}\n\t}\n\n\treturn wrappedFn\n}\n\n/**\n * Does nothing, but it's really really good at it.\n * @internal\n */\nexport function noop(): void {}\n"],
+  "mappings": "AAqBO,SAAS,mBACf,IAC4B;AAC5B,QAAM,YAAY,IAAI,SAAe;AACpC,QAAI;AACH,aAAO,GAAG,GAAG,IAAI;AAAA,IAClB,SAAS,OAAO;AACf,UAAI,iBAAiB,SAAS,MAAM,mBAAmB;AACtD,cAAM,kBAAkB,OAAO,SAAS;AAAA,MACzC;AACA,YAAM;AAAA,IACP;AAAA,EACD;AAEA,SAAO;AACR;AAMO,SAAS,OAAa;AAAC;",
   "names": []
 }

package/dist-esm/lib/media/avif.mjs

@@ -1,7 +1,7 @@
-const isAvifAnimated = (buffer) => {
+function isAvifAnimated(buffer) {
   const view = new Uint8Array(buffer);
   return view[3] === 44;
-};
+}
 export {
   isAvifAnimated
 };

package/dist-esm/lib/media/avif.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/media/avif.ts"],
-  "sourcesContent": ["/**\n * Determines whether an ArrayBuffer contains an animated AVIF image.\n *\n * This function performs a simple check by examining the 4th byte of the buffer.\n * AVIF animation is indicated when the byte at index 3 equals 44.\n *\n * @param buffer - The ArrayBuffer containing the AVIF image data to analyze\n * @returns True if the buffer contains an animated AVIF, false otherwise\n *\n * @example\n * ```typescript\n * // Check if an AVIF file is animated\n * const response = await fetch('image.avif')\n * const buffer = await response.arrayBuffer()\n * const isAnimated = isAvifAnimated(buffer)\n * if (isAnimated) {\n *   console.log('This AVIF contains animation!')\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Use with file input\n * const fileInput = document.querySelector('input[type=\"file\"]')\n * fileInput.addEventListener('change', async (event) => {\n *   const file = event.target.files[0]\n *   const buffer = await file.arrayBuffer()\n *   const hasAnimation = isAvifAnimated(buffer)\n *   console.log(hasAnimation ? 'Animated AVIF' : 'Static AVIF')\n * })\n * ```\n *\n * @public\n */\nexport const isAvifAnimated = (buffer: ArrayBuffer) => {\n\tconst view = new Uint8Array(buffer)\n\treturn view[3] === 44\n}\n"],
-  "mappings": "AAkCO,MAAM,iBAAiB,CAAC,WAAwB;AACtD,QAAM,OAAO,IAAI,WAAW,MAAM;AAClC,SAAO,KAAK,CAAC,MAAM;AACpB;",
+  "sourcesContent": ["/**\n * Determines whether an ArrayBuffer contains an animated AVIF image.\n *\n * This function performs a simple check by examining the 4th byte of the buffer.\n * AVIF animation is indicated when the byte at index 3 equals 44.\n *\n * @param buffer - The ArrayBuffer containing the AVIF image data to analyze\n * @returns True if the buffer contains an animated AVIF, false otherwise\n *\n * @example\n * ```typescript\n * // Check if an AVIF file is animated\n * const response = await fetch('image.avif')\n * const buffer = await response.arrayBuffer()\n * const isAnimated = isAvifAnimated(buffer)\n * if (isAnimated) {\n *   console.log('This AVIF contains animation!')\n * }\n * ```\n *\n * @example\n * ```typescript\n * // Use with file input\n * const fileInput = document.querySelector('input[type=\"file\"]')\n * fileInput.addEventListener('change', async (event) => {\n *   const file = event.target.files[0]\n *   const buffer = await file.arrayBuffer()\n *   const hasAnimation = isAvifAnimated(buffer)\n *   console.log(hasAnimation ? 'Animated AVIF' : 'Static AVIF')\n * })\n * ```\n *\n * @public\n */\nexport function isAvifAnimated(buffer: ArrayBuffer) {\n\tconst view = new Uint8Array(buffer)\n\treturn view[3] === 44\n}\n"],
+  "mappings": "AAkCO,SAAS,eAAe,QAAqB;AACnD,QAAM,OAAO,IAAI,WAAW,MAAM;AAClC,SAAO,KAAK,CAAC,MAAM;AACpB;",
   "names": []
 }

package/dist-esm/lib/network.mjs

@@ -5,11 +5,11 @@ async function fetch(input, init) {
     ...init
   });
 }
-const Image = (width, height) => {
+function Image(width, height) {
   const img = new window.Image(width, height);
   img.referrerPolicy = "strict-origin-when-cross-origin";
   return img;
-};
+}
 export {
   Image,
   fetch

package/dist-esm/lib/network.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/network.ts"],
-  "sourcesContent": ["/**\n * Just a wrapper around `window.fetch` that sets the `referrerPolicy` to `strict-origin-when-cross-origin`.\n *\n * @param input - A Request object or string containing the URL to fetch\n * @param init - Optional request initialization options\n * @returns Promise that resolves to the Response object\n * @internal\n */\nexport async function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {\n\t// eslint-disable-next-line tldraw/no-restricted-properties\n\treturn window.fetch(input, {\n\t\t// We want to make sure that the referrer is not sent to other domains.\n\t\treferrerPolicy: 'strict-origin-when-cross-origin',\n\t\t...init,\n\t})\n}\n\n/**\n * Just a wrapper around `new Image`, and yeah, it's a bit strange that it's in the network.ts file\n * but the main concern here is the referrerPolicy and setting it correctly.\n *\n * @param width - Optional width for the image element\n * @param height - Optional height for the image element\n * @returns HTMLImageElement with referrerPolicy set to 'strict-origin-when-cross-origin'\n * @internal\n */\nexport const Image = (width?: number, height?: number) => {\n\t// eslint-disable-next-line tldraw/no-restricted-properties\n\tconst img = new window.Image(width, height)\n\timg.referrerPolicy = 'strict-origin-when-cross-origin'\n\treturn img\n}\n"],
-  "mappings": "AAQA,eAAsB,MAAM,OAA0B,MAAuC;AAE5F,SAAO,OAAO,MAAM,OAAO;AAAA;AAAA,IAE1B,gBAAgB;AAAA,IAChB,GAAG;AAAA,EACJ,CAAC;AACF;AAWO,MAAM,QAAQ,CAAC,OAAgB,WAAoB;AAEzD,QAAM,MAAM,IAAI,OAAO,MAAM,OAAO,MAAM;AAC1C,MAAI,iBAAiB;AACrB,SAAO;AACR;",
+  "sourcesContent": ["/**\n * Just a wrapper around `window.fetch` that sets the `referrerPolicy` to `strict-origin-when-cross-origin`.\n *\n * @param input - A Request object or string containing the URL to fetch\n * @param init - Optional request initialization options\n * @returns Promise that resolves to the Response object\n * @internal\n */\nexport async function fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {\n\t// eslint-disable-next-line tldraw/no-restricted-properties\n\treturn window.fetch(input, {\n\t\t// We want to make sure that the referrer is not sent to other domains.\n\t\treferrerPolicy: 'strict-origin-when-cross-origin',\n\t\t...init,\n\t})\n}\n\n/**\n * Just a wrapper around `new Image`, and yeah, it's a bit strange that it's in the network.ts file\n * but the main concern here is the referrerPolicy and setting it correctly.\n *\n * @param width - Optional width for the image element\n * @param height - Optional height for the image element\n * @returns HTMLImageElement with referrerPolicy set to 'strict-origin-when-cross-origin'\n * @internal\n */\nexport function Image(width?: number, height?: number) {\n\t// eslint-disable-next-line tldraw/no-restricted-properties\n\tconst img = new window.Image(width, height)\n\timg.referrerPolicy = 'strict-origin-when-cross-origin'\n\treturn img\n}\n"],
+  "mappings": "AAQA,eAAsB,MAAM,OAA0B,MAAuC;AAE5F,SAAO,OAAO,MAAM,OAAO;AAAA;AAAA,IAE1B,gBAAgB;AAAA,IAChB,GAAG;AAAA,EACJ,CAAC;AACF;AAWO,SAAS,MAAM,OAAgB,QAAiB;AAEtD,QAAM,MAAM,IAAI,OAAO,MAAM,OAAO,MAAM;AAC1C,MAAI,iBAAiB;AACrB,SAAO;AACR;",
   "names": []
 }

package/dist-esm/lib/url.mjs

@@ -1,10 +1,10 @@
-const safeParseUrl = (url, baseUrl) => {
+function safeParseUrl(url, baseUrl) {
   try {
     return new URL(url, baseUrl);
   } catch {
     return;
   }
-};
+}
 export {
   safeParseUrl
 };

package/dist-esm/lib/url.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/url.ts"],
-  "sourcesContent": ["/**\n * Safely parses a URL string without throwing exceptions on invalid input.\n * Returns a URL object for valid URLs or undefined for invalid ones.\n *\n * @param url - The URL string to parse\n * @param baseUrl - Optional base URL to resolve relative URLs against\n * @returns A URL object if parsing succeeds, undefined if it fails\n *\n * @example\n * ```ts\n * // Valid absolute URL\n * const url1 = safeParseUrl('https://example.com')\n * if (url1) {\n *   console.log(`Valid URL: ${url1.href}`) // \"Valid URL: https://example.com/\"\n * }\n *\n * // Invalid URL\n * const url2 = safeParseUrl('not-a-url')\n * console.log(url2) // undefined\n *\n * // Relative URL with base\n * const url3 = safeParseUrl('/path', 'https://example.com')\n * if (url3) {\n *   console.log(url3.href) // \"https://example.com/path\"\n * }\n *\n * // Error handling\n * function handleUserUrl(input: string) {\n *   const url = safeParseUrl(input)\n *   if (url) {\n *     return url\n *   } else {\n *     console.log('Invalid URL provided')\n *     return null\n *   }\n * }\n * ```\n *\n * @public\n */\nexport const safeParseUrl = (url: string, baseUrl?: string | URL) => {\n\ttry {\n\t\treturn new URL(url, baseUrl)\n\t} catch {\n\t\treturn\n\t}\n}\n"],
-  "mappings": "AAwCO,MAAM,eAAe,CAAC,KAAa,YAA2B;AACpE,MAAI;AACH,WAAO,IAAI,IAAI,KAAK,OAAO;AAAA,EAC5B,QAAQ;AACP;AAAA,EACD;AACD;",
+  "sourcesContent": ["/**\n * Safely parses a URL string without throwing exceptions on invalid input.\n * Returns a URL object for valid URLs or undefined for invalid ones.\n *\n * @param url - The URL string to parse\n * @param baseUrl - Optional base URL to resolve relative URLs against\n * @returns A URL object if parsing succeeds, undefined if it fails\n *\n * @example\n * ```ts\n * // Valid absolute URL\n * const url1 = safeParseUrl('https://example.com')\n * if (url1) {\n *   console.log(`Valid URL: ${url1.href}`) // \"Valid URL: https://example.com/\"\n * }\n *\n * // Invalid URL\n * const url2 = safeParseUrl('not-a-url')\n * console.log(url2) // undefined\n *\n * // Relative URL with base\n * const url3 = safeParseUrl('/path', 'https://example.com')\n * if (url3) {\n *   console.log(url3.href) // \"https://example.com/path\"\n * }\n *\n * // Error handling\n * function handleUserUrl(input: string) {\n *   const url = safeParseUrl(input)\n *   if (url) {\n *     return url\n *   } else {\n *     console.log('Invalid URL provided')\n *     return null\n *   }\n * }\n * ```\n *\n * @public\n */\nexport function safeParseUrl(url: string, baseUrl?: string | URL) {\n\ttry {\n\t\treturn new URL(url, baseUrl)\n\t} catch {\n\t\treturn\n\t}\n}\n"],
+  "mappings": "AAwCO,SAAS,aAAa,KAAa,SAAwB;AACjE,MAAI;AACH,WAAO,IAAI,IAAI,KAAK,OAAO;AAAA,EAC5B,QAAQ;AACP;AAAA,EACD;AACD;",
   "names": []
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tldraw/utils",
   "description": "tldraw infinite canvas SDK (private utilities).",
-  "version": "5.1.0",
+  "version": "5.2.0-next.b91d4a4551c9",
   "author": {
     "name": "tldraw Inc.",
     "email": "hello@tldraw.com"

package/src/lib/debounce.test.ts

@@ -65,4 +65,64 @@ describe(debounce, () => {
 		expect(fn).toHaveBeenCalledTimes(2)
 		expect(await Promise.all([promiseC, promiseD])).toEqual(['gh', 'gh'])
 	})
+
+	it('rejects the pending promise when cancelled', async () => {
+		const fn = vi.fn()
+		const debounced = debounce(fn, 100)
+		const promiseA = debounced()
+		const promiseB = debounced()
+
+		debounced.cancel()
+		vi.advanceTimersByTime(200)
+
+		expect(fn).not.toHaveBeenCalled()
+		await expect(promiseA).rejects.toThrow('Debounced function was cancelled')
+		await expect(promiseB).rejects.toThrow('Debounced function was cancelled')
+	})
+
+	it('starts a fresh promise after cancel', async () => {
+		const fn = vi.fn((a, b) => a + b)
+		const debounced = debounce(fn, 100)
+		const cancelledPromise = debounced('a', 'b')
+
+		debounced.cancel()
+		await expect(cancelledPromise).rejects.toThrow('Debounced function was cancelled')
+
+		const freshPromise = debounced('c', 'd')
+		expect(freshPromise).not.toBe(cancelledPromise)
+
+		vi.advanceTimersByTime(200)
+		expect(fn).toHaveBeenCalledTimes(1)
+		expect(fn).toHaveBeenCalledWith('c', 'd')
+		expect(await freshPromise).toBe('cd')
+	})
+
+	it('cancel is a no-op when no call is pending', async () => {
+		const fn = vi.fn()
+		const debounced = debounce(fn, 100)
+		expect(() => debounced.cancel()).not.toThrow()
+
+		const promise = debounced()
+		debounced.cancel()
+		await expect(promise).rejects.toThrow('Debounced function was cancelled')
+
+		expect(() => debounced.cancel()).not.toThrow()
+	})
+
+	it('does not emit an unhandledrejection when the promise is discarded on cancel', async () => {
+		const handler = vi.fn()
+		process.on('unhandledRejection', handler)
+		try {
+			const fn = vi.fn()
+			const debounced = debounce(fn, 100)
+			debounced()
+			debounced.cancel()
+
+			await new Promise(process.nextTick)
+
+			expect(handler).not.toHaveBeenCalled()
+		} finally {
+			process.off('unhandledRejection', handler)
+		}
+	})
 })

package/src/lib/debounce.ts

@@ -1,3 +1,4 @@
+import { noop } from './function'
 import type { Awaitable } from './types'
 
 /**
@@ -8,6 +9,12 @@ import type { Awaitable } from './types'
  * function returns a Promise that resolves with the result of the original function. Includes a
  * cancel method to prevent execution if needed.
  *
+ * Calling `cancel()` while a call is pending rejects the returned promise with an `Error`
+ * whose message is `'Debounced function was cancelled'`. Callers that discard the promise
+ * are not affected — internal handling suppresses the unhandled-rejection warning — but
+ * any code that `await`s or chains `.then()` on the promise must be prepared to handle the
+ * rejection.
+ *
  * @param callback - The function to debounce (can be sync or async)
  * @param wait - The delay in milliseconds before executing the function
  * @returns A debounced function that returns a Promise and includes a cancel method
@@ -23,15 +30,19 @@ import type { Awaitable } from './types'
  * debouncedSearch('react hooks') // This cancels the previous call
  * debouncedSearch('react typescript') // Only this will execute
  *
- * // Cancel pending execution
+ * // Cancel pending execution — any in-flight promise rejects
  * debouncedSearch.cancel()
  *
- * // With async/await
+ * // With async/await — wrap in try/catch if you might cancel
  * const saveData = debounce(async (data: any) => {
  *   return await api.save(data)
  * }, 1000)
  *
- * const result = await saveData({name: 'John'})
+ * try {
+ *   const result = await saveData({name: 'John'})
+ * } catch (err) {
+ *   // handle cancellation or callback error
+ * }
  * ```
  *
  * @public
@@ -79,7 +90,14 @@ export function debounce<T extends unknown[], U>(
 	fn.cancel = () => {
 		if (!state) return
 		clearTimeout(state.timeout)
+		const s = state
 		state = undefined
+		// Attach a no-op handler so callers that discard the promise don't
+		// trigger an unhandled-rejection warning. Consumers that did `.then`,
+		// `.catch`, or `await` on the returned promise still observe the
+		// rejection through their own chain.
+		s.promise.catch(noop)
+		s.reject(new Error('Debounced function was cancelled'))
 	}
 	return fn
 }

package/src/lib/function.ts

@@ -40,4 +40,4 @@ export function omitFromStackTrace<Args extends Array<unknown>, Return>(
  * Does nothing, but it's really really good at it.
  * @internal
  */
-export const noop: () => void = () => {}
+export function noop(): void {}

package/src/lib/media/avif.ts

@@ -32,7 +32,7 @@
  *
  * @public
  */
-export const isAvifAnimated = (buffer: ArrayBuffer) => {
+export function isAvifAnimated(buffer: ArrayBuffer) {
 	const view = new Uint8Array(buffer)
 	return view[3] === 44
 }

package/src/lib/network.ts

@@ -24,7 +24,7 @@ export async function fetch(input: RequestInfo | URL, init?: RequestInit): Promi
  * @returns HTMLImageElement with referrerPolicy set to 'strict-origin-when-cross-origin'
  * @internal
  */
-export const Image = (width?: number, height?: number) => {
+export function Image(width?: number, height?: number) {
 	// eslint-disable-next-line tldraw/no-restricted-properties
 	const img = new window.Image(width, height)
 	img.referrerPolicy = 'strict-origin-when-cross-origin'

package/src/lib/url.ts

@@ -38,7 +38,7 @@
  *
  * @public
  */
-export const safeParseUrl = (url: string, baseUrl?: string | URL) => {
+export function safeParseUrl(url: string, baseUrl?: string | URL) {
 	try {
 		return new URL(url, baseUrl)
 	} catch {