frameyard 0.4.0 → 0.5.0

package/dist/html/validate.js

@@ -1,11 +1,12 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
-import { assertJsonSerializable, isPlainObject, mergeProps, normalizeAudioClip, normalizeTranscriptClip, } from "../contracts.js";
+import { KNOWN_DATA_FY_ATTRIBUTES, isAnimationAttribute, isLocalRelative, isMediaAttribute, isRemote, readAnimationDeclarations, readCompositionDescriptor, readMediaDeclarations, readTranscriptDeclarations, } from "../composition/index.js";
+import { mergeProps, } from "../contracts.js";
 import { resolveBindingPath, suggestBindingPath, validateBindingPath } from "../bindings.js";
 import { errorMessage, isFrameyardError } from "../errors.js";
 import { parseTranscript } from "../transcript.js";
-import { findElements, getAttribute, getAttributeLocation, getDocumentDoctype, getElementByTagName, getElementLocation, getNodeLocation, getTextContent, hasAttribute, isDescendantOf, isElement, isTemplate, isTextNode, parseHtml, walk, } from "./parse.js";
-const SCHEME = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+import { createParse5Adapter } from "./document-adapter.js";
+import { findElements, getAttribute, getAttributeLocation, getDocumentDoctype, getElementByTagName, getElementLocation, getNodeLocation, hasAttribute, isDescendantOf, isElement, isTemplate, isTextNode, parseHtml, walk, } from "./parse.js";
 const VOID_ELEMENTS = new Set([
     "area",
     "base",
@@ -24,27 +25,6 @@ const VOID_ELEMENTS = new Set([
 ]);
 const NON_VISUAL_ELEMENTS = new Set(["script", "style", "link", "meta", "template", "noscript", "title"]);
 const NON_ANIMATED_ELEMENTS = new Set(["audio", "fy-transcript", "script", "style", "link", "meta", "template"]);
-const MEDIA_ATTRIBUTES = new Set([
-    "data-fy-start",
-    "data-fy-trim",
-    "data-fy-duration",
-    "data-fy-volume",
-    "data-fy-audio",
-]);
-const KNOWN_BINDING_ATTRIBUTES = [
-    "data-fy",
-    "data-fy-text",
-    "data-fy-if",
-    "data-fy-repeat",
-    "data-fy-anim-start",
-    "data-fy-anim-duration",
-    "data-fy-anim-easing",
-    "data-fy-start",
-    "data-fy-trim",
-    "data-fy-duration",
-    "data-fy-volume",
-    "data-fy-audio",
-];
 class HtmlCompositionValidator {
     diagnostics = [];
     projectRoot;
@@ -57,9 +37,9 @@ class HtmlCompositionValidator {
     metadata = null;
     controller = null;
     documentValid = true;
-    defaultsValid = true;
-    controllerValid = true;
-    rootValid = false;
+    fixedFactsValid = false;
+    overridesValid = false;
+    controllerFileValid = true;
     root = null;
     audioClips = [];
     embeddedAudioClips = [];
@@ -74,10 +54,19 @@ class HtmlCompositionValidator {
     }
     async run() {
         this.validateDoctype();
-        this.findRoot();
-        this.validateMetadata();
-        await this.validateDefaultProps();
-        this.validateControllerDeclaration();
+        const adapter = createParse5Adapter(this.document);
+        const read = readCompositionDescriptor(adapter, {
+            path: this.entry,
+            resolvePath: (raw) => this.resolveControllerPath(raw),
+        });
+        this.diagnostics.push(...read.diagnostics);
+        this.fixedFactsValid = read.valid;
+        const readRoot = read.root;
+        this.root = readRoot !== null && isElement(readRoot) ? readRoot : null;
+        this.metadata = read.descriptor.metadata;
+        this.defaultPropsValue = read.descriptor.defaultProps;
+        this.controller = read.descriptor.controller;
+        this.mergeOverrides();
         await this.validateControllerFile();
         this.validateScripts();
         this.validateUnsupportedElements();
@@ -86,12 +75,32 @@ class HtmlCompositionValidator {
         if (this.root) {
             this.validateBindings(this.root, 0);
         }
-        await this.validateMedia();
-        await this.validateTranscripts();
+        const animation = readAnimationDeclarations(adapter, {
+            path: this.entry,
+            includeTemplateContent: true,
+        });
+        this.diagnostics.push(...animation.diagnostics);
+        this.validateAnimationTargets(animation.entries);
+        const media = readMediaDeclarations(adapter, {
+            path: this.entry,
+            includeTemplateContent: true,
+            props: this.props,
+        });
+        this.diagnostics.push(...media.diagnostics);
+        await this.validateMediaFiles(media.audio, media.embedded);
+        const transcripts = readTranscriptDeclarations(adapter, {
+            path: this.entry,
+            includeTemplateContent: true,
+            props: this.props,
+        });
+        this.diagnostics.push(...transcripts.diagnostics);
+        await this.validateTranscriptFiles(transcripts.declarations);
         await this.validateOrdinaryAssets();
-        const info = this.metadata && this.root && this.rootValid && this.documentValid && this.defaultsValid && this.controllerValid
+        const metadata = this.metadata;
+        const root = this.root;
+        const info = metadata && root && this.fixedFactsValid && this.overridesValid && this.controllerFileValid && this.documentValid
             ? {
-                metadata: this.metadata,
+                metadata,
                 defaultProps: this.defaultPropsValue,
                 controller: this.controller,
                 audioClips: Object.freeze([...this.audioClips]),
@@ -195,179 +204,38 @@ class HtmlCompositionValidator {
             });
         }
     }
-    findRoot() {
-        const roots = findElements(this.document, (element) => element.tagName === "fy-composition");
-        if (roots.length === 0) {
-            this.error("COMPOSITION_INVALID", "Composition document must contain one <fy-composition> root.");
-            return;
-        }
-        for (const extra of roots.slice(1)) {
-            this.error("COMPOSITION_INVALID", "Composition document must contain exactly one <fy-composition> root.", this.elementDetails(extra));
-        }
-        const root = roots[0];
-        this.root = root;
-        let valid = roots.length === 1;
-        const body = getElementByTagName(this.document, "body");
-        if (!body || !isDescendantOf(root, body)) {
-            valid = false;
-            this.error("COMPOSITION_INVALID", "The <fy-composition> root must be inside <body>.", this.elementDetails(root));
-        }
-        if (this.isInsideTemplate(root)) {
-            valid = false;
-            this.error("COMPOSITION_INVALID", "The <fy-composition> root must not be inside a <template>.", this.elementDetails(root));
-        }
-        this.rootValid = valid;
-    }
-    isInsideTemplate(node) {
-        let current = "parentNode" in node ? node.parentNode : null;
-        while (current) {
-            if (isElement(current) && current.tagName === "template") {
-                return true;
-            }
-            current = "parentNode" in current ? current.parentNode : null;
-        }
-        return false;
-    }
-    validateMetadata() {
-        const root = this.root;
-        if (!root) {
-            return;
-        }
-        const width = this.readPositiveInteger(root, "width");
-        const height = this.readPositiveInteger(root, "height");
-        const fps = this.readPositiveNumber(root, "fps");
-        const durationInFrames = this.readPositiveInteger(root, "duration-in-frames");
-        if (width !== null && height !== null && fps !== null && durationInFrames !== null) {
-            this.metadata = { width, height, fps, durationInFrames };
-        }
-    }
-    readPositiveInteger(element, attribute) {
-        const raw = getAttribute(element, attribute);
-        if (raw === undefined) {
-            this.error("COMPOSITION_INVALID", `Missing required "${attribute}" attribute on <fy-composition>.`, this.attributeDetails(element, attribute));
-            return null;
-        }
-        const value = Number(raw);
-        if (!/^\d+$/.test(raw.trim()) || !Number.isInteger(value) || value <= 0) {
-            this.error("COMPOSITION_INVALID", `"${attribute}" must be a positive integer; received "${raw}".`, this.attributeDetails(element, attribute, { value: raw }));
-            return null;
-        }
-        return value;
-    }
-    readPositiveNumber(element, attribute) {
-        const raw = getAttribute(element, attribute);
-        if (raw === undefined) {
-            this.error("COMPOSITION_INVALID", `Missing required "${attribute}" attribute on <fy-composition>.`, this.attributeDetails(element, attribute));
-            return null;
-        }
-        const value = Number(raw);
-        if (!Number.isFinite(value) || value <= 0) {
-            this.error("COMPOSITION_INVALID", `"${attribute}" must be a positive number; received "${raw}".`, this.attributeDetails(element, attribute, { value: raw }));
-            return null;
-        }
-        return value;
-    }
-    async validateDefaultProps() {
-        const blocks = findElements(this.document, (element) => element.tagName === "script" &&
-            getAttribute(element, "type")?.toLowerCase() === "application/json" &&
-            getAttribute(element, "data-fy") === "props");
-        if (blocks.length > 1) {
-            this.defaultsValid = false;
-            for (const extra of blocks.slice(1)) {
-                this.error("PROPS_INVALID", 'A composition may contain at most one data-fy="props" block.', this.elementDetails(extra));
-            }
-        }
-        const block = blocks[0];
-        let defaults = Object.freeze({});
-        if (block) {
-            if (this.isInsideTemplate(block)) {
-                this.defaultsValid = false;
-                this.error("PROPS_INVALID", 'The data-fy="props" block must not be inside a <template>.', this.elementDetails(block));
-            }
-            try {
-                const parsed = JSON.parse(getTextContent(block));
-                if (!isPlainObject(parsed)) {
-                    throw new Error('The data-fy="props" block must contain a JSON object.');
-                }
-                assertJsonSerializable(parsed, "defaultProps");
-                defaults = mergeProps(parsed, undefined);
-            }
-            catch (error) {
-                this.defaultsValid = false;
-                this.error("PROPS_INVALID", `Invalid default props: ${errorMessage(error)}`, this.elementDetails(block));
-            }
-        }
+    mergeOverrides() {
         try {
-            this.props = mergeProps(defaults, this.propsOverrides);
+            this.props = mergeProps(this.defaultPropsValue, this.propsOverrides);
+            this.overridesValid = true;
         }
         catch (error) {
-            this.defaultsValid = false;
+            this.overridesValid = false;
             this.error("PROPS_INVALID", `Invalid props: ${errorMessage(error)}`);
-            this.props = defaults;
-        }
-        if (this.defaultsValid) {
-            this.defaultPropsValue = defaults;
-        }
-    }
-    validateControllerDeclaration() {
-        const blocks = findElements(this.document, (element) => element.tagName === "script" && getAttribute(element, "type")?.toLowerCase() === "text/fy-controller");
-        if (blocks.length > 1) {
-            this.controllerValid = false;
-            for (const extra of blocks.slice(1)) {
-                this.error("CONTROLLER_INVALID", "A composition may declare at most one controller.", this.elementDetails(extra));
-            }
-        }
-        const block = blocks[0];
-        if (!block) {
-            return;
+            this.props = this.defaultPropsValue;
         }
-        if (this.isInsideTemplate(block)) {
-            this.controllerValid = false;
-            this.error("CONTROLLER_INVALID", "The controller block must not be inside a <template>.", this.elementDetails(block));
-        }
-        const src = getAttribute(block, "src");
-        const source = getTextContent(block);
-        const hasSource = source.trim().length > 0;
-        if (src !== undefined && hasSource) {
-            this.controllerValid = false;
-            this.error("CONTROLLER_INVALID", "A controller must be either inline or external, not both.", this.attributeDetails(block, "src"));
-            return;
-        }
-        if (src === undefined && !hasSource) {
-            this.controllerValid = false;
-            this.error("CONTROLLER_INVALID", "A controller must contain inline source or reference an external module with src.", this.elementDetails(block));
-            return;
-        }
-        if (src !== undefined) {
-            this.controller = {
-                kind: "external",
-                src,
-                ...this.locationDetails(getAttributeLocation(block, "src")),
-            };
-            return;
-        }
-        const textNode = block.childNodes[0];
-        const location = textNode ? getNodeLocation(textNode) : getElementLocation(block);
-        this.controller = {
-            kind: "inline",
-            source,
-            ...this.locationDetails(location),
-        };
     }
     async validateControllerFile() {
-        if (!this.controller || this.controller.kind !== "external" || this.controller.src === undefined) {
+        const controller = this.controller;
+        if (!controller ||
+            controller.kind !== "external" ||
+            controller.rawSrc === undefined ||
+            controller.src === undefined) {
             return;
         }
         const details = {
             path: this.entry,
-            ...(this.controller.line !== undefined ? { line: this.controller.line, column: this.controller.column } : {}),
+            ...(controller.line !== undefined ? { line: controller.line, column: controller.column } : {}),
         };
-        const resolved = await this.resolveLocalFile(this.controller.src, this.compositionDir, "CONTROLLER_INVALID", "Controller", details);
+        const resolved = await this.resolveLocalFile(controller.rawSrc, this.compositionDir, "CONTROLLER_INVALID", "Controller", details);
         if (!resolved) {
-            this.controllerValid = false;
+            this.controllerFileValid = false;
             return;
         }
-        this.controller = { ...this.controller, src: resolved.relative };
+        this.controller = { ...controller, src: resolved.relative };
+    }
+    resolveControllerPath(raw) {
+        return path.relative(this.projectRoot, path.resolve(this.compositionDir, raw)).split(path.sep).join("/");
     }
     validateScripts() {
         for (const element of findElements(this.document, (candidate) => candidate.tagName === "script")) {
@@ -531,22 +399,11 @@ class HtmlCompositionValidator {
                 this.validateClassBinding(element, name, attribute.value, inRepeat);
                 continue;
             }
-            if (name === "data-fy-anim-start" || name === "data-fy-anim-duration") {
-                this.validateAnimationDuration(element, name, attribute.value);
-                continue;
-            }
-            if (name === "data-fy-anim-easing") {
-                if (attribute.value.trim().length === 0) {
-                    this.error("ANIMATION_INVALID", "data-fy-anim-easing must not be empty.", this.attributeDetails(element, name));
-                }
-                continue;
-            }
-            if (MEDIA_ATTRIBUTES.has(name)) {
-                this.validateMediaAttribute(element, name, attribute.value);
+            if (isAnimationAttribute(name) || isMediaAttribute(name)) {
                 continue;
             }
             if (name.startsWith("data-fy-")) {
-                this.error("BINDING_INVALID", `Unknown Frameyard attribute "${name}". Known attributes: ${KNOWN_BINDING_ATTRIBUTES.join(", ")}.`, this.attributeDetails(element, name, { value: attribute.value }));
+                this.error("BINDING_INVALID", `Unknown Frameyard attribute "${name}". Known attributes: ${KNOWN_DATA_FY_ATTRIBUTES.join(", ")}.`, this.attributeDetails(element, name, { value: attribute.value }));
             }
         }
         const children = isTemplate(element) ? element.content.childNodes : element.childNodes;
@@ -610,195 +467,61 @@ class HtmlCompositionValidator {
             checkValueType: "class",
         });
     }
-    validateAnimationDuration(element, name, value) {
-        const frames = Number(value);
-        const valid = /^\d+$/.test(value.trim()) &&
-            Number.isInteger(frames) &&
-            (name === "data-fy-anim-start" ? frames >= 0 : frames > 0);
-        if (!valid) {
-            this.error("ANIMATION_INVALID", `${name} must be a ${name === "data-fy-anim-start" ? "non-negative" : "positive"} integer frame count.`, this.attributeDetails(element, name, { value }));
-        }
-        if (NON_ANIMATED_ELEMENTS.has(element.tagName)) {
-            this.warning("ANIMATION_NOT_FOUND", `${name} has no visual animation target on <${element.tagName}>.`, this.attributeDetails(element, name));
-        }
-    }
-    validateMediaAttribute(element, name, value) {
-        if (element.tagName !== "audio" && element.tagName !== "video") {
-            this.error("MEDIA_INVALID", `${name} is only valid on <audio> or <video>.`, this.attributeDetails(element, name));
-            return;
-        }
-        if (name === "data-fy-audio") {
-            if (element.tagName !== "video" || value !== "off") {
-                this.error("MEDIA_INVALID", 'data-fy-audio is only valid on <video> with the value "off".', this.attributeDetails(element, name, { value }));
-            }
-            return;
-        }
-        if (name === "data-fy-start") {
-            const frames = Number(value);
-            if (!/^\d+$/.test(value.trim()) || !Number.isInteger(frames) || frames < 0) {
-                this.error("MEDIA_INVALID", "data-fy-start must be a non-negative integer frame.", this.attributeDetails(element, name, { value }));
-            }
-            return;
-        }
-        if (name === "data-fy-trim") {
-            const seconds = Number(value);
-            if (!Number.isFinite(seconds) || seconds < 0) {
-                this.error("MEDIA_INVALID", "data-fy-trim must be a non-negative number of seconds.", this.attributeDetails(element, name, { value }));
-            }
-            return;
-        }
-        if (name === "data-fy-duration") {
-            const seconds = Number(value);
-            if (!Number.isFinite(seconds) || seconds <= 0) {
-                this.error("MEDIA_INVALID", "data-fy-duration must be a positive number of seconds.", this.attributeDetails(element, name, { value }));
-            }
-            return;
-        }
-        const volume = Number(value);
-        if (!Number.isFinite(volume) || volume < 0 || volume > 1) {
-            this.error("MEDIA_INVALID", "data-fy-volume must be between 0 and 1.", this.attributeDetails(element, name, { value }));
-        }
-    }
-    async validateMedia() {
-        const media = findElements(this.document, (element) => element.tagName === "audio" || element.tagName === "video");
-        for (const element of media) {
-            const literal = getAttribute(element, "src");
-            const bound = getAttribute(element, "data-fy-attr-src");
-            if (literal !== undefined && bound !== undefined) {
-                this.error("MEDIA_INVALID", `Use either src or data-fy-attr-src on <${element.tagName}>, not both.`, this.elementDetails(element));
+    validateAnimationTargets(entries) {
+        for (const entry of entries) {
+            if (!isElement(entry.element)) {
                 continue;
             }
-            if (literal === undefined && bound === undefined) {
-                this.error("MEDIA_INVALID", `<${element.tagName}> requires a src attribute or data-fy-attr-src binding.`, this.elementDetails(element));
+            const tag = entry.element.tagName;
+            if (!NON_ANIMATED_ELEMENTS.has(tag)) {
                 continue;
             }
-            let source;
-            if (literal !== undefined) {
-                source = literal;
-            }
-            else if (bound !== undefined) {
-                const resolved = this.resolveMediaBinding(bound);
-                if (resolved === null) {
+            for (const attribute of entry.attributes) {
+                if (attribute !== "data-fy-anim-start" && attribute !== "data-fy-anim-duration") {
                     continue;
                 }
-                source = resolved;
-            }
-            if (source === undefined) {
-                continue;
-            }
-            const file = await this.resolveLocalFile(source, this.projectRoot, "MEDIA_INVALID", "Media", this.elementDetails(element));
-            if (!file) {
-                continue;
-            }
-            const startFrame = this.readMediaInteger(element, "data-fy-start", 0);
-            const trimStart = this.readMediaNumber(element, "data-fy-trim", 0);
-            const trimDuration = this.readOptionalMediaNumber(element, "data-fy-duration");
-            const volume = hasAttribute(element, "muted") ? 0 : this.readMediaNumber(element, "data-fy-volume", 1);
-            if (startFrame === undefined || trimStart === undefined || volume === undefined) {
-                continue;
-            }
-            try {
-                const clip = normalizeAudioClip({
-                    src: file.relative,
-                    startFrame,
-                    trimStart,
-                    ...(trimDuration !== undefined ? { trimDuration } : {}),
-                    volume,
-                }, this.audioClips.length + this.embeddedAudioClips.length);
-                if (element.tagName === "audio") {
-                    this.audioClips.push(clip);
-                }
-                else if (!hasAttribute(element, "muted") && getAttribute(element, "data-fy-audio") !== "off") {
-                    this.embeddedAudioClips.push(clip);
-                }
-            }
-            catch (error) {
-                this.error(errorCode(error, "MEDIA_INVALID"), errorMessage(error), this.elementDetails(element));
+                this.warning("ANIMATION_NOT_FOUND", `${attribute} has no visual animation target on <${tag}>.`, this.attributeDetails(entry.element, attribute));
             }
         }
     }
-    resolveMediaBinding(path) {
-        const root = path.split(".")[0];
-        if (root === "item" || root === "index") {
-            return null;
-        }
-        const resolved = resolveBindingPath({ props: this.props }, path);
-        if (!resolved.found) {
-            return null;
-        }
-        if (typeof resolved.value !== "string" || resolved.value.length === 0) {
-            this.error("MEDIA_INVALID", `Media binding "${path}" must resolve to a non-empty local path.`, { value: path });
-            return null;
-        }
-        return resolved.value;
-    }
-    readMediaInteger(element, attribute, fallback) {
-        const raw = getAttribute(element, attribute);
-        if (raw === undefined) {
-            return fallback;
+    async validateMediaFiles(audio, embedded) {
+        for (const declaration of audio) {
+            if (await this.mediaFileExists(declaration)) {
+                this.audioClips.push(declaration.clip);
+            }
         }
-        const value = Number(raw);
-        return /^\d+$/.test(raw.trim()) && Number.isInteger(value) && value >= 0 ? value : undefined;
-    }
-    readMediaNumber(element, attribute, fallback) {
-        const raw = getAttribute(element, attribute);
-        if (raw === undefined) {
-            return fallback;
+        for (const declaration of embedded) {
+            if (await this.mediaFileExists(declaration)) {
+                this.embeddedAudioClips.push(declaration.clip);
+            }
         }
-        const value = Number(raw);
-        return Number.isFinite(value) && value >= 0 ? value : undefined;
     }
-    readOptionalMediaNumber(element, attribute) {
-        const raw = getAttribute(element, attribute);
-        if (raw === undefined) {
-            return undefined;
+    async mediaFileExists(declaration) {
+        if (!isElement(declaration.element)) {
+            return false;
         }
-        const value = Number(raw);
-        return Number.isFinite(value) && value > 0 ? value : undefined;
+        const file = await this.resolveLocalFile(declaration.clip.src, this.projectRoot, "MEDIA_INVALID", "Media", this.elementDetails(declaration.element));
+        return file !== null;
     }
-    async validateTranscripts() {
-        const transcripts = findElements(this.document, (element) => element.tagName === "fy-transcript");
-        for (const element of transcripts) {
-            const literal = getAttribute(element, "src");
-            const bound = getAttribute(element, "data-fy-attr-src");
-            if (literal !== undefined && bound !== undefined) {
-                this.error("TRANSCRIPT_INVALID", "Use either src or data-fy-attr-src on <fy-transcript>, not both.", this.elementDetails(element));
-                continue;
-            }
-            if (literal === undefined && bound === undefined) {
-                this.error("TRANSCRIPT_INVALID", "<fy-transcript> requires a src attribute or data-fy-attr-src binding.", this.elementDetails(element));
+    async validateTranscriptFiles(declarations) {
+        for (const declaration of declarations) {
+            if (!isElement(declaration.element)) {
                 continue;
             }
-            let source;
-            if (literal !== undefined) {
-                source = literal;
-            }
-            else if (bound !== undefined) {
-                const resolved = this.resolveMediaBinding(bound);
-                if (resolved === null) {
-                    continue;
-                }
-                source = resolved;
-            }
-            if (source === undefined) {
-                continue;
-            }
-            const file = await this.resolveLocalFile(source, this.projectRoot, "TRANSCRIPT_INVALID", "Transcript", this.elementDetails(element));
+            const file = await this.resolveLocalFile(declaration.clip.src, this.projectRoot, "TRANSCRIPT_INVALID", "Transcript", this.elementDetails(declaration.element));
             if (!file) {
                 continue;
             }
-            const words = hasAttribute(element, "words");
+            this.transcriptClips.push(declaration.clip);
             try {
-                const clip = normalizeTranscriptClip({ src: file.relative, words }, this.transcriptClips.length);
-                this.transcriptClips.push(clip);
                 const content = await readFile(file.absolute, "utf8");
                 const parsed = JSON.parse(content);
-                parseTranscript(parsed, { requireWords: words });
+                parseTranscript(parsed, { requireWords: declaration.clip.words });
             }
             catch (error) {
                 this.error(errorCode(error, "TRANSCRIPT_INVALID"), errorMessage(error), {
                     path: file.relative,
-                    ...this.elementDetails(element),
+                    ...this.elementDetails(declaration.element),
                 });
             }
         }
@@ -907,12 +630,6 @@ export async function validateHtmlComposition(options) {
     const validator = new HtmlCompositionValidator({ ...options, projectRoot }, document);
     return validator.run();
 }
-function isRemote(value) {
-    return SCHEME.test(value) || value.startsWith("//");
-}
-function isLocalRelative(value) {
-    return !SCHEME.test(value) && !value.startsWith("/") && !value.includes("\\") && !value.split("/").includes("..");
-}
 function describeValue(value) {
     if (value === null) {
         return "null";