@spacefast/common 0.0.13 → 0.0.17

package/dist/utils/asset-fingerprint.js

@@ -1,620 +0,0 @@
-// Publish-time asset fingerprinting (caching plan §6): content-address stable
-// assets by adding a `name.<sha256-prefix-8>.ext` alias alongside the original
-// path and rewriting exact static references (HTML attributes, CSS url()/
-// @import) to the alias. Both paths ship in the version — CAS dedupes the
-// bytes — so every reference we do NOT rewrite (JS, dynamic URLs, hotlinks)
-// keeps working on the original path. The fingerprint IS the sha256 prefix we
-// compute ourselves: immutability is self-verifying by construction, never
-// inferred from pre-existing filenames (see static-runtime-policy.ts for the
-// incident that rule comes from).
-//
-// This module is intentionally pure (no node:path, no I/O, hashing injected)
-// so the exact same pass can be exercised by the CLI, the MCP server, and the
-// builds product against one behavior. JavaScript content is never parsed and
-// never rewritten; HTML is never fingerprinted (it is the freshness anchor).
-import { GUARANTEED_IMMUTABLE_PREFIXES } from "./static-runtime-policy.js";
-export const FINGERPRINT_IMMUTABLE_CACHE_CONTROL = "public, max-age=31536000, immutable";
-export const FINGERPRINT_HASH_LENGTH = 8;
-/**
- * Stand-in hash used to probe user `_headers` coverage of a would-be alias
- * path before the real hash exists. Compiled `_headers` patterns are wildcard/
- * placeholder based and cannot discriminate on hash content, so any 8-char
- * value is decision-equivalent to the real one.
- */
-const FINGERPRINT_PROBE_HASH = "0".repeat(FINGERPRINT_HASH_LENGTH);
-// css/js/images/fonts only — never html (freshness anchor), never data files
-// (json/xml/txt), never .well-known/robots material (no extension match).
-const FINGERPRINT_ASSET_EXTENSIONS = new Set([
-    "css",
-    "js",
-    "mjs",
-    "png",
-    "jpg",
-    "jpeg",
-    "gif",
-    "webp",
-    "avif",
-    "svg",
-    "ico",
-    "bmp",
-    "woff",
-    "woff2",
-    "ttf",
-    "otf",
-    "eot",
-]);
-// Only fingerprint paths that survive URL/_headers round-trips verbatim: no
-// percent-encoding ambiguity, no `_headers` pattern metacharacters (`*`, `:`),
-// no whitespace. Anything else stays on the default lane.
-const SAFE_PATH_PATTERN = /^[A-Za-z0-9/_.-]+$/;
-const SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
-const HTML_ANCHOR_HREF_PATTERN = /<a\b[^>]*\bhref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/giu;
-const JS_STATIC_REFERENCE_PATTERN = /(?:\b(?:import|export)\s+(?:[^"'()]*?\s+from\s+)?|\bimport\s*\(|\bnew\s+URL\s*\()\s*["']([^"']+)["']/gu;
-const SOURCE_MAP_REFERENCE_PATTERN = /[#@]\s*sourceMappingURL=([^\s*]+)/gu;
-/**
- * Advisory-only dependency discovery used by finalize diagnostics. It shares
- * the exact HTML/CSS tokenizer and URL resolver with asset fingerprinting, then
- * adds conservative static JS imports and page links. It never rewrites bytes
- * and never changes access automatically.
- */
-export function scanStaticDocumentDependencies(sourcePath, text) {
-    const extension = pathExtensionOf(sourcePath);
-    const rawUrls = [];
-    if (extension === "html" || extension === "htm") {
-        const html = scanHtml(text);
-        rawUrls.push(...html.refs.map((ref) => ref.url));
-        for (const range of html.cssRanges) {
-            rawUrls.push(...scanCssRefs(range.css, range.offset).map((ref) => ref.url));
-        }
-        for (const match of text.matchAll(HTML_ANCHOR_HREF_PATTERN)) {
-            const url = match[1] ?? match[2] ?? match[3];
-            if (url)
-                rawUrls.push(url);
-        }
-    }
-    else if (extension === "css") {
-        rawUrls.push(...scanCssRefs(text, 0).map((ref) => ref.url));
-    }
-    else if (extension === "js" || extension === "mjs" || extension === "cjs") {
-        for (const match of text.matchAll(JS_STATIC_REFERENCE_PATTERN)) {
-            if (match[1])
-                rawUrls.push(match[1]);
-        }
-        for (const match of text.matchAll(SOURCE_MAP_REFERENCE_PATTERN)) {
-            if (match[1])
-                rawUrls.push(match[1]);
-        }
-    }
-    const baseDir = parentDir(sourcePath);
-    return [
-        ...new Set(rawUrls
-            .map((url) => resolveReference(baseDir, url))
-            .filter((targetPath) => targetPath !== null)),
-    ]
-        .toSorted()
-        .map((targetPath) => ({ sourcePath, targetPath }));
-}
-export function planAssetFingerprints(input) {
-    const covered = input.pathCoveredByUserCacheControl ?? (() => false);
-    const excluded = input.excludePath ?? (() => false);
-    const fileMap = new Map(input.files.map((file) => [file.path, file]));
-    const skipped = [];
-    const eligibleTarget = (path) => {
-        const file = fileMap.get(path);
-        if (!file?.sha256)
-            return false;
-        if (!FINGERPRINT_ASSET_EXTENSIONS.has(pathExtensionOf(path)))
-            return false;
-        if (!SAFE_PATH_PATTERN.test(path))
-            return false;
-        if (GUARANTEED_IMMUTABLE_PREFIXES.some((prefix) => path.startsWith(prefix)))
-            return false;
-        const probeAlias = insertBeforeExtension(path, FINGERPRINT_PROBE_HASH);
-        if (probeAlias === null)
-            return false;
-        if (excluded(path))
-            return false;
-        if (covered(`/${path}`) || covered(`/${probeAlias}`)) {
-            skippedOnce(skipped, path, "user_cache_control");
-            return false;
-        }
-        return true;
-    };
-    // ---- reference extraction --------------------------------------------
-    const htmlDocs = input.files.filter((file) => isExtension(file.path, "html", "htm") && file.text !== undefined);
-    const cssDocs = input.files.filter((file) => pathExtensionOf(file.path) === "css" && file.text !== undefined);
-    const resolveDocRefs = (docPath, text, rawRefs, baseDir) => {
-        const refs = [];
-        for (const ref of rawRefs) {
-            const target = resolveReference(baseDir ?? parentDir(docPath), ref.url);
-            if (target === null || !fileMap.has(target) || target === docPath)
-                continue;
-            refs.push({ ...ref, target });
-        }
-        return { path: docPath, text, refs };
-    };
-    const htmlRefs = [];
-    for (const doc of htmlDocs) {
-        const text = doc.text;
-        const scan = scanHtml(text);
-        const base = resolveBaseDir(doc.path, scan.baseHref);
-        if (base.skipDocument)
-            continue;
-        const rawRefs = [...scan.refs];
-        for (const range of scan.cssRanges) {
-            rawRefs.push(...scanCssRefs(range.css, range.offset));
-        }
-        htmlRefs.push(resolveDocRefs(doc.path, text, rawRefs, base.dir));
-    }
-    const cssRefs = new Map();
-    for (const doc of cssDocs) {
-        const text = doc.text;
-        cssRefs.set(doc.path, resolveDocRefs(doc.path, text, scanCssRefs(text, 0), null));
-    }
-    // ---- referenced, eligible targets ------------------------------------
-    const referenced = new Set();
-    for (const doc of [...htmlRefs, ...cssRefs.values()]) {
-        for (const ref of doc.refs) {
-            if (eligibleTarget(ref.target))
-                referenced.add(ref.target);
-        }
-    }
-    // ---- CSS dependency order (leaves hash first; cycles drop out) --------
-    const cycleMembers = new Set();
-    const cssOrder = [];
-    const state = new Map();
-    const stack = [];
-    const visit = (path) => {
-        const current = state.get(path);
-        if (current === "done")
-            return;
-        if (current === "visiting") {
-            const from = stack.indexOf(path);
-            for (const member of stack.slice(from === -1 ? 0 : from))
-                cycleMembers.add(member);
-            return;
-        }
-        state.set(path, "visiting");
-        stack.push(path);
-        for (const ref of cssRefs.get(path)?.refs ?? []) {
-            if (cssRefs.has(ref.target))
-                visit(ref.target);
-        }
-        stack.pop();
-        state.set(path, "done");
-        cssOrder.push(path);
-    };
-    for (const path of cssRefs.keys())
-        visit(path);
-    for (const member of cycleMembers) {
-        if (referenced.delete(member))
-            skippedOnce(skipped, member, "css_cycle");
-    }
-    // ---- alias assignment + content rewriting ----------------------------
-    const aliasHash = new Map();
-    const claimedAliases = new Set();
-    const aliases = [];
-    const rewrites = [];
-    const assignAlias = (path, fullSha) => {
-        const hash = fullSha.slice(0, FINGERPRINT_HASH_LENGTH);
-        const aliasPath = insertBeforeExtension(path, hash);
-        if (aliasPath === null || fileMap.has(aliasPath) || claimedAliases.has(aliasPath)) {
-            referenced.delete(path);
-            skippedOnce(skipped, path, "alias_collision");
-            return false;
-        }
-        claimedAliases.add(aliasPath);
-        aliasHash.set(path, hash);
-        aliases.push({ path: aliasPath, sourcePath: path });
-        return true;
-    };
-    // Leaf assets (everything that is not a rewritable css doc): the given
-    // sha256 already addresses the exact published bytes.
-    for (const path of [...referenced].toSorted()) {
-        if (cssRefs.has(path))
-            continue;
-        assignAlias(path, fileMap.get(path).sha256);
-    }
-    const rewriteDocText = (doc) => spliceRefs(doc.text, doc.refs.flatMap((ref) => {
-        const hash = aliasHash.get(ref.target);
-        if (hash === undefined)
-            return [];
-        const replacement = fingerprintedUrl(ref.url, hash);
-        return replacement === null ? [] : [{ start: ref.start, end: ref.end, replacement }];
-    }));
-    // CSS in dependency order: rewrite to fingerprinted leaves, THEN hash the
-    // rewritten content — the alias name addresses the bytes that actually ship.
-    for (const path of cssOrder) {
-        if (cycleMembers.has(path))
-            continue;
-        const doc = cssRefs.get(path);
-        const rewritten = rewriteDocText(doc);
-        const changed = rewritten !== doc.text;
-        const fullSha = changed
-            ? input.hashHex(rewritten)
-            : fileMap.get(path).sha256;
-        if (referenced.has(path))
-            assignAlias(path, fullSha);
-        if (changed)
-            rewrites.push({ path, text: rewritten, sha256: fullSha });
-    }
-    // HTML last: never fingerprinted, always points at the freshest aliases.
-    for (const doc of htmlRefs) {
-        const rewritten = rewriteDocText(doc);
-        if (rewritten !== doc.text) {
-            rewrites.push({ path: doc.path, text: rewritten, sha256: input.hashHex(rewritten) });
-        }
-    }
-    aliases.sort((left, right) => left.sourcePath.localeCompare(right.sourcePath));
-    return { aliases, rewrites, skipped };
-}
-/**
- * Merges the generated immutable pins into user `_headers` content. The user
- * content is preserved byte-for-byte; generated exact-path rules are appended
- * (per-path Cache-Control conflicts are impossible — files covered by a user
- * Cache-Control rule are never fingerprinted).
- */
-export function mergeFingerprintHeaders(userHeaders, aliasPaths) {
-    const generated = [
-        "# Generated by the Spacefast publish fingerprint pass: each path below is a",
-        "# content-hashed alias of a file in this version, so its bytes can never change.",
-        ...[...aliasPaths]
-            .toSorted()
-            .flatMap((path) => [`/${path}`, `  Cache-Control: ${FINGERPRINT_IMMUTABLE_CACHE_CONTROL}`]),
-    ].join("\n");
-    if (userHeaders === undefined || userHeaders === "") {
-        return `${generated}\n`;
-    }
-    return `${userHeaders}${userHeaders.endsWith("\n") ? "" : "\n"}\n${generated}\n`;
-}
-// ---------------------------------------------------------------------------
-// Reference resolution
-function skippedOnce(skipped, path, reason) {
-    if (!skipped.some((entry) => entry.path === path))
-        skipped.push({ path, reason });
-}
-function pathExtensionOf(path) {
-    const slash = path.lastIndexOf("/");
-    const base = slash === -1 ? path : path.slice(slash + 1);
-    const dot = base.lastIndexOf(".");
-    return dot > 0 ? base.slice(dot + 1).toLowerCase() : "";
-}
-function isExtension(path, ...extensions) {
-    return extensions.includes(pathExtensionOf(path));
-}
-function parentDir(path) {
-    const slash = path.lastIndexOf("/");
-    return slash === -1 ? "" : path.slice(0, slash);
-}
-function normalizeSegments(pathText) {
-    const stack = [];
-    for (const segment of pathText.split("/")) {
-        if (segment === "" || segment === ".")
-            continue;
-        if (segment === "..") {
-            if (stack.length === 0)
-                return null;
-            stack.pop();
-            continue;
-        }
-        stack.push(segment);
-    }
-    return stack.join("/");
-}
-/**
- * Resolves a raw document reference to a canonical manifest path, or null for
- * anything out of scope: external origins, protocol-relative URLs, data:/other
- * schemes, query strings, bare fragments, whitespace, undecodable escapes, or
- * traversal above the site root. Exact resolution only — no guessing.
- */
-function resolveReference(docDir, url) {
-    if (url === "" || /\s/.test(url))
-        return null;
-    if (url.startsWith("#") || url.includes("?"))
-        return null;
-    if (url.startsWith("//") || SCHEME_PATTERN.test(url))
-        return null;
-    const hashIndex = url.indexOf("#");
-    const pathPart = hashIndex === -1 ? url : url.slice(0, hashIndex);
-    if (pathPart === "")
-        return null;
-    let decoded;
-    try {
-        decoded = decodeURIComponent(pathPart);
-    }
-    catch {
-        return null;
-    }
-    return normalizeSegments(decoded.startsWith("/") ? decoded : docDir ? `${docDir}/${decoded}` : decoded);
-}
-function resolveBaseDir(docPath, baseHref) {
-    if (baseHref === null)
-        return { dir: null, skipDocument: false };
-    const href = baseHref.trim();
-    if (href === "")
-        return { dir: null, skipDocument: false };
-    // An external or unparseable <base> makes every ref resolve off-site:
-    // rewrite nothing in this document.
-    if (href.startsWith("//") || SCHEME_PATTERN.test(href) || href.includes("?") || /\s/.test(href)) {
-        return { dir: null, skipDocument: true };
-    }
-    const withoutFragment = href.split("#", 1)[0];
-    let decoded;
-    try {
-        decoded = decodeURIComponent(withoutFragment);
-    }
-    catch {
-        return { dir: null, skipDocument: true };
-    }
-    const combined = decoded.startsWith("/")
-        ? decoded
-        : `${parentDir(docPath)}${parentDir(docPath) ? "/" : ""}${decoded}`;
-    const normalized = normalizeSegments(combined);
-    if (normalized === null)
-        return { dir: null, skipDocument: true };
-    // "/assets/" is the directory itself; "/assets/page.html" bases on its parent.
-    return { dir: decoded.endsWith("/") ? normalized : parentDir(normalized), skipDocument: false };
-}
-/** Inserts ".hash" before the final extension of a URL/path string. */
-function insertBeforeExtension(value, hash) {
-    const slash = value.lastIndexOf("/");
-    const dot = value.lastIndexOf(".");
-    if (dot <= slash + 1 || dot >= value.length - 1)
-        return null;
-    return `${value.slice(0, dot)}.${hash}${value.slice(dot)}`;
-}
-/** Rewrites a raw reference string to its fingerprinted form, keeping any fragment. */
-function fingerprintedUrl(url, hash) {
-    const hashIndex = url.indexOf("#");
-    const base = hashIndex === -1 ? url : url.slice(0, hashIndex);
-    const suffix = hashIndex === -1 ? "" : url.slice(hashIndex);
-    const rewritten = insertBeforeExtension(base, hash);
-    return rewritten === null ? null : `${rewritten}${suffix}`;
-}
-function spliceRefs(text, replacements) {
-    let output = text;
-    for (const ref of [...replacements].toSorted((left, right) => right.start - left.start)) {
-        output = `${output.slice(0, ref.start)}${ref.replacement}${output.slice(ref.end)}`;
-    }
-    return output;
-}
-// ---------------------------------------------------------------------------
-// CSS reference scanning (url() and @import string forms; comments masked)
-const CSS_URL_PATTERN = /url\(\s*(?:"([^"]*)"|'([^']*)'|([^)"'\s]+))\s*\)/gi;
-const CSS_IMPORT_PATTERN = /@import\s+(?:"([^"]*)"|'([^']*)')/gi;
-const CSS_COMMENT_PATTERN = /\/\*[\s\S]*?(?:\*\/|$)/g;
-function maskCssComments(css) {
-    return css.replace(CSS_COMMENT_PATTERN, (comment) => " ".repeat(comment.length));
-}
-function scanCssRefs(css, offset) {
-    const masked = maskCssComments(css);
-    const refs = [];
-    for (const [pattern, searchFrom] of [
-        [CSS_URL_PATTERN, 4],
-        [CSS_IMPORT_PATTERN, 7],
-    ]) {
-        pattern.lastIndex = 0;
-        for (const match of masked.matchAll(pattern)) {
-            const quoted = match[1] ?? match[2];
-            const value = quoted ?? match[3];
-            if (value === undefined || value === "")
-                continue;
-            const valueStart = quoted !== undefined
-                ? match.index + match[0].search(/["']/) + 1
-                : match.index + match[0].indexOf(value, searchFrom);
-            refs.push({
-                start: offset + valueStart,
-                end: offset + valueStart + value.length,
-                url: value,
-            });
-        }
-    }
-    return refs;
-}
-// ---------------------------------------------------------------------------
-// HTML reference scanning: a real tokenizer (tags, attributes, comments,
-// rawtext elements) that yields exact source offsets, so rewriting is an
-// offset splice and every untouched byte survives verbatim. References are
-// only ever rewritten when they exactly resolve to a published file, so a
-// conservative bail-out (malformed markup, entities in values) simply leaves
-// the reference — and the working original path — alone.
-const HTML_URL_ATTRIBUTES = {
-    link: ["href"],
-    script: ["src"],
-    img: ["src"],
-    source: ["src"],
-    video: ["src", "poster"],
-    audio: ["src"],
-};
-const HTML_SRCSET_TAGS = new Set(["img", "source"]);
-const HTML_RAWTEXT_TAGS = new Set(["script", "style", "textarea", "title"]);
-const META_IMAGE_KEYS = new Set([
-    "og:image",
-    "og:image:url",
-    "og:image:secure_url",
-    "twitter:image",
-    "twitter:image:src",
-]);
-function scanHtml(text) {
-    const refs = [];
-    const cssRanges = [];
-    const lower = text.toLowerCase();
-    let baseHref = null;
-    let baseSeen = false;
-    const processTag = (tagName, attrs) => {
-        const byName = new Map();
-        for (const attr of attrs) {
-            if (!byName.has(attr.name))
-                byName.set(attr.name, attr);
-        }
-        if (tagName === "base") {
-            if (!baseSeen && byName.has("href")) {
-                baseSeen = true;
-                baseHref = byName.get("href").value;
-            }
-            return;
-        }
-        // Attribute values carrying entities ("&") are skipped rather than decoded:
-        // exact-match-only means ambiguity always resolves to "leave it alone".
-        const pushRef = (attr) => {
-            if (attr && attr.value !== "" && !attr.value.includes("&")) {
-                refs.push({ start: attr.start, end: attr.end, url: attr.value });
-            }
-        };
-        for (const attrName of HTML_URL_ATTRIBUTES[tagName] ?? []) {
-            pushRef(byName.get(attrName));
-        }
-        if (HTML_SRCSET_TAGS.has(tagName)) {
-            const srcset = byName.get("srcset");
-            if (srcset && srcset.value !== "" && !srcset.value.includes("&")) {
-                refs.push(...srcsetUrlSpans(srcset.value, srcset.start));
-            }
-        }
-        if (tagName === "meta") {
-            const key = (byName.get("property")?.value ?? byName.get("name")?.value ?? "").toLowerCase();
-            if (META_IMAGE_KEYS.has(key))
-                pushRef(byName.get("content"));
-        }
-        const style = byName.get("style");
-        if (style && style.value !== "" && !style.value.includes("&")) {
-            cssRanges.push({ offset: style.start, css: style.value });
-        }
-    };
-    let i = 0;
-    scan: while (i < text.length) {
-        const lt = text.indexOf("<", i);
-        if (lt === -1)
-            break;
-        if (text.startsWith("<!--", lt)) {
-            const close = text.indexOf("-->", lt + 4);
-            if (close === -1)
-                break;
-            i = close + 3;
-            continue;
-        }
-        const next = text[lt + 1] ?? "";
-        if (next === "!" || next === "?" || next === "/") {
-            const close = text.indexOf(">", lt + 1);
-            if (close === -1)
-                break;
-            i = close + 1;
-            continue;
-        }
-        if (!/[a-zA-Z]/.test(next)) {
-            i = lt + 1;
-            continue;
-        }
-        let p = lt + 1;
-        while (p < text.length && /[a-zA-Z0-9-]/.test(text[p]))
-            p += 1;
-        const tagName = lower.slice(lt + 1, p);
-        const attrs = [];
-        let selfClosing = false;
-        let closed = false;
-        while (p < text.length) {
-            const char = text[p];
-            if (/\s/.test(char)) {
-                p += 1;
-                continue;
-            }
-            if (char === "/") {
-                selfClosing = true;
-                p += 1;
-                continue;
-            }
-            if (char === ">") {
-                closed = true;
-                p += 1;
-                break;
-            }
-            selfClosing = false;
-            const nameStart = p;
-            while (p < text.length && !/[\s=/>]/.test(text[p]))
-                p += 1;
-            const name = lower.slice(nameStart, p);
-            while (p < text.length && /\s/.test(text[p]))
-                p += 1;
-            if (text[p] === "=") {
-                p += 1;
-                while (p < text.length && /\s/.test(text[p]))
-                    p += 1;
-                const quote = text[p];
-                if (quote === '"' || quote === "'") {
-                    const valueStart = p + 1;
-                    const valueEnd = text.indexOf(quote, valueStart);
-                    // Unterminated attribute: stop scanning — never guess at structure.
-                    if (valueEnd === -1)
-                        break scan;
-                    attrs.push({
-                        name,
-                        value: text.slice(valueStart, valueEnd),
-                        start: valueStart,
-                        end: valueEnd,
-                    });
-                    p = valueEnd + 1;
-                }
-                else {
-                    const valueStart = p;
-                    while (p < text.length && !/[\s>]/.test(text[p]))
-                        p += 1;
-                    attrs.push({ name, value: text.slice(valueStart, p), start: valueStart, end: p });
-                }
-            }
-            else if (name !== "") {
-                attrs.push({ name, value: "", start: nameStart, end: nameStart });
-            }
-            else {
-                p += 1;
-            }
-        }
-        if (!closed)
-            break;
-        processTag(tagName, attrs);
-        if (!selfClosing && HTML_RAWTEXT_TAGS.has(tagName)) {
-            const closeIndex = lower.indexOf(`</${tagName}`, p);
-            const contentEnd = closeIndex === -1 ? text.length : closeIndex;
-            if (tagName === "style") {
-                cssRanges.push({ offset: p, css: text.slice(p, contentEnd) });
-            }
-            if (closeIndex === -1)
-                break;
-            i = contentEnd;
-            continue;
-        }
-        i = p;
-    }
-    return { refs, cssRanges, baseHref };
-}
-/** WHATWG-lite srcset candidate parser: URL, then descriptor up to the next comma. */
-function srcsetUrlSpans(value, valueStart) {
-    const spans = [];
-    let i = 0;
-    while (i < value.length) {
-        while (i < value.length && /[\s,]/.test(value[i]))
-            i += 1;
-        if (i >= value.length)
-            break;
-        let j = i;
-        const dataUrl = value.slice(i, i + 5).toLowerCase() === "data:";
-        while (j < value.length &&
-            !(dataUrl ? /\s/.test(value[j]) : /[\s,]/.test(value[j]))) {
-            j += 1;
-        }
-        let url = value.slice(i, j);
-        let end = j;
-        let endedWithComma = false;
-        while (url.endsWith(",")) {
-            url = url.slice(0, -1);
-            end -= 1;
-            endedWithComma = true;
-        }
-        if (url !== "")
-            spans.push({ start: valueStart + i, end: valueStart + end, url });
-        i = j;
-        if (endedWithComma)
-            continue;
-        while (i < value.length && value[i] !== ",")
-            i += 1;
-    }
-    return spans;
-}