fontconv 0.0.1

package/esm/fontconv/mod.js

@@ -0,0 +1,147 @@
+import * as dntShim from "../_dnt.shims.js";
+import { compress, decompress } from "wawoff2";
+import { Font, parse } from "opentype.js";
+import { font2svgFont, ttf2svgFont } from "../ttf2svg/mod.js";
+import svg2ttf from "svg2ttf";
+import ttf2eot from "ttf2eot";
+import ttf2woff from "ttf2woff";
+// import ttf2woff2 from "npm:ttf2woff2@5.0.0";
+// import * as fonteditor from "npm:fonteditor-core@2.3.3"; // glyph names are lost
+export function isOTF(uint8Array) {
+    return uint8Array[0] === 0x4F &&
+        uint8Array[1] === 0x54 &&
+        uint8Array[2] === 0x54 &&
+        uint8Array[3] === 0x4F;
+}
+export function isTTF(uint8Array) {
+    return uint8Array[0] === 0x00 &&
+        uint8Array[1] === 0x01 &&
+        uint8Array[2] === 0x00 &&
+        uint8Array[3] === 0x00;
+}
+export function isEOT(uint8Array) {
+    return uint8Array[34] === 0x4C && uint8Array[35] === 0x50;
+}
+export function isSVG(object) {
+    return typeof object === "string";
+}
+export function isWOFF(uint8Array) {
+    return uint8Array[0] === 0x77 &&
+        uint8Array[1] === 0x4F &&
+        uint8Array[2] === 0x46 &&
+        uint8Array[3] === 0x46;
+}
+export function isWOFF2(uint8Array) {
+    return uint8Array[0] === 0x77 &&
+        uint8Array[1] === 0x4F &&
+        uint8Array[2] === 0x46 &&
+        uint8Array[3] === 0x32;
+}
+// glyph names are lost
+//   difficult: OTF --> TTF
+//   easy:      OTF --> SVG --> TTF
+// export function otf2ttf(otf) {
+//   const ttfObj = fonteditor.default.otf2ttfobject(otf);
+//   const ttfBuffer = new fonteditor.default.TTFWriter().write(ttfObj);
+//   return new Uint8Array(ttfBuffer);
+// }
+export function otf2ttf(otf) {
+    const svg = ttf2svgFont(new Uint8Array(otf));
+    return svg2ttf(svg).buffer;
+}
+// // TODO: not work
+// export function eot2ttf(eot) {
+//   const ttfObj = fonteditor.default.eot2ttf(eot.buffer);
+//   const ttfBuffer = new fonteditor.default.TTFWriter().write(ttfObj);
+//   return new Uint8Array(ttfBuffer);
+// }
+function getGlyphString(options) {
+    if (options.textFile) {
+        const text = dntShim.Deno.readTextFileSync(options.textFile);
+        return text.trimEnd().replace(/\n/g, "");
+    }
+    else if (options.codeFile) {
+        const text = dntShim.Deno.readTextFileSync(options.codeFile);
+        return text.trimEnd().split("\n")
+            .map((line) => String.fromCodePoint(Number(line))).join("");
+    }
+    else if (options.text) {
+        return options.text;
+    }
+    else if (options.code) {
+        return options.code.split(",")
+            .map((code) => String.fromCodePoint(Number(code))).join("");
+    }
+    else {
+        return undefined;
+    }
+}
+export async function getFont(fontContent) {
+    if (isSVG(fontContent)) {
+        const ttf = svg2ttf(fontContent);
+        return parse(ttf.buffer.buffer);
+    }
+    else if (isWOFF2(fontContent)) {
+        const data = await decompress(fontContent);
+        return parse(Uint8Array.from(data).buffer);
+    }
+    else if (isEOT(fontContent)) {
+        // const ttf = eot2ttf(fontContent);
+        // return parse(ttf.buffer);
+        throw new Error(".eot format input is no supported.");
+    }
+    else {
+        return parse(fontContent.buffer);
+    }
+}
+async function convertFormat(font, format) {
+    const svg = font2svgFont(font);
+    if (format === ".svg")
+        return svg;
+    const ttf = svg2ttf(svg).buffer;
+    switch (format) {
+        case ".otf": {
+            const tempFont = parse(ttf.buffer);
+            return new Uint8Array(tempFont.toArrayBuffer());
+        }
+        case ".ttf":
+            return ttf;
+        case ".eot":
+            return ttf2eot(ttf);
+        case ".woff":
+            return ttf2woff(ttf);
+        case ".woff2":
+            // return ttf2woff2(ttf);
+            return await compress(ttf);
+        default:
+            throw new Error(`${format} is not a supported format.`);
+    }
+}
+export function filterGlyphs(font, options) {
+    const glyphString = getGlyphString(options);
+    if (glyphString) {
+        return font.stringToGlyphs(glyphString);
+    }
+    else {
+        return Object.values(font.glyphs.glyphs);
+    }
+}
+function createTemporaryFont(font, glyphs) {
+    const notdefGlyph = font.glyphs.get(0);
+    const tempFont = new Font({
+        familyName: font.names.fontFamily.en,
+        styleName: font.names.fontSubfamily.en,
+        unitsPerEm: font.unitsPerEm,
+        ascender: font.ascender,
+        descender: font.descender,
+        glyphs: [notdefGlyph, ...glyphs],
+    });
+    tempFont.names = font.names;
+    return tempFont;
+}
+export async function convert(fontContent, format, options) {
+    const font = await getFont(fontContent);
+    const glyphs = filterGlyphs(font, options);
+    const tempFont = createTemporaryFont(font, glyphs);
+    return await convertFormat(tempFont, format);
+}

package/esm/fontconv/test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/test/format-check.svg

@@ -0,0 +1,25 @@
+<svg xmlns="http://www.w3.org/2000/svg">
+<!--
+ 
+ 
+ 
+ 
+  -->
+
+  <defs>
+    <font name="Material Icons Regular"
+      horiz-adv-x="512" vert-adv-y="512" >
+    <font-face font-family="Material Icons" font-weight="400"
+      font-stretch="normal"
+      units-per-em="512"
+      ascent="512"
+      descent="0"/>
+<glyph glyph-name=".notdef" unicode="&#59530;"
+      horiz-adv-x="512" vert-adv-y="512"
+      d="M213 213L213 85L107 85L107 256L43 256L256 448L469 256L405 256L405 85L299 85L299 213L213 213Z"/>
+<missing-glyph glyph-name=".notdef"
+      horiz-adv-x="512" vert-adv-y="512"
+      d="M213 213L213 85L107 85L107 256L43 256L256 448L469 256L405 256L405 85L299 85L299 213L213 213Z"/>
+    </font>
+  </defs>
+</svg>

package/esm/ttf2svg/mod.d.ts

@@ -0,0 +1,9 @@
+export function toSVG(font: any, glyph: any, options?: {}): string | undefined;
+export function toSVGFont(font: any, glyphs: any, options: any): string;
+export function toGlyphTag(font: any, glyphs: any, options: any): any;
+export function filterGlyphs(font: any, options?: {}): any;
+export function font2svg(font: any, options: any): any;
+export function ttf2svg(uint8array: any, options?: {}): any;
+export function ttf2svgFont(uint8array: any, options?: {}): string;
+export function font2svgFont(font: any, options?: {}): string;
+export { parse };

package/esm/ttf2svg/mod.js

@@ -0,0 +1,167 @@
+import * as dntShim from "../_dnt.shims.js";
+import { parse } from "opentype.js";
+import svgpath from "svgpath";
+export { parse };
+function calcLineSpace(font) {
+    const lineGap = font.tables.hhea?.lineGap ?? 0;
+    return font.ascender - font.descender + lineGap;
+}
+function svgHeader(font, glyph, options = {}) {
+    const widthAttribute = (options.width) ? `width="${options.width}"` : "";
+    const heightAttribute = (options.height) ? `height="${options.height}"` : "";
+    const glyphWidth = glyph.advanceWidth;
+    const glyphHeight = options.glyphHeight ?? calcLineSpace(font);
+    const copyright = fontToCopyright(font);
+    let svg = `<svg xmlns="http://www.w3.org/2000/svg"
+  ${widthAttribute} ${heightAttribute} viewBox="0 0 ${glyphWidth} ${glyphHeight}">
+`;
+    if (copyright != "") {
+        svg += `  <!--
+${copyright}
+  -->
+`;
+    }
+    return svg;
+}
+export function toSVG(font, glyph, options = {}) {
+    const translateY = options.translateY ?? font.ascender;
+    const d = svgpath(glyph.path.toPathData())
+        .scale(1, -1)
+        .translate(0, Number(translateY))
+        .toString();
+    if (d == "")
+        return undefined;
+    const path = `<path d="${d}"/>`;
+    return svgHeader(font, glyph, options) + path + "\n</svg>";
+}
+function getInfo(hash) {
+    if (!hash)
+        return "";
+    const arr = Object.values(hash);
+    if (arr.length > 0) {
+        return arr[0];
+    }
+    else {
+        return "";
+    }
+}
+function fontToCopyright(font) {
+    const copyrights = font.names.copyright
+        ? Object.values(font.names.copyright).join("\n")
+        : "";
+    const trademarks = font.names.trademark
+        ? Object.values(font.names.trademark).join("\n")
+        : "";
+    const licenses = font.names.license
+        ? Object.values(font.names.license).join("\n")
+        : "";
+    const licenseURLs = font.names.licenseURL
+        ? Object.values(font.names.licenseURL).join("\n")
+        : "";
+    const infos = [copyrights, trademarks, licenses, licenseURLs];
+    return infos.filter((info) => info).join("\n");
+}
+function glyphHeader(font) {
+    let header = `<svg xmlns="http://www.w3.org/2000/svg">
+`;
+    const copyright = fontToCopyright(font);
+    if (copyright != "") {
+        header += `<!--
+${copyright}
+  -->
+`;
+    }
+    header += `
+  <defs>
+    <font name="${getInfo(font.names.fullName)}"
+      horiz-adv-x="${font.unitsPerEm}" vert-adv-y="${font.unitsPerEm}" >
+    <font-face font-family="${getInfo(font.names.fontFamily)}" font-weight="400"
+      font-stretch="normal"
+      units-per-em="${font.unitsPerEm}"
+      ascent="${font.ascender}"
+      descent="${font.descender}"/>
+`;
+    return header;
+}
+function glyphFooter() {
+    return `
+    </font>
+  </defs>
+</svg>`;
+}
+export function toSVGFont(font, glyphs, options) {
+    return glyphHeader(font) + toGlyphTag(font, glyphs, options) +
+        glyphFooter();
+}
+export function toGlyphTag(font, glyphs, options) {
+    const lineGap = font.tables.hhea?.lineGap ?? 0;
+    const height = font.ascender - font.descender + lineGap;
+    const existed = glyphs.filter((glyph) => glyph.unicode).map((glyph) => {
+        const d = glyph.path.toPathData();
+        if (d == "")
+            return undefined;
+        const glyphName = (glyph.name) ? `glyph-name="${glyph.name}"` : "";
+        return `<glyph ${glyphName} unicode="&#${glyph.unicode};"
+      horiz-adv-x="${glyph.advanceWidth}" vert-adv-y="${height}"
+      d="${d}"/>`;
+    }).filter((glyphTag) => glyphTag).join("\n");
+    if (options.removeNotdef) {
+        return existed;
+    }
+    else {
+        const notdefGlyph = font.glyphs.get(0);
+        const d = notdefGlyph.path.toPathData();
+        const notDef = `<missing-glyph glyph-name=".notdef"
+      horiz-adv-x="${notdefGlyph.advanceWidth}" vert-adv-y="${height}"
+      d="${d}"/>`;
+        return existed + "\n" + notDef;
+    }
+}
+function getGlyphString(options = {}) {
+    if (options.textFile) {
+        const text = dntShim.Deno.readTextFileSync(options.textFile);
+        return text.trimEnd().replace(/\n/g, "");
+    }
+    else if (options.codeFile) {
+        const text = dntShim.Deno.readTextFileSync(options.codeFile);
+        return text.trimEnd().split("\n")
+            .map((line) => String.fromCodePoint(Number(line))).join("");
+    }
+    else if (options.text) {
+        return options.text;
+    }
+    else if (options.code) {
+        return options.code.split(",")
+            .map((code) => String.fromCodePoint(Number(code))).join("");
+    }
+    else {
+        return undefined;
+    }
+}
+export function filterGlyphs(font, options = {}) {
+    const glyphString = getGlyphString(options);
+    if (glyphString) {
+        return font.stringToGlyphs(glyphString);
+    }
+    else {
+        return Object.values(font.glyphs.glyphs);
+    }
+}
+export function font2svg(font, options) {
+    const glyphs = filterGlyphs(font, options);
+    return glyphs.map((glyph) => {
+        return toSVG(font, glyph, options);
+    });
+}
+export function ttf2svg(uint8array, options = {}) {
+    const font = parse(uint8array.buffer);
+    return font2svg(font, options);
+}
+export function ttf2svgFont(uint8array, options = {}) {
+    const font = parse(uint8array.buffer);
+    return font2svgFont(font, options);
+}
+export function font2svgFont(font, options = {}) {
+    const glyphs = filterGlyphs(font, options);
+    return toSVGFont(font, glyphs, options);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "fontconv",
+  "version": "0.0.1",
+  "description": "Convert and compress fonts (.ttf, .otf, .eot, .svg, .woff, .woff2).",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/marmooo/fontconv/repo.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/marmooo/fontconv/issues"
+  },
+  "main": "./script/fontconv/mod.js",
+  "module": "./esm/fontconv/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/fontconv/mod.js",
+      "require": "./script/fontconv/mod.js"
+    }
+  },
+  "scripts": {
+    "test": "node test_runner.js"
+  },
+  "bin": {
+    "fontconv": "./esm/fontconv/cli.js"
+  },
+  "dependencies": {
+    "commander": "12.0.0",
+    "opentype.js": "1.3.4",
+    "svg2ttf": "6.0.3",
+    "svgpath": "2.6.0",
+    "ttf2eot": "3.1.0",
+    "ttf2woff": "3.0.0",
+    "wawoff2": "2.0.1",
+    "@deno/shim-deno": "~0.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.9.0",
+    "picocolors": "^1.0.0"
+  },
+  "_generatedBy": "dnt@0.40.0"
+}

package/script/_dnt.shims.d.ts

@@ -0,0 +1,5 @@
+import { Deno } from "@deno/shim-deno";
+export { Deno } from "@deno/shim-deno";
+export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
+    Deno: typeof Deno;
+};

package/script/_dnt.shims.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = exports.Deno = void 0;
+const shim_deno_1 = require("@deno/shim-deno");
+var shim_deno_2 = require("@deno/shim-deno");
+Object.defineProperty(exports, "Deno", { enumerable: true, get: function () { return shim_deno_2.Deno; } });
+const dntGlobals = {
+    Deno: shim_deno_1.Deno,
+};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/deps/deno.land/std@0.221.0/assert/assert.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example
+ * ```ts
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ */
+export declare function assert(expr: unknown, msg?: string): asserts expr;

package/script/deps/deno.land/std@0.221.0/assert/assert.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = void 0;
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+const assertion_error_js_1 = require("./assertion_error.js");
+/**
+ * Make an assertion, error will be thrown if `expr` does not have truthy value.
+ *
+ * @example
+ * ```ts
+ * import { assert } from "https://deno.land/std@$STD_VERSION/assert/assert.ts";
+ *
+ * assert("hello".includes("ello")); // Doesn't throw
+ * assert("hello".includes("world")); // Throws
+ * ```
+ */
+function assert(expr, msg = "") {
+    if (!expr) {
+        throw new assertion_error_js_1.AssertionError(msg);
+    }
+}
+exports.assert = assert;

package/script/deps/deno.land/std@0.221.0/assert/assertion_error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example
+ * ```ts
+ * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
+ *
+ * throw new AssertionError("Assertion failed");
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message: string);
+}

package/script/deps/deno.land/std@0.221.0/assert/assertion_error.js

@@ -0,0 +1,22 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssertionError = void 0;
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example
+ * ```ts
+ * import { AssertionError } from "https://deno.land/std@$STD_VERSION/assert/assertion_error.ts";
+ *
+ * throw new AssertionError("Assertion failed");
+ * ```
+ */
+class AssertionError extends Error {
+    /** Constructs a new instance. */
+    constructor(message) {
+        super(message);
+        this.name = "AssertionError";
+    }
+}
+exports.AssertionError = AssertionError;

package/script/deps/deno.land/std@0.221.0/path/_common/assert_path.d.ts

@@ -0,0 +1 @@
+export declare function assertPath(path?: string): void;

package/script/deps/deno.land/std@0.221.0/path/_common/assert_path.js

@@ -0,0 +1,11 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPath = void 0;
+function assertPath(path) {
+    if (typeof path !== "string") {
+        throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`);
+    }
+}
+exports.assertPath = assertPath;

package/script/deps/deno.land/std@0.221.0/path/_common/basename.d.ts

@@ -0,0 +1,3 @@
+export declare function stripSuffix(name: string, suffix: string): string;
+export declare function lastPathSegment(path: string, isSep: (char: number) => boolean, start?: number): string;
+export declare function assertArgs(path: string, suffix: string): string | undefined;

package/script/deps/deno.land/std@0.221.0/path/_common/basename.js

@@ -0,0 +1,46 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertArgs = exports.lastPathSegment = exports.stripSuffix = void 0;
+const assert_path_js_1 = require("./assert_path.js");
+function stripSuffix(name, suffix) {
+    if (suffix.length >= name.length) {
+        return name;
+    }
+    const lenDiff = name.length - suffix.length;
+    for (let i = suffix.length - 1; i >= 0; --i) {
+        if (name.charCodeAt(lenDiff + i) !== suffix.charCodeAt(i)) {
+            return name;
+        }
+    }
+    return name.slice(0, -suffix.length);
+}
+exports.stripSuffix = stripSuffix;
+function lastPathSegment(path, isSep, start = 0) {
+    let matchedNonSeparator = false;
+    let end = path.length;
+    for (let i = path.length - 1; i >= start; --i) {
+        if (isSep(path.charCodeAt(i))) {
+            if (matchedNonSeparator) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (!matchedNonSeparator) {
+            matchedNonSeparator = true;
+            end = i + 1;
+        }
+    }
+    return path.slice(start, end);
+}
+exports.lastPathSegment = lastPathSegment;
+function assertArgs(path, suffix) {
+    (0, assert_path_js_1.assertPath)(path);
+    if (path.length === 0)
+        return path;
+    if (typeof suffix !== "string") {
+        throw new TypeError(`Suffix must be a string. Received ${JSON.stringify(suffix)}`);
+    }
+}
+exports.assertArgs = assertArgs;

package/script/deps/deno.land/std@0.221.0/path/_common/common.d.ts

@@ -0,0 +1 @@
+export declare function _common(paths: string[], sep: string): string;

package/script/deps/deno.land/std@0.221.0/path/_common/common.js

@@ -0,0 +1,27 @@
+"use strict";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._common = void 0;
+function _common(paths, sep) {
+    const [first = "", ...remaining] = paths;
+    const parts = first.split(sep);
+    let endOfPrefix = parts.length;
+    let append = "";
+    for (const path of remaining) {
+        const compare = path.split(sep);
+        if (compare.length <= endOfPrefix) {
+            endOfPrefix = compare.length;
+            append = "";
+        }
+        for (let i = 0; i < endOfPrefix; i++) {
+            if (compare[i] !== parts[i]) {
+                endOfPrefix = i;
+                append = i === 0 ? "" : sep;
+                break;
+            }
+        }
+    }
+    return parts.slice(0, endOfPrefix).join(sep) + append;
+}
+exports._common = _common;