@occultist/extensions 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Matthew Quinn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/css-parser.d.ts

@@ -0,0 +1,21 @@
+import type { FilesByURL, PolicyDirective, ReferenceDetails, ReferenceParser } from "./types.js";
+import { type FileInfo } from "./file-info.ts";
+type PolicyDirectiveMap = Record<string, PolicyDirective>;
+export type CSSReferenceParserArgs = {
+    contentType?: string | string[];
+};
+export declare class CSSReferenceParser implements ReferenceParser {
+    ruleRe: RegExp;
+    urlRe: RegExp;
+    supports: Set<string>;
+    directives: PolicyDirectiveMap;
+    constructor(args?: CSSReferenceParserArgs);
+    /**
+     * Parses all references within a css document.
+     *
+     * @param content Content of a css file.
+     */
+    parse(content: Blob, file: FileInfo, filesByURL: FilesByURL): Promise<ReferenceDetails[]>;
+    update(content: Blob, file: FileInfo, filesByURL: FilesByURL): Promise<Blob>;
+}
+export {};

package/dist/css-parser.js

@@ -0,0 +1,67 @@
+const ruleRe = /(?:(\@[a-z]+)|(?:([a-z][a-z\-]*\s*):))\s*(.*);/gm;
+const urlRe = /url\(\s*(?:(?:\"(.*)\")|(?:\'(.*)\')|(.*))\s*\)/gm;
+const defaultDirectives = {
+    '@import': 'style-src',
+    'background': 'img-src',
+    'background-image': 'img-src',
+    'src': 'font-src',
+};
+export class CSSReferenceParser {
+    ruleRe = ruleRe;
+    urlRe = urlRe;
+    supports = new Set(['text/css']);
+    directives = defaultDirectives;
+    constructor(args) {
+        if (Array.isArray(args?.contentType)) {
+            this.supports = new Set(args.contentType);
+        }
+        else if (args?.contentType != null) {
+            this.supports = new Set([args.contentType]);
+        }
+    }
+    /**
+     * Parses all references within a css document.
+     *
+     * @param content Content of a css file.
+     */
+    async parse(content, file, filesByURL) {
+        let m1;
+        let m2;
+        let property;
+        let url;
+        let directive;
+        const references = [];
+        const text = await content.text();
+        this.ruleRe.lastIndex = 0;
+        while ((m1 = this.ruleRe.exec(text))) {
+            property = m1[1] ?? m1[2];
+            directive = this.directives[property];
+            if (directive == null)
+                continue;
+            this.urlRe.lastIndex = 0;
+            while ((m2 = this.urlRe.exec(m1[3]))) {
+                url = new URL(m2[1] ?? m2[2] ?? m2[3], file.aliasURL).toString();
+                references.push({
+                    url,
+                    directive,
+                    file: filesByURL.get(url),
+                });
+            }
+        }
+        return references;
+    }
+    async update(content, file, filesByURL) {
+        const text = await content.text();
+        const updated = text.replace(ruleRe, (match) => {
+            return match.replace(urlRe, (...matches) => {
+                const src = matches[1] ?? matches[2] ?? matches[3];
+                const url = new URL(src, file.aliasURL).toString();
+                const ref = filesByURL.get(url);
+                if (ref == null)
+                    return matches[0];
+                return `url(${ref.url})`;
+            });
+        });
+        return new Blob([updated], { type: file.contentType });
+    }
+}

package/dist/dependancy-graph.d.ts

@@ -0,0 +1,17 @@
+import type { FileInfo } from "./file-info.ts";
+import type { PolicyDirective, ReferenceDetails } from "./types.ts";
+export declare class DependancyMap {
+    file: FileInfo;
+    references: ReferenceDetails[];
+    polices: Map<PolicyDirective, ReferenceDetails[]>;
+    constructor(file: FileInfo, references: ReferenceDetails[]);
+    finalize(): void;
+}
+export declare class DependancyGraph {
+    dependancies: Map<string, DependancyMap>;
+    constructor(dependancies: Map<string, DependancyMap>);
+    /**
+     * Returns a debug string for this dependancy graph.
+     */
+    debug(): string;
+}

package/dist/dependancy-graph.js

@@ -0,0 +1,74 @@
+export class DependancyMap {
+    file;
+    references;
+    polices = new Map();
+    constructor(file, references) {
+        this.file = file;
+        this.references = references;
+    }
+    finalize() {
+        let reference;
+        let policies;
+        for (let i = 0; i < this.references.length; i++) {
+            reference = this.references[i];
+            policies = this.polices.get(reference.directive);
+            if (policies == null) {
+                policies = [];
+                this.polices.set(reference.directive, policies);
+            }
+            policies.push(reference);
+        }
+    }
+}
+export class DependancyGraph {
+    dependancies = new Map();
+    constructor(dependancies) {
+        this.dependancies = dependancies;
+        for (const dependancyMap of this.dependancies.values()) {
+            for (let i = 0; i < dependancyMap.references.length; i++) {
+                const reference = dependancyMap.references[i];
+                if (reference.file == null) {
+                    console.warn(`Unknown dependancy reference ${reference.url}`);
+                    continue;
+                }
+                const other = this.dependancies.get(reference.file.alias);
+                if (other == null) {
+                    continue;
+                }
+                for (let j = 0; j < other.references.length; j++) {
+                    dependancyMap.references.push(other.references[j]);
+                }
+            }
+            dependancyMap.finalize();
+        }
+        Object.freeze(this.dependancies);
+        Object.freeze(this);
+    }
+    /**
+     * Returns a debug string for this dependancy graph.
+     */
+    debug() {
+        let debug = 'Dependancy Graph\n----------------\n\n';
+        let dependancy;
+        const dependancies = Array.from(this.dependancies.values());
+        for (let i = 0; i < dependancies.length; i++) {
+            if (i !== 0)
+                debug += '\n';
+            dependancy = dependancies[i];
+            debug += dependancy.file.alias + '\n';
+            const polices = Array.from(dependancy.polices.entries());
+            if (polices.length === 0) {
+                debug += `  No dependancies\n`;
+                continue;
+            }
+            for (const [policy, references] of dependancy.polices.entries()) {
+                debug += `  ${policy}\n`;
+                for (let j = 0; j < references.length; j++) {
+                    debug += `    ${references[j].url}\n`;
+                }
+            }
+        }
+        debug += '----------------\n';
+        return debug;
+    }
+}

package/dist/file-info.d.ts

@@ -0,0 +1,97 @@
+export type FileInfo = {
+    /**
+     * The name of the file.
+     */
+    name: string;
+    /**
+     * Path of the file relative to the configured directory.
+     */
+    relativePath: string;
+    /**
+     * Full path to the file.
+     */
+    absolutePath: string;
+    /**
+     * The alias to the directory where the file is located in.
+     */
+    directoryAlias: string;
+    /**
+     * The file's extension.
+     */
+    extension: string;
+    /**
+     * The file's language if detected.
+     */
+    lang?: string;
+    /**
+     * The file's content type.
+     */
+    contentType: string;
+    /**
+     * This files directory + relative path + name.
+     */
+    alias: string;
+    /**
+     * The hash of the original file contents.
+     */
+    hash: string;
+    /**
+     * The URL of the file.
+     */
+    url: string;
+    /**
+     * alias url for this resource.
+     */
+    aliasURL: string;
+};
+/**
+ * Contains information about a static file.
+ */
+export declare class WorkingFileInfo {
+    /**
+     * The name of the file.
+     */
+    name: string;
+    /**
+     * Path of the file relative to the configured directory.
+     */
+    relativePath: string;
+    /**
+     * Full path to the file.
+     */
+    absolutePath: string;
+    /**
+     * The alias to the directory where the file is located in.
+     */
+    directoryAlias: string;
+    /**
+     * The file's extension.
+     */
+    extension: string;
+    /**
+     * The file's language if detected.
+     */
+    lang?: string;
+    /**
+     * The file's content type.
+     */
+    contentType: string;
+    /**
+     * This files directory + relative path + name.
+     */
+    alias: string;
+    /**
+     * The hash of the original file contents.
+     */
+    hash: string | null;
+    /**
+     * The URL of the file.
+     */
+    url: string | null;
+    /**
+     * alias url for this resource.
+     */
+    aliasURL: string | null;
+    constructor(name: string, directoryAlias: string, relativePath: string, absolutePath: string, extension: string, contentType: string, lang?: string);
+    finalize(hash: string, url: string, aliasURL: string): void;
+}

package/dist/file-info.js

@@ -0,0 +1,66 @@
+import { join } from "node:path";
+/**
+ * Contains information about a static file.
+ */
+export class WorkingFileInfo {
+    /**
+     * The name of the file.
+     */
+    name;
+    /**
+     * Path of the file relative to the configured directory.
+     */
+    relativePath;
+    /**
+     * Full path to the file.
+     */
+    absolutePath;
+    /**
+     * The alias to the directory where the file is located in.
+     */
+    directoryAlias;
+    /**
+     * The file's extension.
+     */
+    extension;
+    /**
+     * The file's language if detected.
+     */
+    lang;
+    /**
+     * The file's content type.
+     */
+    contentType;
+    /**
+     * This files directory + relative path + name.
+     */
+    alias;
+    /**
+     * The hash of the original file contents.
+     */
+    hash = null;
+    /**
+     * The URL of the file.
+     */
+    url = null;
+    /**
+     * alias url for this resource.
+     */
+    aliasURL = null;
+    constructor(name, directoryAlias, relativePath, absolutePath, extension, contentType, lang) {
+        this.name = name;
+        this.directoryAlias = directoryAlias;
+        this.relativePath = relativePath;
+        this.absolutePath = absolutePath;
+        this.extension = extension;
+        this.contentType = contentType;
+        this.lang = lang;
+        this.alias = join(directoryAlias, relativePath);
+    }
+    finalize(hash, url, aliasURL) {
+        this.hash = hash;
+        this.url = url;
+        this.aliasURL = aliasURL;
+        Object.freeze(this);
+    }
+}

package/dist/html-parser.d.ts

@@ -0,0 +1,11 @@
+import { type FileInfo } from "./file-info.ts";
+import type { ReferenceDetails, ReferenceParser } from "./types.ts";
+export type HTMLParserArgs = {
+    contentType?: string | string[];
+};
+export declare class HTMLParser implements ReferenceParser {
+    supports: Set<string>;
+    constructor(args?: HTMLParserArgs);
+    parse(content: Blob, file: FileInfo, filesByURL: Map<string, FileInfo>): Promise<ReferenceDetails[]>;
+    update(content: Blob, file: FileInfo, filesByURL: Map<string, FileInfo>): Promise<Blob>;
+}

package/dist/html-parser.js

@@ -0,0 +1,171 @@
+import { JSDOM } from 'jsdom';
+const asMap = {
+    audio: 'media-src',
+    document: 'frame-src',
+    embed: 'object-src',
+    fetch: 'connect-src',
+    font: 'font-src',
+    image: 'img-src',
+    object: 'object-src',
+    script: 'script-src',
+    style: 'style-src',
+    track: 'media-src',
+    video: 'media-src',
+    worker: 'worker-src',
+};
+export class HTMLParser {
+    supports = new Set([
+        'text/html',
+        'application/xhtml+xml',
+    ]);
+    constructor(args = {}) {
+        if (Array.isArray(args?.contentType)) {
+            this.supports = new Set(args.contentType);
+        }
+        else if (args?.contentType != null) {
+            this.supports = new Set([args.contentType]);
+        }
+    }
+    async parse(content, file, filesByURL) {
+        let references = [];
+        let src;
+        let rel;
+        let as;
+        let url;
+        const text = await content.text();
+        const dom = new JSDOM(text, {
+            contentType: file.contentType,
+        });
+        const document = dom.window.document;
+        for (const element of document.querySelectorAll('link')) {
+            src = element.getAttribute('src');
+            rel = element.getAttribute('rel');
+            as = element.getAttribute('as');
+            url = new URL(src, file.aliasURL).toString();
+            if (rel === 'stylesheet') {
+                references.push({
+                    url,
+                    directive: 'style-src',
+                    file: filesByURL.get(url),
+                });
+                continue;
+            }
+            if (Object.hasOwn(asMap, as)) {
+                references.push({
+                    url,
+                    directive: asMap[as],
+                    file: filesByURL.get(url),
+                });
+                continue;
+            }
+            references.push({
+                url,
+                file: filesByURL.get(url),
+            });
+        }
+        for (const element of [
+            ...document.querySelectorAll('img'),
+            ...document.querySelectorAll('picture source'),
+        ]) {
+            src = element.tagName.toLowerCase() === 'source'
+                ? element.getAttribute('srcset')
+                : element.getAttribute('src');
+            if (src == null) {
+                continue;
+            }
+            url = new URL(src, file.aliasURL).toString();
+            references.push({
+                url,
+                directive: 'img-src',
+                file: filesByURL.get(url),
+            });
+        }
+        for (const element of [
+            ...document.querySelectorAll('track'),
+            ...document.querySelectorAll('audio'),
+            ...document.querySelectorAll('video'),
+            ...document.querySelectorAll('video source'),
+        ]) {
+            src = element.getAttribute('src');
+            if (src == null) {
+                continue;
+            }
+            url = new URL(src, file.aliasURL).toString();
+            references.push({
+                url,
+                directive: 'media-src',
+                file: filesByURL.get(url),
+            });
+        }
+        for (const element of [
+            ...document.querySelectorAll('iframe'),
+            ...document.querySelectorAll('fencedframe'),
+        ]) {
+            src = element.getAttribute('src');
+            if (src == null) {
+                continue;
+            }
+            url = new URL(src, file.aliasURL).toString();
+            references.push({
+                url,
+                directive: 'child-src',
+                file: filesByURL.get(url),
+            });
+        }
+        for (const element of document.querySelectorAll('script')) {
+            src = element.getAttribute('src');
+            if (src == null) {
+                continue;
+            }
+            url = new URL(src, file.aliasURL).toString();
+            references.push({
+                url,
+                directive: 'script-src',
+                file: filesByURL.get(url),
+            });
+        }
+        return references;
+    }
+    async update(content, file, filesByURL) {
+        let url;
+        let ref;
+        let text = await content.text();
+        const dom = new JSDOM(text, {
+            contentType: file.contentType,
+        });
+        const document = dom.window.document;
+        for (const element of [
+            ...document.querySelectorAll('link'),
+            ...document.querySelectorAll('img'),
+            ...document.querySelectorAll('track'),
+            ...document.querySelectorAll('audio'),
+            ...document.querySelectorAll('video'),
+            ...document.querySelectorAll('video source'),
+            ...document.querySelectorAll('iframe'),
+            ...document.querySelectorAll('fencedframe'),
+            ...document.querySelectorAll('script'),
+        ]) {
+            const src = element.getAttribute('src');
+            if (src == null) {
+                continue;
+            }
+            url = new URL(src, file.aliasURL).toString();
+            ref = filesByURL.get(url);
+            if (ref == null)
+                continue;
+            element.setAttribute('src', ref.url);
+        }
+        for (const element of document.querySelectorAll('picture source')) {
+            const src = element.getAttribute('srcset');
+            if (src == null) {
+                continue;
+            }
+            url = new URL(src, file.aliasURL).toString();
+            ref = filesByURL.get(url);
+            if (ref == null)
+                continue;
+            element.setAttribute('srcset', ref.url);
+        }
+        return new Blob([dom.serialize()], { type: file.contentType });
+    }
+}

package/dist/js-parser.d.ts

@@ -0,0 +1,14 @@
+import { type Options } from 'acorn';
+import { type FileInfo } from "./file-info.ts";
+import type { FilesByURL, ReferenceDetails, ReferenceParser } from "./types.ts";
+export type JSReferenceParserArgs = {
+    contentType?: string | string[];
+    acornOptions?: Options;
+};
+export declare class JSReferenceParser implements ReferenceParser {
+    #private;
+    supports: Set<string>;
+    constructor(args?: JSReferenceParserArgs);
+    parse(content: Blob, file: FileInfo, filesByURL: FilesByURL): Promise<ReferenceDetails[]>;
+    update(content: Blob, file: FileInfo, filesByURL: Map<string, FileInfo>): Promise<Blob>;
+}

package/dist/js-parser.js

@@ -0,0 +1,74 @@
+import { parse } from 'acorn';
+import { generate } from 'astring';
+import { walk } from 'zimmerframe';
+export class JSReferenceParser {
+    supports = new Set(['application/javascript']);
+    #acornOptions;
+    constructor(args = {}) {
+        if (Array.isArray(args?.contentType)) {
+            this.supports = new Set(args.contentType);
+        }
+        else if (args?.contentType != null) {
+            this.supports = new Set([args.contentType]);
+        }
+        this.#acornOptions = args.acornOptions ?? {
+            ecmaVersion: 'latest',
+            sourceType: 'module',
+        };
+    }
+    async parse(content, file, filesByURL) {
+        let references = [];
+        let url;
+        const text = await content.text();
+        const ast = parse(text, this.#acornOptions);
+        walk(ast, {}, {
+            ImportDeclaration(node, { next }) {
+                url = new URL(node.source.value, file.aliasURL).toString();
+                references.push({
+                    url,
+                    directive: 'script-src',
+                    file: filesByURL.get(url),
+                });
+                next();
+            },
+            ImportExpression(node, { next }) {
+                url = new URL(node.source.value, file.aliasURL).toString();
+                references.push({
+                    url,
+                    directive: 'script-src',
+                    file: filesByURL.get(url),
+                });
+                next();
+            },
+        });
+        return references;
+    }
+    async update(content, file, filesByURL) {
+        let url;
+        let ref;
+        const text = await content.text();
+        const ast = parse(text, this.#acornOptions);
+        const updated = walk(ast, {}, {
+            ImportDeclaration(node, { next }) {
+                url = new URL(node.source.value, file.aliasURL).toString();
+                ref = filesByURL.get(url);
+                if (ref == null)
+                    return;
+                const source = node.source;
+                source.raw = '"' + encodeURI(ref.url) + '"';
+                next();
+            },
+            ImportExpression(node, { next }) {
+                url = new URL(node.source.value, file.aliasURL).toString();
+                ref = filesByURL.get(url);
+                if (ref == null)
+                    return;
+                const source = node.source;
+                source.raw = '"' + encodeURI(ref.url) + '"';
+                next();
+            },
+        });
+        const serialized = generate(updated);
+        return new Blob([serialized], { type: file.contentType });
+    }
+}