From ecf85368666fc47273cef6d23e69d12ffd682a59 Mon Sep 17 00:00:00 2001 From: be5invis Date: Sat, 25 Apr 2020 20:39:26 -0700 Subject: [PATCH 1/4] Remove `aalt` from Gothic/UI --- make/common/gc.js | 51 ++++++++++++++++++++++++++++++++++++++++++++ make/punct/as.js | 2 ++ make/punct/common.js | 2 +- make/punct/ws.js | 2 ++ verdafile.js | 20 ++++++++--------- 5 files changed, 65 insertions(+), 12 deletions(-) diff --git a/make/common/gc.js b/make/common/gc.js index b56f2a5cf..966bc412a 100644 --- a/make/common/gc.js +++ b/make/common/gc.js @@ -1,6 +1,8 @@ "use strict"; module.exports = function gcFont(font, cfg) { + markSweepOtl(font.GSUB); + markSweepOtl(font.GPOS); const sink = mark(font, cfg); sweep(font, sink); }; @@ -57,6 +59,55 @@ function mark(font, cfg) { return sink; } +function markSweepOtl(table) { + if (!table || !table.features || !table.lookups) return; + const accessibleLookupsIds = new Set(); + markLookups(table, accessibleLookupsIds); + + let lookups1 = {}; + for (const l in table.lookups) { + if (accessibleLookupsIds.has(l)) lookups1[l] = table.lookups[l]; + } + table.lookups = lookups1; + + let features1 = {}; + for (let f in table.features) { + const feature = table.features[f]; + if (!feature) continue; + const featureFiltered = []; + for (const l of feature) if (accessibleLookupsIds.has(l)) featureFiltered.push(l); + if (!featureFiltered.length) continue; + features1[f] = featureFiltered; + } + table.features = features1; +} +function markLookups(gsub, sink) { + if (!gsub || !gsub.features) return; + for (let f in gsub.features) { + const feature = gsub.features[f]; + if (!feature) continue; + for (const l of feature) sink.add(l); + } + let loop = 0, + lookupSetChanged = false; + do { + lookupSetChanged = false; + let sizeBefore = sink.size; + for (const l of Array.from(sink)) { + const lookup = gsub.lookups[l]; + if (!lookup || !lookup.subtables) continue; + if (lookup.type === "gsub_chaining" || lookup.type === "gpos_chaining") { + for (let st of lookup.subtables) { + if (!st || !st.apply) continue; + for (const app of st.apply) sink.add(app.lookup); + } + } + } + loop++; + lookupSetChanged = sizeBefore !== sink.size; + } while (loop < 0xff && lookupSetChanged); +} + function markSubtable(sink, type, st, cfg) { switch (type) { case "gsub_single": diff --git a/make/punct/as.js b/make/punct/as.js index 6c7733522..161b87b40 100644 --- a/make/punct/as.js +++ b/make/punct/as.js @@ -15,6 +15,7 @@ const { removeDashCcmp, aliasFeatMap } = require("./common"); +const gc = require("../common/gc"); module.exports = async function makeFont(ctx, config, argv) { const a = await ctx.run(introduce, "a", { @@ -41,6 +42,7 @@ module.exports = async function makeFont(ctx, config, argv) { } removeUnusedFeatures(ctx.items.a, argv.mono); aliasFeatMap(ctx.items.a, "vert", [[0x2014, 0x2015]]); + gc(ctx.items.a); await ctx.run(build, "a", { to: argv.o, optimize: true }); ctx.remove("a"); diff --git a/make/punct/common.js b/make/punct/common.js index 8df97daa4..b6725a745 100644 --- a/make/punct/common.js +++ b/make/punct/common.js @@ -108,6 +108,7 @@ function removeUnusedFeature(table, tag) { } exports.removeUnusedFeatures = function (a, mono) { + removeUnusedFeature(a.GSUB, "aalt"); removeUnusedFeature(a.GSUB, "pwid"); removeUnusedFeature(a.GSUB, "fwid"); removeUnusedFeature(a.GSUB, "hwid"); @@ -115,7 +116,6 @@ exports.removeUnusedFeatures = function (a, mono) { removeUnusedFeature(a.GSUB, "qwid"); if (mono) { - removeUnusedFeature(a.GSUB, "aalt"); removeUnusedFeature(a.GSUB, "locl"); removeUnusedFeature(a.GPOS, "kern"); removeUnusedFeature(a.GPOS, "vkrn"); diff --git a/make/punct/ws.js b/make/punct/ws.js index 45a8e47b5..b255603a8 100644 --- a/make/punct/ws.js +++ b/make/punct/ws.js @@ -9,6 +9,7 @@ const { filterUnicodeRange } = require("../common/unicode-kind"); const { sanitizeSymbols, removeUnusedFeatures, toPWID } = require("./common"); +const gc = require("../common/gc"); module.exports = async function makeFont(ctx, config, argv) { const a = await ctx.run(introduce, "a", { @@ -33,6 +34,7 @@ module.exports = async function makeFont(ctx, config, argv) { await ctx.run(manip.glyph, "a", sanitizeSymbols, argv.type); } removeUnusedFeatures(ctx.items.a); + gc(ctx.items.a); await ctx.run(build, "a", { to: argv.o, optimize: true }); ctx.remove("a"); diff --git a/verdafile.js b/verdafile.js index 03ab27ac1..954263e8d 100644 --- a/verdafile.js +++ b/verdafile.js @@ -246,6 +246,9 @@ const Pass1 = file.make( } ); +task("pass1-mono-sc-regular", t => t.need(Pass1("mono", "sc", "regular"))); +task("pass1-gothic-sc-regular", t => t.need(Pass1("gothic", "sc", "regular"))); + const Kanji0 = file.make( (region, style) => `${BUILD}/kanji0/${region}-${style}.ttf`, async (t, { full, dir, name }, region, style) => { @@ -459,27 +462,22 @@ function* InstrParams(otds) { // TTC building const TTCFile = file.make( style => `${OUT}/ttc/${PREFIX}-${style}.ttc`, - async (t, { full, dir }, style) => { + async (t, out, style) => { const [config] = await t.need(Config, de`${OUT}/ttc`); - let requirements = [], - n = 0; + let requirements = []; for (let family of config.familyOrder) { for (let region of config.subfamilyOrder) { - requirements.push({ - from: Prod(family, region, style), - otd: `${OUT}/ttc/${PREFIX}-${style}-parts.${n}.otd`, - ttf: `${OUT}/ttc/${PREFIX}-${style}-parts.${n}.ttf` - }); - n++; + requirements.push(Prod(family, region, style)); } } - const [$$] = await t.need(requirements.map(t => t.from)); + const [$$] = await t.need(requirements); + await rm(out.full); await run( TTCIZE, ["-x", "--common-width", 1000, "--common-height", 1000], - ["-o", full], + ["-o", out.full], [...$$.map(t => t.full)] ); } From 4d50bc52ca9a2fb13a13819f81f57e72e8c879d5 Mon Sep 17 00:00:00 2001 From: be5invis Date: Mon, 4 May 2020 21:17:43 -0700 Subject: [PATCH 2/4] Make CMAP in TTCs more efficient (#153,#157) --- .eslintrc.json | 1 - .npmrc | 1 + make/common/unicode-kind.js | 9 +++++---- make/pass1/build.js | 2 +- make/pass2/build.js | 8 +++++++- package.json | 2 +- run.js | 20 +++----------------- verdafile.js | 20 ++------------------ 8 files changed, 20 insertions(+), 43 deletions(-) create mode 100644 .npmrc diff --git a/.eslintrc.json b/.eslintrc.json index 1d174dea6..4d19eb648 100644 --- a/.eslintrc.json +++ b/.eslintrc.json @@ -15,7 +15,6 @@ "rules": { "indent": ["error", "tab", { "SwitchCase": 1 }], "linebreak-style": ["error", "windows"], - "quotes": ["error", "double", { "allowTemplateLiterals": true }], "semi": ["error", "always"], "no-var": "error", "no-console": 0, diff --git a/.npmrc b/.npmrc new file mode 100644 index 000000000..9cf949503 --- /dev/null +++ b/.npmrc @@ -0,0 +1 @@ +package-lock=false \ No newline at end of file diff --git a/make/common/unicode-kind.js b/make/common/unicode-kind.js index 28130a426..ffbe29101 100644 --- a/make/common/unicode-kind.js +++ b/make/common/unicode-kind.js @@ -1,11 +1,12 @@ "use strict"; -exports.isIdeograph = function(c) { +exports.isIdeograph = function (c) { return ( (c >= 0x2e80 && c <= 0x2fff) || // CJK radicals (c >= 0x3192 && c <= 0x319f) || // Ideographic annotation (c >= 0x31c0 && c <= 0x31ef) || // CJK strokes - (c >= 0x3300 && c <= 0x9fff) || // BMP ideographs + (c >= 0x3400 && c <= 0x4dbf) || // ExtA + (c >= 0x4e00 && c <= 0x9fff) || // URO (c >= 0xf900 && c <= 0xfa6f) || // CJK compatibility ideographs (c >= 0x20000 && c <= 0x3ffff) // SIP, TIP ); @@ -23,11 +24,11 @@ exports.isKorean = c => (c >= 0xa960 && c <= 0xa97f) || (c >= 0xd7b0 && c <= 0xd7ff); -exports.isWS = function(c, _isType = false, isTerm = false) { +exports.isWS = function (c, _isType = false, isTerm = false) { return c >= (isTerm ? 0x2000 : 0x20a0) && c < 0x3000 && !(c >= 0x2e3a && c <= 0x2e3b); }; -exports.filterUnicodeRange = function(a, fn) { +exports.filterUnicodeRange = function (a, fn) { for (let c in a.cmap) { if (!fn(c - 0)) a.cmap[c] = null; } diff --git a/make/pass1/build.js b/make/pass1/build.js index 385c87fb1..258204eb8 100644 --- a/make/pass1/build.js +++ b/make/pass1/build.js @@ -99,7 +99,7 @@ async function pass(ctx, config, argv) { if (argv.italize) italize(a, +10); gc(ctx.items.a); - await ctx.run(build, "a", { to: config.o, optimize: true }); + await ctx.run(build, "a", { to: config.o }); } module.exports = async function makeFont(ctx, config, argv) { diff --git a/make/pass2/build.js b/make/pass2/build.js index 2778accb6..2da2467f2 100644 --- a/make/pass2/build.js +++ b/make/pass2/build.js @@ -30,5 +30,11 @@ module.exports = async function makeFont(ctx, config, argv) { shareFeatures(ctx.items.a.GSUB); shareFeatures(ctx.items.a.GPOS); gc(ctx.items.a); - await ctx.run(build, "a", { to: argv.o, optimize: true }); + + // This will make the order of glyphs in TTC less mangled + ctx.items.a.glyf.__glyf_pad = { advanceWidth: 0, contours: [[{ x: 0, y: 0, on: true }]] }; + if (ctx.items.a.glyph_order) { + ctx.items.a.glyph_order = [ctx.items.a.glyph_order[0], "__glyf_pad"]; + } + await ctx.run(build, "a", { to: argv.o }); }; diff --git a/package.json b/package.json index a075e0cf4..43fd1c07c 100644 --- a/package.json +++ b/package.json @@ -11,7 +11,7 @@ "colors": "^1.4.0", "fs-extra": "^8.1.0", "megaminx": "^0.9.0", - "otfcc-ttcize": "^0.9.6", + "otfcc-ttcize": "^0.10.0", "verda": "^1.0.0-10", "which": "^2.0.2", "yargs": "^15.3.0" diff --git a/run.js b/run.js index 0ee17c0a9..deaaa9eb4 100644 --- a/run.js +++ b/run.js @@ -1,27 +1,13 @@ "use strict"; -const argv = require("yargs").argv; const path = require("path"); const { Workflow } = require("megaminx"); -function toSet(a) { - let o = {}; - for (let k of a) { - o[k] = true; - } - return o; -} - -const main = async function() { - const recipePath = path.resolve(argv.recipe); +module.exports = async function (recipeArg, args) { + const recipePath = path.resolve(recipeArg); const recipe = require(recipePath); const config = {}; const flow = new Workflow(config); - await flow.run(recipe, config, argv); + await flow.run(recipe, config, args); }; - -main().catch(function(e) { - console.error(e); - process.exit(1); -}); diff --git a/verdafile.js b/verdafile.js index 954263e8d..b71b4a0c2 100644 --- a/verdafile.js +++ b/verdafile.js @@ -3,7 +3,7 @@ const build = require("verda").create(); const { task, file, oracle, phony, computed } = build.ruleTypes; const { de, fu } = build.rules; -const { run, rm, cd, mv, cp } = build.actions; +const { run, node, rm, cd, mv, cp } = build.actions; const { FileList } = build.predefinedFuncs; const fs = require("fs-extra"); @@ -526,24 +526,8 @@ async function OtfccBuildAsIs(from, to) { await run(OTFCCBUILD, from, [`-o`, to], [`-k`, `-s`, `--keep-average-char-width`, `-q`]); await rm(from); } - async function RunFontBuildTask(recipe, args) { - return await run(NODEJS, "run", "--recipe", recipe, ...objToArgs(args)); -} -function objToArgs(o) { - let a = []; - for (let k in o) { - if (o[k] === false) continue; - if (k.length === 1) { - a.push("-" + k); - } else { - a.push("--" + k); - } - if (o[k] !== true) { - a.push("" + o[k]); - } - } - return a; + return await node("./run", recipe, args); } function deItalizedNameOf(config, set) { From ef978f5d75462855bfb4fb615ad567b48081b1fd Mon Sep 17 00:00:00 2001 From: be5invis Date: Mon, 4 May 2020 23:46:02 -0700 Subject: [PATCH 3/4] Add sorting for TTF too --- make/common/gc.js | 205 ++++++++++++++++++++++++++++---------------- make/pass1/build.js | 2 +- make/pass2/build.js | 8 +- verdafile.js | 3 - 4 files changed, 136 insertions(+), 82 deletions(-) diff --git a/make/common/gc.js b/make/common/gc.js index 966bc412a..7c3db9071 100644 --- a/make/common/gc.js +++ b/make/common/gc.js @@ -3,61 +3,12 @@ module.exports = function gcFont(font, cfg) { markSweepOtl(font.GSUB); markSweepOtl(font.GPOS); - const sink = mark(font, cfg); - sweep(font, sink); + const glyphSink = markGlyphs(font, cfg); + sweepGlyphs(font, glyphSink); + return [...glyphSink].sort((a, b) => a[1] - b[1]).map(x => x[0]); }; -function mark(font, cfg) { - let sink = new Set(); - let glyphCount = 0; - - sink.add(".notdef"); - if (font.glyph_order) { - for (let idx = 0; idx < font.glyph_order.length; idx++) { - const g = font.glyph_order[idx]; - if (idx === 0 || /\.notdef$/.test(g)) sink.add(g); - } - } - - if (font.cmap) { - for (const k in font.cmap) { - if (font.cmap[k]) sink.add(font.cmap[k]); - } - } - if (font.cmap_uvs) { - for (const k in font.cmap_uvs) { - if (font.cmap_uvs[k]) sink.add(font.cmap_uvs[k]); - } - } - - do { - glyphCount = sink.size; - - if (font.GSUB) { - for (const l in font.GSUB.lookups) { - const lookup = font.GSUB.lookups[l]; - if (!lookup || !lookup.subtables) continue; - if (lookup && lookup.subtables) { - for (let st of lookup.subtables) { - markSubtable(sink, lookup.type, st, cfg); - } - } - } - } - - if (font.glyf) { - for (const g in font.glyf) { - const glyph = font.glyf[g]; - if (!glyph || !glyph.references) continue; - for (const ref of glyph.references) if (ref && ref.glyph) sink.add(ref.glyph); - } - } - - let glyphCount1 = sink.size; - if (glyphCount1 === glyphCount) break; - } while (true); - return sink; -} +/////////////////////////////////////////////////////////////////////////////////////////////////// function markSweepOtl(table) { if (!table || !table.features || !table.lookups) return; @@ -81,49 +32,155 @@ function markSweepOtl(table) { } table.features = features1; } -function markLookups(gsub, sink) { +function markLookups(gsub, lookupSet) { if (!gsub || !gsub.features) return; for (let f in gsub.features) { const feature = gsub.features[f]; if (!feature) continue; - for (const l of feature) sink.add(l); + for (const l of feature) lookupSet.add(l); } let loop = 0, lookupSetChanged = false; do { lookupSetChanged = false; - let sizeBefore = sink.size; - for (const l of Array.from(sink)) { + let sizeBefore = lookupSet.size; + for (const l of Array.from(lookupSet)) { const lookup = gsub.lookups[l]; if (!lookup || !lookup.subtables) continue; if (lookup.type === "gsub_chaining" || lookup.type === "gpos_chaining") { for (let st of lookup.subtables) { if (!st || !st.apply) continue; - for (const app of st.apply) sink.add(app.lookup); + for (const app of st.apply) lookupSet.add(app.lookup); } } } loop++; - lookupSetChanged = sizeBefore !== sink.size; + lookupSetChanged = sizeBefore !== lookupSet.size; } while (loop < 0xff && lookupSetChanged); } -function markSubtable(sink, type, st, cfg) { +/////////////////////////////////////////////////////////////////////////////////////////////////// + +const RANK_MOST = 0; +const RANK_UNICODE_PREFERRED = 0x1000000; +const RANK_UNICODE_ALIASED = 0x2000000; +const RANK_LEAST = 0xf000000; + +function simplyAdd(sink, gn) { + if (!sink.has(gn)) sink.set(gn, RANK_LEAST); +} + +function rankFromUnicode(c) { + if (!c) return RANK_LEAST; + // CJK aliased + if ( + (c >= 0x2e80 && c <= 0x2fff) || // CJK radicals + (c >= 0x3192 && c <= 0x319f) || // Ideographic annotation + (c >= 0x31c0 && c <= 0x31ef) || // CJK strokes + (c >= 0xf900 && c <= 0xfa6f) // CJK compatibility ideographs + ) { + return RANK_UNICODE_ALIASED | c; + } + + // Letter-like Symbols + if (c >= 0x2100 && c <= 0x214f) return RANK_UNICODE_ALIASED | c; + + return RANK_UNICODE_PREFERRED | c; +} + +function rankedAdd(sink, gn, rank) { + if (!rank) simplyAdd(sink, gn); + if (sink.has(gn)) { + const existing = sink.get(gn); + if (rank < existing) sink.set(gn, rank); + } else { + sink.set(gn, rank); + } +} + +function markGlyphs(font, cfg) { + let glyphSink = new Map(); + + if (font.glyf[".notdef"]) glyphSink.set(".notdef", RANK_MOST); + + if (font.glyph_order) { + for (let idx = 0; idx < font.glyph_order.length; idx++) { + const g = font.glyph_order[idx]; + if (idx === 0 || /\.notdef$/.test(g)) glyphSink.set(g, RANK_MOST); + } + } + + if (cfg && cfg.rankMap) { + for (const [gn, rank] of cfg.rankMap) rankedAdd(glyphSink, gn, rank); + } + + if (font.cmap) { + for (const k in font.cmap) { + if (font.cmap[k]) rankedAdd(glyphSink, font.cmap[k], rankFromUnicode(parseInt(k))); + } + } + if (font.cmap_uvs) { + for (const k in font.cmap_uvs) { + if (font.cmap_uvs[k]) simplyAdd(glyphSink, font.cmap_uvs[k]); + } + } + + let glyphCount; + do { + glyphCount = glyphSink.size; + + if (font.GSUB) { + for (const l in font.GSUB.lookups) { + const lookup = font.GSUB.lookups[l]; + if (!lookup || !lookup.subtables) continue; + if (lookup && lookup.subtables) { + for (let st of lookup.subtables) { + markSubtable(glyphSink, lookup.type, st, cfg); + } + } + } + } + + if (font.glyf) { + for (const g in font.glyf) { + const glyph = font.glyf[g]; + if (!glyph || !glyph.references) continue; + for (const ref of glyph.references) { + if (ref && ref.glyph) simplyAdd(glyphSink, ref.glyph); + } + } + } + + let glyphCount1 = glyphSink.size; + if (glyphCount1 === glyphCount) break; + } while (true); + return glyphSink; +} + +function markSubtable(glyphSink, type, st, cfg) { switch (type) { case "gsub_single": + for (const k in st) if (glyphSink.has(k) && st[k]) simplyAdd(glyphSink, st[k]); + break; case "gsub_multi": - for (const k in st) if (sink.has(k) && st[k]) sink.add(st[k]); + for (const k in st) + if (glyphSink.has(k) && st[k]) { + for (const gTo of st[k]) simplyAdd(glyphSink, gTo); + } break; case "gsub_alternate": if (!cfg || !cfg.ignoreAltSub) { - for (const k in st) if (sink.has(k) && st[k]) sink.add(st[k]); + for (const k in st) + if (glyphSink.has(k) && st[k]) { + for (const gTo of st[k]) simplyAdd(glyphSink, gTo); + } } break; case "gsub_ligature": for (const sub of st.substitutions) { let check = true; - for (const g of sub.from) if (!sink.has(g)) check = false; - if (check && sub.to) sink.add(sub.to); + for (const g of sub.from) if (!glyphSink.has(g)) check = false; + if (check && sub.to) simplyAdd(glyphSink, sub.to); } break; case "gsub_chaining": @@ -132,19 +189,21 @@ function markSubtable(sink, type, st, cfg) { if (st.match && st.to) { const matchCoverage = st.match[st.inputIndex]; for (let j = 0; j < matchCoverage.length; j++) { - if (sink.has(matchCoverage[j]) && st.to[j]) sink.add(st.to[j]); + if (glyphSink.has(matchCoverage[j]) && st.to[j]) simplyAdd(glyphSink, st.to[j]); } } break; } } -function sweep(font, sink) { +/////////////////////////////////////////////////////////////////////////////////////////////////// + +function sweepGlyphs(font, glyphSink) { // glyf if (font.glyf) { const filteredGlyf = {}; for (const key in font.glyf) { - if (sink.has(key)) filteredGlyf[key] = font.glyf[key]; + if (glyphSink.has(key)) filteredGlyf[key] = font.glyf[key]; } font.glyf = filteredGlyf; } else { @@ -152,32 +211,32 @@ function sweep(font, sink) { } // GSUB - sweepOtl(font.GSUB, sink); + sweepOtl(font.GSUB, glyphSink); } -function sweepOtl(gsub, sink) { +function sweepOtl(gsub, glyphSink) { if (!gsub || !gsub.lookups) return; for (const lid in gsub.lookups) { const lookup = gsub.lookups[lid]; if (!lookup.subtables) continue; const newSubtables = []; for (const st of lookup.subtables) { - const keep = sweepSubtable(st, lookup.type, sink); + const keep = sweepSubtable(st, lookup.type, glyphSink); if (keep) newSubtables.push(st); } lookup.subtables = newSubtables; } } -function sweepSubtable(st, type, sink) { +function sweepSubtable(st, type, glyphSink) { switch (type) { case "gsub_ligature": { if (!st.substitutions) return false; let newSubst = []; for (const rule of st.substitutions) { let include = true; - if (!sink.has(rule.to)) include = false; - for (const from of rule.from) if (!sink.has(from)) include = false; + if (!glyphSink.has(rule.to)) include = false; + for (const from of rule.from) if (!glyphSink.has(from)) include = false; if (include) newSubst.push(rule); } st.substitutions = newSubst; diff --git a/make/pass1/build.js b/make/pass1/build.js index 258204eb8..0e7a930cc 100644 --- a/make/pass1/build.js +++ b/make/pass1/build.js @@ -98,7 +98,7 @@ async function pass(ctx, config, argv) { ); if (argv.italize) italize(a, +10); - gc(ctx.items.a); + ctx.items.a.glyph_order = gc(ctx.items.a); await ctx.run(build, "a", { to: config.o }); } diff --git a/make/pass2/build.js b/make/pass2/build.js index 2da2467f2..283f968b7 100644 --- a/make/pass2/build.js +++ b/make/pass2/build.js @@ -29,12 +29,10 @@ module.exports = async function makeFont(ctx, config, argv) { await ctx.run(merge.below, "a", "a", "c", { mergeOTL: true }); shareFeatures(ctx.items.a.GSUB); shareFeatures(ctx.items.a.GPOS); - gc(ctx.items.a); // This will make the order of glyphs in TTC less mangled - ctx.items.a.glyf.__glyf_pad = { advanceWidth: 0, contours: [[{ x: 0, y: 0, on: true }]] }; - if (ctx.items.a.glyph_order) { - ctx.items.a.glyph_order = [ctx.items.a.glyph_order[0], "__glyf_pad"]; - } + ctx.items.a.glyf.__glyf_pad__ = { advanceWidth: 0, contours: [[{ x: 0, y: 0, on: true }]] }; + ctx.items.a.glyph_order = gc(ctx.items.a, { rankMap: [["__glyf_pad__", 1]] }); + await ctx.run(build, "a", { to: argv.o }); }; diff --git a/verdafile.js b/verdafile.js index b71b4a0c2..64cadab36 100644 --- a/verdafile.js +++ b/verdafile.js @@ -246,9 +246,6 @@ const Pass1 = file.make( } ); -task("pass1-mono-sc-regular", t => t.need(Pass1("mono", "sc", "regular"))); -task("pass1-gothic-sc-regular", t => t.need(Pass1("gothic", "sc", "regular"))); - const Kanji0 = file.make( (region, style) => `${BUILD}/kanji0/${region}-${style}.ttf`, async (t, { full, dir, name }, region, style) => { From e2afedb4e8d45d7ed2866da1bcacdbd690d2db2d Mon Sep 17 00:00:00 2001 From: be5invis Date: Sat, 9 May 2020 10:14:22 -0700 Subject: [PATCH 4/4] Bump ver --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index 43fd1c07c..4c830f50d 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "sarasa-gothic", - "version": "0.12.5", + "version": "0.12.6", "main": "./run", "dependencies": { "@chlorophytum/cli": "^0.7.0",