fontconv 0.0.1

package/script/fontconv/mod.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convert = exports.filterGlyphs = exports.getFont = exports.otf2ttf = exports.isWOFF2 = exports.isWOFF = exports.isSVG = exports.isEOT = exports.isTTF = exports.isOTF = void 0;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+const wawoff2_1 = require("wawoff2");
+const opentype_js_1 = require("opentype.js");
+const mod_js_1 = require("../ttf2svg/mod.js");
+const svg2ttf_1 = __importDefault(require("svg2ttf"));
+const ttf2eot_1 = __importDefault(require("ttf2eot"));
+const ttf2woff_1 = __importDefault(require("ttf2woff"));
+// import ttf2woff2 from "npm:ttf2woff2@5.0.0";
+// import * as fonteditor from "npm:fonteditor-core@2.3.3"; // glyph names are lost
+function isOTF(uint8Array) {
+    return uint8Array[0] === 0x4F &&
+        uint8Array[1] === 0x54 &&
+        uint8Array[2] === 0x54 &&
+        uint8Array[3] === 0x4F;
+}
+exports.isOTF = isOTF;
+function isTTF(uint8Array) {
+    return uint8Array[0] === 0x00 &&
+        uint8Array[1] === 0x01 &&
+        uint8Array[2] === 0x00 &&
+        uint8Array[3] === 0x00;
+}
+exports.isTTF = isTTF;
+function isEOT(uint8Array) {
+    return uint8Array[34] === 0x4C && uint8Array[35] === 0x50;
+}
+exports.isEOT = isEOT;
+function isSVG(object) {
+    return typeof object === "string";
+}
+exports.isSVG = isSVG;
+function isWOFF(uint8Array) {
+    return uint8Array[0] === 0x77 &&
+        uint8Array[1] === 0x4F &&
+        uint8Array[2] === 0x46 &&
+        uint8Array[3] === 0x46;
+}
+exports.isWOFF = isWOFF;
+function isWOFF2(uint8Array) {
+    return uint8Array[0] === 0x77 &&
+        uint8Array[1] === 0x4F &&
+        uint8Array[2] === 0x46 &&
+        uint8Array[3] === 0x32;
+}
+exports.isWOFF2 = isWOFF2;
+// 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);
+// }
+function otf2ttf(otf) {
+    const svg = (0, mod_js_1.ttf2svgFont)(new Uint8Array(otf));
+    return (0, svg2ttf_1.default)(svg).buffer;
+}
+exports.otf2ttf = otf2ttf;
+// // 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;
+    }
+}
+async function getFont(fontContent) {
+    if (isSVG(fontContent)) {
+        const ttf = (0, svg2ttf_1.default)(fontContent);
+        return (0, opentype_js_1.parse)(ttf.buffer.buffer);
+    }
+    else if (isWOFF2(fontContent)) {
+        const data = await (0, wawoff2_1.decompress)(fontContent);
+        return (0, opentype_js_1.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 (0, opentype_js_1.parse)(fontContent.buffer);
+    }
+}
+exports.getFont = getFont;
+async function convertFormat(font, format) {
+    const svg = (0, mod_js_1.font2svgFont)(font);
+    if (format === ".svg")
+        return svg;
+    const ttf = (0, svg2ttf_1.default)(svg).buffer;
+    switch (format) {
+        case ".otf": {
+            const tempFont = (0, opentype_js_1.parse)(ttf.buffer);
+            return new Uint8Array(tempFont.toArrayBuffer());
+        }
+        case ".ttf":
+            return ttf;
+        case ".eot":
+            return (0, ttf2eot_1.default)(ttf);
+        case ".woff":
+            return (0, ttf2woff_1.default)(ttf);
+        case ".woff2":
+            // return ttf2woff2(ttf);
+            return await (0, wawoff2_1.compress)(ttf);
+        default:
+            throw new Error(`${format} is not a supported format.`);
+    }
+}
+function filterGlyphs(font, options) {
+    const glyphString = getGlyphString(options);
+    if (glyphString) {
+        return font.stringToGlyphs(glyphString);
+    }
+    else {
+        return Object.values(font.glyphs.glyphs);
+    }
+}
+exports.filterGlyphs = filterGlyphs;
+function createTemporaryFont(font, glyphs) {
+    const notdefGlyph = font.glyphs.get(0);
+    const tempFont = new opentype_js_1.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;
+}
+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);
+}
+exports.convert = convert;

package/script/fontconv/test.d.ts

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

package/script/package.json

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

package/script/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/script/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/script/ttf2svg/mod.js

@@ -0,0 +1,204 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.font2svgFont = exports.ttf2svgFont = exports.ttf2svg = exports.font2svg = exports.filterGlyphs = exports.toGlyphTag = exports.toSVGFont = exports.toSVG = exports.parse = void 0;
+const dntShim = __importStar(require("../_dnt.shims.js"));
+const opentype_js_1 = require("opentype.js");
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return opentype_js_1.parse; } });
+const svgpath_1 = __importDefault(require("svgpath"));
+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;
+}
+function toSVG(font, glyph, options = {}) {
+    const translateY = options.translateY ?? font.ascender;
+    const d = (0, svgpath_1.default)(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>";
+}
+exports.toSVG = toSVG;
+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>`;
+}
+function toSVGFont(font, glyphs, options) {
+    return glyphHeader(font) + toGlyphTag(font, glyphs, options) +
+        glyphFooter();
+}
+exports.toSVGFont = toSVGFont;
+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;
+    }
+}
+exports.toGlyphTag = toGlyphTag;
+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;
+    }
+}
+function filterGlyphs(font, options = {}) {
+    const glyphString = getGlyphString(options);
+    if (glyphString) {
+        return font.stringToGlyphs(glyphString);
+    }
+    else {
+        return Object.values(font.glyphs.glyphs);
+    }
+}
+exports.filterGlyphs = filterGlyphs;
+function font2svg(font, options) {
+    const glyphs = filterGlyphs(font, options);
+    return glyphs.map((glyph) => {
+        return toSVG(font, glyph, options);
+    });
+}
+exports.font2svg = font2svg;
+function ttf2svg(uint8array, options = {}) {
+    const font = (0, opentype_js_1.parse)(uint8array.buffer);
+    return font2svg(font, options);
+}
+exports.ttf2svg = ttf2svg;
+function ttf2svgFont(uint8array, options = {}) {
+    const font = (0, opentype_js_1.parse)(uint8array.buffer);
+    return font2svgFont(font, options);
+}
+exports.ttf2svgFont = ttf2svgFont;
+function font2svgFont(font, options = {}) {
+    const glyphs = filterGlyphs(font, options);
+    return toSVGFont(font, glyphs, options);
+}
+exports.font2svgFont = font2svgFont;