@dogsbay/format-openapi 0.2.0-beta.14 → 0.2.0-beta.141

package/dist/parse.js

@@ -16,66 +16,111 @@
  * per-operation pages so the namespace renders as a self-contained
  * mini-site.
  */
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { resolve, join, isAbsolute } from "node:path";
-import { dereference } from "@scalar/openapi-parser";
 import { parse as parseYaml } from "yaml";
-import { operationToSlug, slugifyTag } from "./slug.js";
-import { resolveCodeSamples } from "./code-samples.js";
-const HTTP_METHODS = [
-    "get",
-    "post",
-    "put",
-    "patch",
-    "delete",
-    "head",
-    "options",
-];
+import { embedSpec, parseSpecText, prepareSpec, specToPages, } from "./core.js";
+/** Extensions a spec file can plausibly have. See the note in detectSpecPath. */
+const SPEC_FILE_EXT = /\.(ya?ml|json)$/i;
 /** Auto-detect spec location given the configured source path. */
 export function detectSpecPath(sourcePath) {
     if (sourcePath.startsWith("http://") || sourcePath.startsWith("https://")) {
         return sourcePath;
     }
     if (existsSync(sourcePath)) {
+        // Was `readFileSync(sourcePath)` — reading an entire (possibly multi-MB)
+        // spec into a Buffer purely to answer "is this a file", relying on EISDIR
+        // to signal a directory. `statSync` answers it directly.
         const stat = (() => {
             try {
-                return readFileSync(sourcePath);
+                return statSync(sourcePath);
             }
             catch {
                 return null;
             }
         })();
         // If it's a file, return as-is. If it's a directory, look inside.
+        //
+        // The extension check is load-bearing for AUTO-DETECTION: `detectSpecPath`
+        // used to return any existing file, and `detectOpenApiSource` then only
+        // scanned its first 2 KB for `openapi:` / `swagger:`. No earlier plugin in
+        // the registry claims a FILE path, so openapi-last did not protect
+        // anything — a Mintlify page carrying `openapi: "GET /v1/links"` in its
+        // frontmatter was detected as an OpenAPI spec and routed into this parser.
         try {
             const isFile = existsSync(sourcePath) && stat !== null;
-            if (isFile && !isDirectory(sourcePath))
-                return sourcePath;
+            if (isFile && !isDirectory(sourcePath)) {
+                return SPEC_FILE_EXT.test(sourcePath) ? sourcePath : null;
+            }
         }
         catch {
             // fall through to directory probe
         }
         if (isDirectory(sourcePath)) {
+            // `swagger.*` is here because the content check below explicitly accepts
+            // a `swagger:` declaration — without these names, the one filename that
+            // check was written for (Swagger 2.0 ships as `swagger.json` by
+            // convention) could never be found.
             const candidates = [
                 "openapi.yaml",
                 "openapi.yml",
                 "openapi.json",
+                "swagger.yaml",
+                "swagger.yml",
+                "swagger.json",
                 "spec.yaml",
                 "spec.yml",
                 "spec.json",
-            ];
-            for (const name of candidates) {
-                const p = join(sourcePath, name);
-                if (existsSync(p))
-                    return p;
-            }
+            ].map((name) => join(sourcePath, name)).filter((p) => existsSync(p));
+            // Prefer the first candidate that actually LOOKS like a spec, rather
+            // than the first that merely exists. `openapi.yaml` is also a common
+            // name for codegen/CI config; when such a decoy sat next to a genuine
+            // `spec.yaml`, returning the decoy made the whole directory read as
+            // "not an OpenAPI source" and the real spec was never seen.
+            const declared = candidates.find((p) => declaresSpec(p));
+            if (declared)
+                return declared;
+            // Nothing sniffs as a spec: still return the first candidate so
+            // `parseOpenApiSpec` fails on the FILE (a parse error naming the path)
+            // rather than with a misleading "spec not found". Detection is
+            // unaffected — `detectOpenApiSource` re-applies the same check.
+            return candidates[0] ?? null;
         }
     }
     return null;
 }
+/**
+ * Does this file declare `openapi:` / `swagger:` in its first 2 KB?
+ *
+ * The leading `[{,]?` matters: a MINIFIED JSON spec puts everything on one
+ * line (`{"openapi":"3.0.0",…`), so a purely line-anchored pattern never
+ * matched it and a perfectly valid spec was undetectable. Swagger 2.0 ships
+ * minified as `swagger.json` more often than not.
+ */
+function declaresSpec(path) {
+    try {
+        const head = readFileSync(path, "utf-8").slice(0, 2048);
+        return (/(?:^|[{,])\s*"?openapi"?\s*[:=]/m.test(head) ||
+            /(?:^|[{,])\s*"?swagger"?\s*[:=]/m.test(head));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The package is `"type": "module"`, so a CJS `require` of node:fs here threw
+ * `require is not defined` on EVERY call — the catch swallowed it and this
+ * returned false unconditionally. Effect: `detectSpecPath` never took its
+ * directory branch, so a spec-only DIRECTORY was undetectable and only a
+ * direct path to the spec file worked.
+ *
+ * Vitest cannot see this: its SSR transform supplies a `require` shim, so the
+ * unit tests passed while the shipped ESM build was broken. Caught by running
+ * the actual CLI against a directory. Use the static import instead.
+ */
 function isDirectory(p) {
     try {
-        const { statSync } = require("node:fs");
         return statSync(p).isDirectory();
     }
     catch {
@@ -95,14 +140,7 @@ export function detectOpenApiSource(path) {
         return true;
     // Sanity-check the file content briefly to avoid false-positives on
     // arbitrary YAML/JSON sitting in a sibling directory.
-    try {
-        const head = readFileSync(detected, "utf-8").slice(0, 2048);
-        return /^\s*"?openapi"?\s*[:=]/m.test(head) ||
-            /^\s*"?swagger"?\s*[:=]/m.test(head);
-    }
-    catch {
-        return false;
-    }
+    return declaresSpec(detected);
 }
 export async function parseOpenApiSpec(sourcePath, options = {}) {
     const specPath = detectSpecPath(sourcePath);
@@ -110,404 +148,29 @@ export async function parseOpenApiSpec(sourcePath, options = {}) {
         throw new Error(`OpenAPI spec not found at ${sourcePath}. Looked for openapi.{yaml,yml,json} ` +
             `and spec.{yaml,yml,json} (or expected a direct file path / URL).`);
     }
-    const raw = await readSpecText(specPath);
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        parsed = parseYaml(raw);
-    }
-    const { schema: spec } = await dereference(parsed);
-    if (!spec) {
-        throw new Error(`Failed to dereference OpenAPI spec at ${specPath}`);
-    }
-    const baseUrl = spec.servers?.[0]?.url || "";
-    const hrefPrefix = normalisePrefix(options.hrefPrefix);
-    const pages = [];
-    // Collect tag descriptions (from spec.tags[]) for tag overview pages.
-    const tagDescriptions = new Map();
-    for (const t of spec.tags || []) {
-        if (t?.name)
-            tagDescriptions.set(t.name, t.description || "");
-    }
-    // Walk operations.
-    const paths = spec.paths || {};
-    const tagToOps = new Map();
-    const untagged = [];
-    for (const [path, pathItem] of Object.entries(paths)) {
-        if (!pathItem)
-            continue;
-        for (const method of HTTP_METHODS) {
-            const operation = pathItem[method];
-            if (!operation)
-                continue;
-            const opTags = Array.isArray(operation.tags)
-                ? operation.tags
-                : [];
-            const primaryTag = opTags[0];
-            const tagSlug = primaryTag ? slugifyTag(primaryTag) : "";
-            const opSlug = operationToSlug(method, path, operation.operationId);
-            const slug = tagSlug ? `${tagSlug}/${opSlug}` : opSlug;
-            const props = {
-                method,
-                path,
-                baseUrl,
-                summary: operation.summary || undefined,
-                description: operation.description || undefined,
-                operationId: operation.operationId || undefined,
-                tags: opTags.length > 0 ? opTags : undefined,
-                deprecated: operation.deprecated === true ? true : undefined,
-                parameters: extractParameters(operation, pathItem),
-                ...extractRequestBody(operation),
-                responses: extractResponses(operation),
-                codeSamples: resolveCodeSamples(operation, method, path, baseUrl),
-            };
-            const title = operation.summary || `${method.toUpperCase()} ${path}`;
-            const tree = [
-                {
-                    type: "endpoint",
-                    props: props,
-                },
-            ];
-            const headings = [{ depth: 1, slug: opSlug, text: title }];
-            pages.push({
-                slug,
-                title,
-                tree,
-                headings,
-            });
-            const summary = {
-                slug,
-                title,
-                method,
-                path,
-                deprecated: operation.deprecated === true,
-            };
-            if (primaryTag) {
-                const arr = tagToOps.get(primaryTag) || [];
-                arr.push(summary);
-                tagToOps.set(primaryTag, arr);
-            }
-            else {
-                untagged.push(summary);
-            }
-        }
-    }
-    // Tag overview pages.
-    for (const [tagName, ops] of tagToOps) {
-        const tagSlug = slugifyTag(tagName);
-        const description = tagDescriptions.get(tagName) || "";
-        pages.push(buildTagPage(tagName, tagSlug, description, ops));
-    }
-    // Root info page.
-    const info = spec.info || {};
-    pages.push(buildInfoPage(info.title || "API Reference", info.description || "", info.version || ""));
-    // Build nav: tag groups in declaration order, with operations as
-    // children. Untagged operations land under a synthetic "Other" group
-    // so they're discoverable but visually separated.
-    const nav = buildNav(spec, pages, tagToOps, untagged, hrefPrefix);
-    return { pages, nav };
+    return specToPages(await loadSpec(specPath), options);
+}
+/** Read a spec file (or URL) and prepare it (core.ts `prepareSpec`). */
+export async function loadSpec(specPath) {
+    return prepareSpec(parseSpecText(await readSpecText(specPath), parseYaml), specPath);
+}
+/**
+ * A whole spec as the BODY of one page (core.ts `embedSpec`), read from a
+ * file. Each call parses the spec; a build that embeds one spec on several
+ * pages uses `createSpecCache` and `embedSpec` instead.
+ */
+export async function openApiEmbed(specPath, options = {}) {
+    return embedSpec(await loadSpec(specPath), options);
 }
 async function readSpecText(specPath) {
     if (specPath.startsWith("http://") || specPath.startsWith("https://")) {
-        const r = await fetch(specPath);
+        // Bound the fetch — a spec is loaded during `convert` / `site build`, so a
+        // slow/hung host must not stall the whole import indefinitely.
+        const r = await fetch(specPath, { signal: AbortSignal.timeout(30_000) });
+        if (!r.ok)
+            throw new Error(`HTTP ${r.status} fetching spec ${specPath}`);
         return await r.text();
     }
     const abs = isAbsolute(specPath) ? specPath : resolve(specPath);
     return await readFile(abs, "utf-8");
 }
-function normalisePrefix(p) {
-    if (!p)
-        return "";
-    return p.replace(/\/+$/, "");
-}
-function schemaToType(schema) {
-    if (!schema)
-        return "any";
-    if (schema.type === "array") {
-        const itemType = schema.items ? schemaToType(schema.items) : "any";
-        return `${itemType}[]`;
-    }
-    return schema.type || "any";
-}
-function extractSchemaProperties(schema, requiredFields) {
-    if (!schema?.properties)
-        return [];
-    const required = requiredFields || schema.required || [];
-    return Object.entries(schema.properties).map(([name, prop]) => {
-        const result = {
-            name,
-            type: schemaToType(prop),
-            required: required.includes(name),
-        };
-        if (prop.description)
-            result.description = prop.description;
-        if (prop.nullable)
-            result.nullable = true;
-        if (prop.format)
-            result.format = prop.format;
-        if (prop.enum)
-            result.enum = prop.enum;
-        if (prop.default !== undefined)
-            result.default = prop.default;
-        if (prop.example !== undefined)
-            result.example = prop.example;
-        if (prop.type === "object" && prop.properties) {
-            result.properties = extractSchemaProperties(prop);
-        }
-        if (prop.type === "array" && prop.items) {
-            if (prop.items.type === "object" && prop.items.properties) {
-                result.items = extractSchemaProperties(prop.items);
-            }
-        }
-        return result;
-    });
-}
-function extractParameters(operation, pathItem) {
-    const params = [];
-    const allParams = [
-        ...(pathItem.parameters || []),
-        ...(operation.parameters || []),
-    ];
-    // Operation-level wins over path-level on (name, in) collision.
-    const seen = new Map();
-    for (const p of allParams) {
-        if (!p?.name || !p?.in)
-            continue;
-        seen.set(`${p.name}:${p.in}`, p);
-    }
-    for (const p of seen.values()) {
-        const param = {
-            name: p.name,
-            in: p.in,
-            type: schemaToType(p.schema),
-            required: p.required || false,
-        };
-        if (p.description)
-            param.description = p.description;
-        if (p.schema?.default !== undefined) {
-            param.default = String(p.schema.default);
-        }
-        if (p.schema?.enum)
-            param.enum = p.schema.enum;
-        if (p.deprecated)
-            param.deprecated = true;
-        params.push(param);
-    }
-    return params;
-}
-function extractRequestBody(operation) {
-    const body = operation.requestBody;
-    if (!body?.content)
-        return {};
-    const mediaType = body.content["application/json"] ||
-        Object.values(body.content)[0];
-    if (!mediaType?.schema)
-        return {};
-    return {
-        requestBody: extractSchemaProperties(mediaType.schema),
-        requestBodyExample: generateExampleFromSchema(mediaType.schema),
-    };
-}
-function extractResponses(operation) {
-    if (!operation.responses)
-        return [];
-    return Object.entries(operation.responses)
-        .filter(([status]) => status !== "default")
-        .map(([status, resp]) => {
-        const result = {
-            status,
-            description: resp.description,
-        };
-        if (resp.content) {
-            const contentTypeKey = resp.content["application/json"]
-                ? "application/json"
-                : Object.keys(resp.content)[0];
-            const mediaType = resp.content[contentTypeKey];
-            if (contentTypeKey)
-                result.contentType = contentTypeKey;
-            if (mediaType?.schema) {
-                const rawSchema = mediaType.schema;
-                const schema = rawSchema.type === "array" && rawSchema.items
-                    ? rawSchema.items
-                    : rawSchema;
-                result.schema = extractSchemaProperties(schema);
-                result.example = generateExampleFromSchema(rawSchema);
-            }
-        }
-        return result;
-    })
-        .sort((a, b) => a.status.localeCompare(b.status));
-}
-function generateExampleFromSchema(schema) {
-    if (!schema)
-        return undefined;
-    if (schema.example !== undefined)
-        return schema.example;
-    switch (schema.type) {
-        case "object": {
-            if (!schema.properties)
-                return {};
-            const obj = {};
-            for (const [name, prop] of Object.entries(schema.properties)) {
-                obj[name] = generateExampleFromSchema(prop);
-            }
-            return obj;
-        }
-        case "array":
-            return schema.items ? [generateExampleFromSchema(schema.items)] : [];
-        case "string": {
-            if (schema.enum)
-                return schema.enum[0];
-            if (schema.format === "date-time")
-                return "2024-01-01T00:00:00Z";
-            if (schema.format === "email")
-                return "user@example.com";
-            if (schema.format === "uri" || schema.format === "url") {
-                return "https://example.com";
-            }
-            if (schema.format === "uuid") {
-                return "550e8400-e29b-41d4-a716-446655440000";
-            }
-            if (schema.default !== undefined)
-                return schema.default;
-            return "string";
-        }
-        case "integer":
-            return schema.example ?? schema.default ?? 0;
-        case "number":
-            return schema.example ?? schema.default ?? 0.0;
-        case "boolean":
-            return schema.example ?? schema.default ?? true;
-        default:
-            return null;
-    }
-}
-function buildTagPage(tagName, tagSlug, description, ops) {
-    const tree = [
-        {
-            type: "heading",
-            props: { level: 1, id: tagSlug },
-            children: [{ type: "prose", html: escapeHtml(tagName) }],
-        },
-    ];
-    if (description) {
-        tree.push({ type: "prose", html: paragraphHtml(description) });
-    }
-    const items = ops.map((op) => ({
-        type: "list-item",
-        children: [
-            {
-                type: "prose",
-                html: `<a href="${escapeAttr(op.slug)}"><code>${op.method.toUpperCase()}</code> ${escapeHtml(op.path)}</a>${op.deprecated ? ' <span class="text-muted-foreground">(deprecated)</span>' : ""}`,
-            },
-        ],
-    }));
-    tree.push({ type: "unordered-list", children: items });
-    return {
-        slug: tagSlug,
-        title: tagName,
-        tree,
-        headings: [{ depth: 1, slug: tagSlug, text: tagName }],
-    };
-}
-function buildInfoPage(title, description, version) {
-    const tree = [
-        {
-            type: "heading",
-            props: { level: 1, id: "api-reference" },
-            children: [{ type: "prose", html: escapeHtml(title) }],
-        },
-    ];
-    if (version) {
-        tree.push({
-            type: "prose",
-            html: `<p class="text-sm text-muted-foreground">Version ${escapeHtml(version)}</p>`,
-        });
-    }
-    if (description) {
-        tree.push({ type: "prose", html: paragraphHtml(description) });
-    }
-    return {
-        slug: "index",
-        title,
-        tree,
-        headings: [{ depth: 1, slug: "api-reference", text: title }],
-    };
-}
-function buildNav(spec, pages, tagToOps, untagged, hrefPrefix) {
-    const nav = [];
-    const root = {
-        label: (spec.info && spec.info.title) || "API Reference",
-        href: hrefHref(hrefPrefix, "index"),
-    };
-    nav.push(root);
-    // Use spec.tags[] order when present so authors control nav order.
-    const declaredTagOrder = Array.isArray(spec.tags)
-        ? spec.tags.map((t) => t?.name).filter(Boolean)
-        : [];
-    const seenTags = new Set();
-    const tagOrder = [];
-    for (const t of declaredTagOrder) {
-        if (tagToOps.has(t)) {
-            tagOrder.push(t);
-            seenTags.add(t);
-        }
-    }
-    for (const t of tagToOps.keys()) {
-        if (!seenTags.has(t))
-            tagOrder.push(t);
-    }
-    for (const tagName of tagOrder) {
-        const ops = tagToOps.get(tagName) || [];
-        const tagSlug = slugifyTag(tagName);
-        nav.push({
-            label: tagName,
-            href: hrefHref(hrefPrefix, tagSlug),
-            children: ops
-                .slice()
-                .sort(byMethodThenPath)
-                .map((op) => ({
-                label: op.title,
-                href: hrefHref(hrefPrefix, op.slug),
-            })),
-        });
-    }
-    if (untagged.length > 0) {
-        nav.push({
-            label: "Other",
-            children: untagged
-                .slice()
-                .sort(byMethodThenPath)
-                .map((op) => ({
-                label: op.title,
-                href: hrefHref(hrefPrefix, op.slug),
-            })),
-        });
-    }
-    return nav;
-}
-function byMethodThenPath(a, b) {
-    const m = a.method.localeCompare(b.method);
-    if (m !== 0)
-        return m;
-    return a.path.localeCompare(b.path);
-}
-function hrefHref(prefix, slug) {
-    const p = prefix ? `${prefix}/` : "/";
-    return slug === "index" ? p : `${p}${slug}`;
-}
-function escapeHtml(s) {
-    return s
-        .replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;");
-}
-function escapeAttr(s) {
-    return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
-}
-function paragraphHtml(text) {
-    return `<p>${escapeHtml(text)}</p>`;
-}
-//# sourceMappingURL=parse.js.map

package/dist/slug.d.ts

@@ -13,4 +13,3 @@ export declare function operationToSlug(method: string, path: string, operationI
  * Tag "Pet Store" → "pet-store".
  */
 export declare function slugifyTag(tag: string): string;
-//# sourceMappingURL=slug.d.ts.map

package/dist/slug.js

@@ -38,4 +38,3 @@ export function slugifyTag(tag) {
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
-//# sourceMappingURL=slug.js.map

package/dist/spec-path.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The content-relative paths `:::openapi{spec}` on the page `slug` may mean,
+ * in the order to try them, or why it may name none.
+ *
+ * The spec path is CONTENT, so it is held to what content may name:
+ *  - a file, never a URL: a page does not get to make the build fetch;
+ *  - `.yaml`, `.yml` or `.json`;
+ *  - inside a content root (the caller checks, after resolving symlinks).
+ *
+ * A leading `/` is the content root. A relative path is tried against the
+ * page's folder, then the page's own folder for an index page (slug
+ * `reference` may be `reference/index.md`). Importers write root-relative
+ * paths, which have no such ambiguity.
+ */
+export declare function specCandidates(spec: string, slug: string): {
+    paths: string[];
+} | {
+    error: string;
+};
+/** What a lookup found at a content-relative path: the file to read, a file outside the content, or nothing. */
+export type SpecLookup = (path: string) => {
+    path: string;
+} | "outside" | undefined;
+/**
+ * The spec file `:::openapi{spec}` on the page `slug` names, or an error.
+ * `lookup` answers for one content-relative path (dogsbay-ssg: its file
+ * map; the CLI: each content root, symlinks resolved).
+ */
+export declare function findSpec(spec: string, slug: string, lookup: SpecLookup): {
+    path: string;
+} | {
+    error: string;
+};

package/dist/spec-path.js

@@ -0,0 +1,68 @@
+/**
+ * Which spec file a page's `:::openapi{spec}` may name. No dependencies, so
+ * a host can check a path without loading the spec parser
+ * (`@dogsbay/format-openapi/spec-path`); also exported from `./core`.
+ */
+const SPEC_EXT = /\.(ya?ml|json)$/i;
+/**
+ * The content-relative paths `:::openapi{spec}` on the page `slug` may mean,
+ * in the order to try them, or why it may name none.
+ *
+ * The spec path is CONTENT, so it is held to what content may name:
+ *  - a file, never a URL: a page does not get to make the build fetch;
+ *  - `.yaml`, `.yml` or `.json`;
+ *  - inside a content root (the caller checks, after resolving symlinks).
+ *
+ * A leading `/` is the content root. A relative path is tried against the
+ * page's folder, then the page's own folder for an index page (slug
+ * `reference` may be `reference/index.md`). Importers write root-relative
+ * paths, which have no such ambiguity.
+ */
+export function specCandidates(spec, slug) {
+    if (!spec)
+        return { error: "no `spec` on :::openapi" };
+    if (/^[a-z][a-z0-9+.-]*:/i.test(spec) || spec.startsWith("//")) {
+        return { error: `a page may name a spec file, not a URL (${spec})` };
+    }
+    if (/[?#]/.test(spec) || !SPEC_EXT.test(spec)) {
+        return { error: `not a .yaml, .yml or .json file (${spec})` };
+    }
+    const clean = spec.replace(/\\/g, "/");
+    if (clean.startsWith("/"))
+        return { paths: [normalizePath(clean)].filter(isContained) };
+    const dir = slug.includes("/") ? slug.slice(0, slug.lastIndexOf("/")) : "";
+    return { paths: [normalizePath(`${dir}/${clean}`), normalizePath(`${slug}/${clean}`)].filter(isContained) };
+}
+/**
+ * The spec file `:::openapi{spec}` on the page `slug` names, or an error.
+ * `lookup` answers for one content-relative path (dogsbay-ssg: its file
+ * map; the CLI: each content root, symlinks resolved).
+ */
+export function findSpec(spec, slug, lookup) {
+    const c = specCandidates(spec, slug);
+    if ("error" in c)
+        return c;
+    let escaped = c.paths.length === 0;
+    for (const p of c.paths) {
+        const found = lookup(p);
+        if (found === "outside")
+            escaped = true;
+        else if (found)
+            return found;
+    }
+    return { error: escaped ? `the spec resolves outside the content root (${spec})` : `spec not found (${spec})` };
+}
+/** `a/./b/../c` → `a/c`; a path that climbs above the root keeps its leading `..`. */
+function normalizePath(p) {
+    const out = [];
+    for (const seg of p.split("/")) {
+        if (!seg || seg === ".")
+            continue;
+        if (seg === ".." && out.length && out[out.length - 1] !== "..")
+            out.pop();
+        else
+            out.push(seg);
+    }
+    return out.join("/");
+}
+const isContained = (p) => p !== "" && p !== ".." && !p.startsWith("../");