@chelone/core 0.6.0 → 0.7.0

package/dist/rich-text/rich-text-image.d.ts

@@ -0,0 +1,124 @@
+import { type RichTextImageRules, type RichTextUpload } from "./rich-text-extras.js";
+/** What `uploadFn` may resolve to: a URL, a URL with the stored file's id, or `null` for a failed upload. */
+export type RichTextUploadResult = string | {
+    id: string | number;
+    src: string;
+} | null;
+export type RichTextImageErrorReason = 
+/** The file type is not allowed. */
+"type"
+/** The file is over `maxFileSize`. */
+ | "size"
+/** The URL is not a safe image source. */
+ | "src"
+/** The upload threw, returned `null`, or returned an unsafe URL. */
+ | "upload";
+export interface RichTextImageError {
+    reason: RichTextImageErrorReason;
+    file: File | null;
+    /** What `uploadFn` threw, for an `upload` error. */
+    cause?: unknown;
+}
+/** The image settings of `<RichTextInput images={...}>`: core's rules, each optional, plus the two callbacks. */
+export interface RichTextImageOptions extends Partial<RichTextImageRules> {
+    /**
+     * Stores a file and resolves to its URL. Without it a file is stored in the
+     * HTML as a data URL when `allowBase64` is on.
+     */
+    uploadFn?: (file: File) => Promise<RichTextUploadResult>;
+    /** Called for a file or URL that is refused, and for an upload that fails. */
+    onImageError?: (error: RichTextImageError) => void;
+}
+export interface RichTextImageConfig {
+    rules: RichTextImageRules;
+    uploadFn: RichTextImageOptions["uploadFn"];
+    onImageError: RichTextImageOptions["onImageError"];
+}
+/** `images` from the input's props, with core's defaults under every rule. */
+export declare function resolveRichTextImageConfig(images: boolean | RichTextImageOptions): RichTextImageConfig;
+export type RichTextImageInput = File | {
+    src: string;
+    alt?: string;
+    title?: string;
+};
+/** What a finished upload left on its image: the stored source, or `null` when it failed. */
+export interface RichTextStoredImage {
+    src: string | null;
+    id: string | null;
+}
+interface UploadState {
+    pending: ReadonlySet<string>;
+    settled: Map<string, RichTextStoredImage>;
+    listeners: Set<() => void>;
+}
+export declare function richTextImageUploadState(editor: object): UploadState;
+export declare function setRichTextImageUploading(editor: object, src: string, uploading: boolean): void;
+export declare function storeRichTextImageFile(file: File, { rules, uploadFn }: RichTextImageConfig): Promise<RichTextUpload>;
+export declare function downloadRichTextImage(src: string, alt: string): Promise<void>;
+export declare function copyRichTextImage(src: string): Promise<void>;
+/** DOMPurify's image hook, shared by both fields on their own sanitizer instances. */
+export declare function sanitizeRichTextImageElement(node: Node): void;
+interface PreparedImage {
+    src: string;
+    alt?: string;
+    title?: string;
+    fileName?: string;
+}
+/** Validate a batch and prepare its temporary previews before an adapter inserts it. */
+export declare function prepareRichTextImages(inputs: readonly RichTextImageInput[], config: RichTextImageConfig): {
+    attributes: PreparedImage[];
+    uploads: {
+        file: File;
+        blobUrl: string;
+    }[];
+};
+/** Extra image attributes in the stored HTML, with finite dimensions only. */
+export declare function richTextImageAttributes(): {
+    id: {
+        default: null;
+        parseHTML: (element: HTMLElement) => string | null;
+        renderHTML: (attrs: {
+            id?: string | number | null;
+        }) => {
+            "data-id"?: undefined;
+        } | {
+            "data-id": string;
+        };
+    };
+    fileName: {
+        default: null;
+        parseHTML: (element: HTMLElement) => string | null;
+        renderHTML: (attrs: {
+            fileName?: string | null;
+        }) => {
+            "data-file-name"?: undefined;
+        } | {
+            "data-file-name": string;
+        };
+    };
+    width: {
+        default: null;
+        parseHTML: (element: HTMLElement) => number | null;
+        renderHTML: (attrs: {
+            width?: number | null;
+            height?: number | null;
+        }) => {
+            [x: string]: number | null | undefined;
+        };
+    };
+    height: {
+        default: null;
+        parseHTML: (element: HTMLElement) => number | null;
+        renderHTML: (attrs: {
+            width?: number | null;
+            height?: number | null;
+        }) => {
+            [x: string]: number | null | undefined;
+        };
+    };
+};
+/** Narrows options from the editor library's untyped extension boundary. */
+export declare function isRichTextImageConfigSource(options: unknown): options is {
+    config: () => RichTextImageConfig;
+};
+export {};

package/dist/rich-text/rich-text-image.js

@@ -0,0 +1,163 @@
+import { isSafeImageSrc } from "./rich-text.js";
+import { checkRichTextImageFile, defaultRichTextImageRules, normalizeRichTextUpload, richTextImageFileName } from "./rich-text-extras.js";
+// src/rich-text/rich-text-image.ts
+/** `images` from the input's props, with core's defaults under every rule. */
+function resolveRichTextImageConfig(images) {
+	const options = typeof images === "object" ? images : {};
+	return {
+		rules: {
+			allowedMimeTypes: options.allowedMimeTypes ?? defaultRichTextImageRules.allowedMimeTypes,
+			maxFileSize: options.maxFileSize ?? defaultRichTextImageRules.maxFileSize,
+			allowBase64: options.allowBase64 ?? defaultRichTextImageRules.allowBase64
+		},
+		uploadFn: options.uploadFn,
+		onImageError: options.onImageError
+	};
+}
+var uploadStates = /* @__PURE__ */ new WeakMap();
+function richTextImageUploadState(editor) {
+	const existing = uploadStates.get(editor);
+	if (existing) return existing;
+	const created = {
+		pending: /* @__PURE__ */ new Set(),
+		settled: /* @__PURE__ */ new Map(),
+		listeners: /* @__PURE__ */ new Set()
+	};
+	uploadStates.set(editor, created);
+	return created;
+}
+function setRichTextImageUploading(editor, src, uploading) {
+	const state = richTextImageUploadState(editor);
+	const pending = new Set(state.pending);
+	if (uploading) pending.add(src);
+	else pending.delete(src);
+	state.pending = pending;
+	for (const listener of state.listeners) listener();
+}
+function readDataUrl(file) {
+	return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.onload = () => typeof reader.result === "string" ? resolve(reader.result) : reject(/* @__PURE__ */ new Error("The file could not be read"));
+		reader.onerror = () => reject(reader.error);
+		reader.readAsDataURL(file);
+	});
+}
+/** Without `uploadFn` the file becomes a data URL, which only some raster types may be. */
+function canBeDataUrl(file, allowBase64) {
+	const type = (file.type.split(";")[0] ?? "").trim();
+	return !allowBase64 || isSafeImageSrc(`data:${type};base64,`, { allowDataImages: true });
+}
+async function storeRichTextImageFile(file, { rules, uploadFn }) {
+	const result = uploadFn ? await uploadFn(file) : rules.allowBase64 ? await readDataUrl(file) : null;
+	const upload = result === null ? null : normalizeRichTextUpload(result, rules);
+	if (upload === null) throw new Error("No safe image source was stored");
+	return upload;
+}
+function triggerDownload(href, fileName) {
+	const anchor = document.createElement("a");
+	anchor.href = href;
+	anchor.download = fileName;
+	anchor.rel = "noopener";
+	anchor.click();
+}
+async function downloadRichTextImage(src, alt) {
+	try {
+		const blob = await (await fetch(src)).blob();
+		const url = URL.createObjectURL(blob);
+		triggerDownload(url, richTextImageFileName(alt, blob.type));
+		setTimeout(() => URL.revokeObjectURL(url));
+	} catch {
+		triggerDownload(src, richTextImageFileName(alt, ""));
+	}
+}
+/** Browsers take only PNG on the clipboard, so other formats are redrawn as one. */
+async function toPng(blob) {
+	if (blob.type === "image/png") return blob;
+	const bitmap = await createImageBitmap(blob);
+	const canvas = document.createElement("canvas");
+	canvas.width = bitmap.width;
+	canvas.height = bitmap.height;
+	canvas.getContext("2d")?.drawImage(bitmap, 0, 0);
+	return new Promise((resolve, reject) => canvas.toBlob((png) => png ? resolve(png) : reject(/* @__PURE__ */ new Error("No PNG was produced")), "image/png"));
+}
+async function copyRichTextImage(src) {
+	const blob = await toPng(await (await fetch(src)).blob());
+	await navigator.clipboard.write([new ClipboardItem({ "image/png": blob })]);
+}
+/** DOMPurify's image hook, shared by both fields on their own sanitizer instances. */
+function sanitizeRichTextImageElement(node) {
+	if (node.nodeName !== "IMG" || !(node instanceof window.Element)) return;
+	const src = node.getAttribute("src");
+	if (src === null || !isSafeImageSrc(src, { allowDataImages: true })) node.remove();
+}
+/** Validate a batch and prepare its temporary previews before an adapter inserts it. */
+function prepareRichTextImages(inputs, config) {
+	const attributes = [];
+	const uploads = [];
+	const { rules, onImageError } = config;
+	for (const input of inputs) {
+		if (!(input instanceof File)) {
+			if (isSafeImageSrc(input.src, { allowDataImages: rules.allowBase64 })) attributes.push(input);
+			else onImageError?.({
+				reason: "src",
+				file: null
+			});
+			continue;
+		}
+		const reason = checkRichTextImageFile(input, rules) ?? (config.uploadFn === void 0 && !canBeDataUrl(input, rules.allowBase64) ? "type" : null);
+		if (reason) {
+			onImageError?.({
+				reason,
+				file: input
+			});
+			continue;
+		}
+		const blobUrl = URL.createObjectURL(input);
+		uploads.push({
+			file: input,
+			blobUrl
+		});
+		attributes.push({
+			src: blobUrl,
+			alt: input.name.replace(/\.[^.]*$/, ""),
+			fileName: input.name
+		});
+	}
+	return {
+		attributes,
+		uploads
+	};
+}
+function imageDimension(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/** Extra image attributes in the stored HTML, with finite dimensions only. */
+function richTextImageAttributes() {
+	const dimension = (key) => ({
+		default: null,
+		parseHTML: (element) => {
+			const raw = element.getAttribute(key);
+			return raw === null ? null : imageDimension(Number.parseFloat(raw));
+		},
+		renderHTML: (attrs) => imageDimension(attrs[key]) === null ? {} : { [key]: attrs[key] }
+	});
+	return {
+		id: {
+			default: null,
+			parseHTML: (element) => element.getAttribute("data-id"),
+			renderHTML: (attrs) => attrs.id == null ? {} : { "data-id": String(attrs.id) }
+		},
+		fileName: {
+			default: null,
+			parseHTML: (element) => element.getAttribute("data-file-name"),
+			renderHTML: (attrs) => attrs.fileName == null ? {} : { "data-file-name": String(attrs.fileName) }
+		},
+		width: dimension("width"),
+		height: dimension("height")
+	};
+}
+/** Narrows options from the editor library's untyped extension boundary. */
+function isRichTextImageConfigSource(options) {
+	return typeof options === "object" && options !== null && "config" in options && typeof options.config === "function";
+}
+export { copyRichTextImage, downloadRichTextImage, isRichTextImageConfigSource, prepareRichTextImages, resolveRichTextImageConfig, richTextImageAttributes, richTextImageUploadState, sanitizeRichTextImageElement, setRichTextImageUploading, storeRichTextImageFile };

package/dist/rich-text/rich-text.d.ts

@@ -1,5 +1,11 @@
 /** Whether a link `href` is safe to store and render in rich text. */
 export declare function isSafeLinkUrl(url: string): boolean;
+/**
+ * Whether a file `href` is safe to render. `blob` is allowed on top of the link
+ * schemes: `FileInput` previews a picked file with `URL.createObjectURL` and
+ * hands that url to `FileField`.
+ */
+export declare function isSafeFileUrl(url: string): boolean;
 export interface IsSafeImageSrcOptions {
     /** Allow base64 raster `data:image/*` sources. SVG is never allowed. */
     allowDataImages?: boolean;

package/dist/rich-text/rich-text.js

@@ -1,105 +1,142 @@
-const CONTROL = /[\u0000-\u001f\u007f]/g;
-const SCHEME = /^([a-z][a-z0-9+.-]*):/i;
-const LINK_SCHEMES = /* @__PURE__ */ new Set([
-  "http",
-  "https",
-  "mailto",
-  "tel"
+// src/rich-text/rich-text.ts
+var CONTROL = /[\u0000-\u001f\u007f]/g;
+var SCHEME = /^([a-z][a-z0-9+.-]*):/i;
+var LINK_SCHEMES = /* @__PURE__ */ new Set([
+	"http",
+	"https",
+	"mailto",
+	"tel"
 ]);
+/**
+* `url` as a browser reads its scheme. Browsers drop tabs and newlines anywhere in a URL and
+* ignore leading control characters and spaces, so `java\tscript:` is
+* `javascript:`. Every control character is dropped here, which can only make a
+* scheme easier to see.
+*/
 function normalize(url) {
-  return url.replace(CONTROL, "").trimStart();
+	return url.replace(CONTROL, "").trimStart();
 }
 function schemeOf(normalized) {
-  return SCHEME.exec(normalized)?.[1]?.toLowerCase();
+	return SCHEME.exec(normalized)?.[1]?.toLowerCase();
 }
+/** Whether a link `href` is safe to store and render in rich text. */
 function isSafeLinkUrl(url) {
-  const scheme = schemeOf(normalize(url));
-  return scheme === void 0 || LINK_SCHEMES.has(scheme);
+	const scheme = schemeOf(normalize(url));
+	return scheme === void 0 || LINK_SCHEMES.has(scheme);
 }
-const IMAGE_SCHEMES = /* @__PURE__ */ new Set(["http", "https", "blob"]);
-const RASTER_DATA_URL = /^data:image\/(?:png|jpeg|gif|webp|avif);base64,/i;
+var FILE_SCHEMES = /* @__PURE__ */ new Set([
+	"http",
+	"https",
+	"blob"
+]);
+/**
+* Whether a file `href` is safe to render. `blob` is allowed on top of the link
+* schemes: `FileInput` previews a picked file with `URL.createObjectURL` and
+* hands that url to `FileField`.
+*/
+function isSafeFileUrl(url) {
+	const scheme = schemeOf(normalize(url));
+	return scheme === void 0 || FILE_SCHEMES.has(scheme);
+}
+var IMAGE_SCHEMES = /* @__PURE__ */ new Set([
+	"http",
+	"https",
+	"blob"
+]);
+var RASTER_DATA_URL = /^data:image\/(?:png|jpeg|gif|webp|avif);base64,/i;
+/** Whether an image `src` is safe to store and render in rich text. */
 function isSafeImageSrc(src, options = {}) {
-  const normalized = normalize(src);
-  const scheme = schemeOf(normalized);
-  if (scheme === void 0 || IMAGE_SCHEMES.has(scheme)) return true;
-  return options.allowDataImages === true && RASTER_DATA_URL.test(normalized);
+	const normalized = normalize(src);
+	const scheme = schemeOf(normalized);
+	if (scheme === void 0 || IMAGE_SCHEMES.has(scheme)) return true;
+	return options.allowDataImages === true && RASTER_DATA_URL.test(normalized);
 }
-const richTextSanitizeOptions = Object.freeze({
-  FORBID_TAGS: Object.freeze([
-    "style",
-    "form",
-    "input",
-    "button",
-    "textarea",
-    "select",
-    "iframe",
-    "object",
-    "embed"
-  ]),
-  FORBID_ATTR: Object.freeze(["style"])
+/** DOMPurify config for stored rich text HTML. Spread it into `sanitize`. */
+var richTextSanitizeOptions = Object.freeze({
+	FORBID_TAGS: Object.freeze([
+		"style",
+		"form",
+		"input",
+		"button",
+		"textarea",
+		"select",
+		"iframe",
+		"object",
+		"embed"
+	]),
+	FORBID_ATTR: Object.freeze(["style"])
 });
-const richTextStarterKitOptions = Object.freeze({
-  heading: Object.freeze({
-    levels: Object.freeze([1, 2, 3, 4, 5, 6])
-  }),
-  link: Object.freeze({
-    openOnClick: false,
-    autolink: true,
-    defaultProtocol: "https",
-    isAllowedUri: (url) => isSafeLinkUrl(url)
-  })
+/**
+* Options for tiptap's `StarterKit.configure`. `isAllowedUri` ignores tiptap's
+* second argument, so the scheme rule is ours alone.
+*/
+var richTextStarterKitOptions = Object.freeze({
+	heading: Object.freeze({ levels: Object.freeze([
+		1,
+		2,
+		3,
+		4,
+		5,
+		6
+	]) }),
+	link: Object.freeze({
+		openOnClick: false,
+		autolink: true,
+		defaultProtocol: "https",
+		isAllowedUri: (url) => isSafeLinkUrl(url)
+	})
 });
 function item(id, group, defaultLabel, shortcut) {
-  return Object.freeze({
-    id,
-    group,
-    labelKey: `chelone.rich_text.${id}`,
-    defaultLabel,
-    ...shortcut ? { shortcut } : {}
-  });
+	return Object.freeze({
+		id,
+		group,
+		labelKey: `chelone.rich_text.${id}`,
+		defaultLabel,
+		...shortcut ? { shortcut } : {}
+	});
 }
-const richTextToolbarItems = Object.freeze([
-  item("bold", "mark", "Bold", "mod+b"),
-  item("italic", "mark", "Italic", "mod+i"),
-  item("underline", "mark", "Underline", "mod+u"),
-  item("strike", "mark", "Strikethrough", "mod+shift+s"),
-  item("code", "mark", "Code", "mod+e"),
-  item("clearFormatting", "mark", "Clear formatting"),
-  item("link", "insert", "Link"),
-  item("bulletList", "list", "Bullet list", "mod+shift+8"),
-  item("orderedList", "list", "Ordered list", "mod+shift+7"),
-  item("blockquote", "block", "Blockquote", "mod+shift+b"),
-  item("codeBlock", "block", "Code block", "mod+alt+c"),
-  item("horizontalRule", "insert", "Horizontal rule"),
-  item("undo", "history", "Undo", "mod+z"),
-  item("redo", "history", "Redo", "mod+shift+z")
+/**
+* Every toolbar button, in display order. Adapters map each id to a tiptap
+* command, so core names no tiptap type. A shortcut is listed only where
+* tiptap's own keymap binds it, so the adapter wires nothing extra. Link has
+* none: tiptap binds no key for it, and `mod+k` opens the command menu.
+*/
+var richTextToolbarItems = Object.freeze([
+	item("bold", "mark", "Bold", "mod+b"),
+	item("italic", "mark", "Italic", "mod+i"),
+	item("underline", "mark", "Underline", "mod+u"),
+	item("strike", "mark", "Strikethrough", "mod+shift+s"),
+	item("code", "mark", "Code", "mod+e"),
+	item("clearFormatting", "mark", "Clear formatting"),
+	item("link", "insert", "Link"),
+	item("bulletList", "list", "Bullet list", "mod+shift+8"),
+	item("orderedList", "list", "Ordered list", "mod+shift+7"),
+	item("blockquote", "block", "Blockquote", "mod+shift+b"),
+	item("codeBlock", "block", "Code block", "mod+alt+c"),
+	item("horizontalRule", "insert", "Horizontal rule"),
+	item("undo", "history", "Undo", "mod+z"),
+	item("redo", "history", "Redo", "mod+shift+z")
 ]);
 function heading(level) {
-  return Object.freeze({
-    id: `heading${level}`,
-    level,
-    labelKey: `chelone.rich_text.heading_${level}`,
-    defaultLabel: `Heading ${level}`
-  });
+	return Object.freeze({
+		id: `heading${level}`,
+		level,
+		labelKey: `chelone.rich_text.heading_${level}`,
+		defaultLabel: `Heading ${level}`
+	});
 }
-const richTextBlockTypes = Object.freeze([
-  Object.freeze({
-    id: "paragraph",
-    labelKey: "chelone.rich_text.paragraph",
-    defaultLabel: "Paragraph"
-  }),
-  heading(1),
-  heading(2),
-  heading(3),
-  heading(4),
-  heading(5),
-  heading(6)
+/** What the block-type select offers: paragraph, then headings 1 to 6. */
+var richTextBlockTypes = Object.freeze([
+	Object.freeze({
+		id: "paragraph",
+		labelKey: "chelone.rich_text.paragraph",
+		defaultLabel: "Paragraph"
+	}),
+	heading(1),
+	heading(2),
+	heading(3),
+	heading(4),
+	heading(5),
+	heading(6)
 ]);
-export {
-  isSafeImageSrc,
-  isSafeLinkUrl,
-  richTextBlockTypes,
-  richTextSanitizeOptions,
-  richTextStarterKitOptions,
-  richTextToolbarItems
-};
+export { isSafeFileUrl, isSafeImageSrc, isSafeLinkUrl, richTextBlockTypes, richTextSanitizeOptions, richTextStarterKitOptions, richTextToolbarItems };

package/dist/router/location.d.ts

@@ -5,10 +5,28 @@
  * (`/posts?page=2#top`) so it works identically in a loader, in node, and in the
  * browser. Adapters map their host location onto `CheloneLocation`.
  */
+/**
+ * What Chelone writes into history state. An interface, so an app adds its own
+ * keys by augmenting `@chelone/core`.
+ */
+export interface LocationState {
+    /** `false` keeps the scroll position on navigation. */
+    _scrollToTop?: boolean;
+    /** Where to go once a blocked navigation is confirmed. */
+    nextPathname?: string;
+    /** A seed record of any resource, read by `getRecordFromLocation`. */
+    record?: Record<string, unknown>;
+}
+/**
+ * Read browser history state, which is untyped input, as a `LocationState`.
+ * `null` for anything that is not an object or whose known keys have the wrong
+ * type. App keys pass through unchecked.
+ */
+export declare function toLocationState(raw: unknown): LocationState | null;
 /**
  * A framework-neutral location snapshot. `search` is the raw `?a=b` string
  * (leading `?` included, `''` when empty); `searchParams` is the parsed
- * convenience view; `state` is `unknown` (never `any`) — callers narrow it.
+ * convenience view; `state` is a `LocationState` or `null`.
  * `key` is native in react-router, synthesized for TanStack (plan §0b-4).
  */
 export interface CheloneLocation {
@@ -16,7 +34,7 @@ export interface CheloneLocation {
     search: string;
     searchParams: URLSearchParams;
     hash: string;
-    state: unknown;
+    state: LocationState | null;
     key?: string;
 }
 /**
@@ -26,7 +44,7 @@ export interface CheloneLocation {
  */
 export interface NavigateOpts {
     replace?: boolean;
-    state?: unknown;
+    state?: LocationState;
     resetScroll?: boolean;
 }
 /**
@@ -34,4 +52,4 @@ export interface NavigateOpts {
  * `state`/`key` are threaded through from the caller (a router adapter owns the
  * history entry's state; a bare parse has none).
  */
-export declare function parseLocation(to: string, state?: unknown, key?: string): CheloneLocation;
+export declare function parseLocation(to: string, state?: LocationState | null, key?: string): CheloneLocation;

package/dist/router/location.js

@@ -1,20 +1,43 @@
+import { isRecord } from "../guards.js";
+// src/router/location.ts
+/**
+* Framework-neutral location types + a pure, SSR-safe parser.
+*
+* No `window` at import (or ever): `parseLocation` takes a full path string
+* (`/posts?page=2#top`) so it works identically in a loader, in node, and in the
+* browser. Adapters map their host location onto `CheloneLocation`.
+*/
+/**
+* Read browser history state, which is untyped input, as a `LocationState`.
+* `null` for anything that is not an object or whose known keys have the wrong
+* type. App keys pass through unchecked.
+*/
+function toLocationState(raw) {
+	return isLocationState(raw) ? raw : null;
+}
+function isLocationState(raw) {
+	if (!isRecord(raw)) return false;
+	const { _scrollToTop, nextPathname, record } = raw;
+	return (_scrollToTop === void 0 || typeof _scrollToTop === "boolean") && (nextPathname === void 0 || typeof nextPathname === "string") && (record === void 0 || isRecord(record));
+}
+/**
+* Parse a full path string into a `CheloneLocation`. Pure — no `window`.
+* `state`/`key` are threaded through from the caller (a router adapter owns the
+* history entry's state; a bare parse has none).
+*/
 function parseLocation(to, state = null, key) {
-  const hashIndex = to.indexOf("#");
-  const hash = hashIndex >= 0 ? to.slice(hashIndex) : "";
-  const withoutHash = hashIndex >= 0 ? to.slice(0, hashIndex) : to;
-  const searchIndex = withoutHash.indexOf("?");
-  const search = searchIndex >= 0 ? withoutHash.slice(searchIndex) : "";
-  const pathname = searchIndex >= 0 ? withoutHash.slice(0, searchIndex) : withoutHash;
-  return {
-    pathname: pathname || "/",
-    search,
-    // URLSearchParams accepts a leading `?` and an empty string.
-    searchParams: new URLSearchParams(search),
-    hash,
-    state,
-    key
-  };
+	const hashIndex = to.indexOf("#");
+	const hash = hashIndex >= 0 ? to.slice(hashIndex) : "";
+	const withoutHash = hashIndex >= 0 ? to.slice(0, hashIndex) : to;
+	const searchIndex = withoutHash.indexOf("?");
+	const search = searchIndex >= 0 ? withoutHash.slice(searchIndex) : "";
+	return {
+		pathname: (searchIndex >= 0 ? withoutHash.slice(0, searchIndex) : withoutHash) || "/",
+		search,
+		searchParams: new URLSearchParams(search),
+		hash,
+		state,
+		key
+	};
 }
-export {
-  parseLocation
-};
+export { parseLocation, toLocationState };