@markw65/monkeyc-optimizer 1.1.46 → 1.1.48

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to the "monkeyc-optimizer" package will be documented in this file.
 
+### 1.1.48
+
+- Adds a `--char-info-as-array` option to `cft-font-info`. When this option is set, charInfo is an array of arrays, rather than an array of objects, and there is a (single) `charInfoNames` array, giving the names of the elements of the charInfo sub-arrays. This is to save space - the charInfo array only contains the data, rather than (potentially) thousands of copies of the field names.
+
+### 1.1.47
+
+- Adds glyphAscent and glyphDescent to the font info produced by `cft-font-info`
+- Adds a `--chars` option to `cft-font-info` to select the chars you want included. This can save time, and greatly reduce the amount of output produced.
+
 ### 1.1.46
 
 - No change in functionality, but make @markw65/peggy-optimizer a devDependency so it doesn't get shipped with the package, and update to [@markw65/prettier-plugin-monkeyc@1.0.55](https://github.com/markw65/prettier-plugin-monkeyc/blob/main/CHANGELOG.md#1055) for the same reason.

package/bin/cft-font-info.js

@@ -2,12 +2,51 @@
 
 const cft = require("../build/cftinfo.cjs");
 const sdkUtil = require("../build/sdk-util.cjs");
-const { globa } = require("../build/util.cjs");
+const { globa, promiseAll } = require("../build/util.cjs");
 const path = require("node:path");
 
 const fonts = new Set();
+const otherArgs = [];
+let charsWanted;
+let charInfoAsArray;
+
+function error(e) {
+  throw new Error(e);
+}
+
+const prev = process.argv.slice(2).reduce((key, value) => {
+  const plain = !key && !value.startsWith("--");
+  if (plain) {
+    otherArgs.push(value);
+    return null;
+  }
+  const match = /^--((?:\w|-)+)(?:=(.*))?$/.exec(value);
+  if (!key) {
+    if (!match) {
+      error(`Expected an argument but got: ${value}`);
+    }
+    key = match[1];
+    value = match[2];
+  } else if (match) {
+    error(`Missing arg for '${key}'`);
+  }
+  switch (key) {
+    case "chars":
+      if (value == null) return key;
+      charsWanted = (charsWanted ?? "") + value;
+      break;
+    case "char-info-as-array":
+      charInfoAsArray = !value || /^(true|1)$/i.test(value);
+      break;
+    default:
+      error(`Unknown argument: --${key}`);
+  }
+  return null;
+}, null);
+if (prev) error(`Missing arg for '${prev}'`);
+
 Promise.all(
-  process.argv.slice(2).map((filename) => {
+  otherArgs.map((filename) => {
     if (/\.cft$/i.test(filename)) {
       return globa(path.resolve(sdkUtil.connectiq, "Fonts", filename)).then(
         (filenames) => {
@@ -36,28 +75,41 @@ Promise.all(
       )
     );
   })
-)
-  .then((results) =>
-    Promise.all(
-      Array.from(fonts).map((font) =>
-        cft.getCFTFontInfo(font).catch(() => null)
+).then((results) => {
+  console.log("{");
+  let last = -1;
+  let active = [];
+  const fontArray = Array.from(fonts).sort();
+  return promiseAll(
+    (i) =>
+      fontArray[i] &&
+      cft
+        .getCFTFontInfo(fontArray[i], { chars: charsWanted, charInfoAsArray })
+        .then(({ name, ...rest }) => `"${name}":${JSON.stringify(rest)},`)
+        .catch(() => null)
+        .then((line) => {
+          active[i] = line;
+          while (active[last + 1] !== undefined) {
+            const a = active[++last];
+            if (a != null) {
+              console.log(a);
+            }
+            delete active[last];
+          }
+        })
+  )
+    .then(() => active.forEach((line) => line && console.log(line)))
+    .then(() =>
+      console.log(
+        `"devices":${JSON.stringify(
+          Object.fromEntries(
+            results
+              .flat()
+              .filter((result) => result != null)
+              .map(({ device, ...rest }) => [device, rest])
+          )
+        )}`
       )
     )
-      .then((fonts) =>
-        Object.fromEntries(
-          fonts
-            .filter((font) => font != null)
-            .map(({ name, ...rest }) => [name, rest])
-        )
-      )
-      .then((fonts) => ({
-        fonts,
-        devices: Object.fromEntries(
-          results
-            .flat()
-            .filter((result) => result != null)
-            .map(({ device, ...rest }) => [device, rest])
-        ),
-      }))
-  )
-  .then((results) => console.log(JSON.stringify(results)));
+    .then(() => console.log("}"));
+});

package/build/api.cjs

@@ -18,47 +18,47 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var api_exports = {};
 __export(api_exports, {
-  checkCompilerVersion: () => import_chunk_LZIGQANB.checkCompilerVersion,
-  collectNamespaces: () => import_chunk_LZIGQANB.collectNamespaces,
-  createDocumentationMap: () => import_chunk_LZIGQANB.createDocumentationMap,
-  diagnostic: () => import_chunk_LZIGQANB.diagnostic,
-  diagnosticHelper: () => import_chunk_LZIGQANB.diagnosticHelper,
-  findNamesInScope: () => import_chunk_LZIGQANB.findNamesInScope,
-  findUsingForNode: () => import_chunk_LZIGQANB.findUsingForNode,
-  formatAst: () => import_chunk_LZIGQANB.formatAst,
-  formatAstLongLines: () => import_chunk_LZIGQANB.formatAstLongLines,
-  formatScopedName: () => import_chunk_LZIGQANB.formatScopedName,
-  getApiFunctionInfo: () => import_chunk_LZIGQANB.getApiFunctionInfo,
-  getApiMapping: () => import_chunk_LZIGQANB.getApiMapping,
-  getSuperClasses: () => import_chunk_LZIGQANB.getSuperClasses,
+  checkCompilerVersion: () => import_chunk_NB4IMZ6R.checkCompilerVersion,
+  collectNamespaces: () => import_chunk_NB4IMZ6R.collectNamespaces,
+  createDocumentationMap: () => import_chunk_NB4IMZ6R.createDocumentationMap,
+  diagnostic: () => import_chunk_NB4IMZ6R.diagnostic,
+  diagnosticHelper: () => import_chunk_NB4IMZ6R.diagnosticHelper,
+  findNamesInScope: () => import_chunk_NB4IMZ6R.findNamesInScope,
+  findUsingForNode: () => import_chunk_NB4IMZ6R.findUsingForNode,
+  formatAst: () => import_chunk_NB4IMZ6R.formatAst,
+  formatAstLongLines: () => import_chunk_NB4IMZ6R.formatAstLongLines,
+  formatScopedName: () => import_chunk_NB4IMZ6R.formatScopedName,
+  getApiFunctionInfo: () => import_chunk_NB4IMZ6R.getApiFunctionInfo,
+  getApiMapping: () => import_chunk_NB4IMZ6R.getApiMapping,
+  getSuperClasses: () => import_chunk_NB4IMZ6R.getSuperClasses,
   hasProperty: () => import_chunk_MBTLUWXR.hasProperty,
-  isClassVariable: () => import_chunk_LZIGQANB.isClassVariable,
-  isLocal: () => import_chunk_LZIGQANB.isLocal,
-  isLookupCandidate: () => import_chunk_LZIGQANB.isLookupCandidate,
-  isStateNode: () => import_chunk_LZIGQANB.isStateNode,
-  lookupByFullName: () => import_chunk_LZIGQANB.lookupByFullName,
-  lookupNext: () => import_chunk_LZIGQANB.lookupNext,
-  lookupResultContains: () => import_chunk_LZIGQANB.lookupResultContains,
-  lookupWithType: () => import_chunk_LZIGQANB.lookupWithType,
-  makeToyboxLink: () => import_chunk_LZIGQANB.makeToyboxLink,
-  mapVarDeclsByType: () => import_chunk_LZIGQANB.mapVarDeclsByType,
-  markInvokeClassMethod: () => import_chunk_LZIGQANB.markInvokeClassMethod,
-  parseSdkVersion: () => import_chunk_LZIGQANB.parseSdkVersion,
-  resolveDiagnostics: () => import_chunk_LZIGQANB.resolveDiagnostics,
-  resolveDiagnosticsMap: () => import_chunk_LZIGQANB.resolveDiagnosticsMap,
-  sameLookupResult: () => import_chunk_LZIGQANB.sameLookupResult,
+  isClassVariable: () => import_chunk_NB4IMZ6R.isClassVariable,
+  isLocal: () => import_chunk_NB4IMZ6R.isLocal,
+  isLookupCandidate: () => import_chunk_NB4IMZ6R.isLookupCandidate,
+  isStateNode: () => import_chunk_NB4IMZ6R.isStateNode,
+  lookupByFullName: () => import_chunk_NB4IMZ6R.lookupByFullName,
+  lookupNext: () => import_chunk_NB4IMZ6R.lookupNext,
+  lookupResultContains: () => import_chunk_NB4IMZ6R.lookupResultContains,
+  lookupWithType: () => import_chunk_NB4IMZ6R.lookupWithType,
+  makeToyboxLink: () => import_chunk_NB4IMZ6R.makeToyboxLink,
+  mapVarDeclsByType: () => import_chunk_NB4IMZ6R.mapVarDeclsByType,
+  markInvokeClassMethod: () => import_chunk_NB4IMZ6R.markInvokeClassMethod,
+  parseSdkVersion: () => import_chunk_NB4IMZ6R.parseSdkVersion,
+  resolveDiagnostics: () => import_chunk_NB4IMZ6R.resolveDiagnostics,
+  resolveDiagnosticsMap: () => import_chunk_NB4IMZ6R.resolveDiagnosticsMap,
+  sameLookupResult: () => import_chunk_NB4IMZ6R.sameLookupResult,
   traverseAst: () => import_chunk_MBTLUWXR.traverseAst,
-  variableDeclarationName: () => import_chunk_LZIGQANB.variableDeclarationName,
-  visitReferences: () => import_chunk_LZIGQANB.visitReferences,
-  visit_resources: () => import_chunk_LZIGQANB.visit_resources,
-  visitorNode: () => import_chunk_LZIGQANB.visitorNode
+  variableDeclarationName: () => import_chunk_NB4IMZ6R.variableDeclarationName,
+  visitReferences: () => import_chunk_NB4IMZ6R.visitReferences,
+  visit_resources: () => import_chunk_NB4IMZ6R.visit_resources,
+  visitorNode: () => import_chunk_NB4IMZ6R.visitorNode
 });
 module.exports = __toCommonJS(api_exports);
-var import_chunk_LZIGQANB = require("./chunk-LZIGQANB.cjs");
+var import_chunk_NB4IMZ6R = require("./chunk-NB4IMZ6R.cjs");
 var import_chunk_SG7ODKRM = require("./chunk-SG7ODKRM.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_LZIGQANB.init_api)();
+(0, import_chunk_NB4IMZ6R.init_api)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   checkCompilerVersion,

package/build/cftinfo.cjs

@@ -38,26 +38,64 @@ var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
 var import_node_assert = __toESM(require("node:assert"));
 var fs = __toESM(require("node:fs/promises"));
 var path = __toESM(require("node:path"));
+var zlib = __toESM(require("node:zlib"));
 (0, import_chunk_MBTLUWXR.init_ast)();
-function getCFTFontInfoFromBuffer(name, data) {
+async function getCFTFontInfoFromBuffer(name, data, options) {
   const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const glyphFlags = view.getUint8(3);
   const cmapOffset = view.getUint32(8);
   const glyphInfoOffset = view.getUint32(12);
+  const glyphDataOffset = view.getUint32(16);
   const height = view.getUint16(22);
   const ascent = view.getUint16(24);
   const internalLeading = view.getUint16(26);
+  const { chars, charInfoAsArray } = typeof options === "string" ? { chars: options } : options ?? {};
+  const charFilter = chars != null ? new Set(chars.split("").map((ch) => ch.charCodeAt(0))) : null;
   const cmapNGroups = view.getUint32(cmapOffset + 12);
   const charInfo = [];
+  const maybeCompressed = view.getUint16(0) === 40;
+  const align = maybeCompressed ? view.getUint8(36) : 1;
+  const glyphData = await getGlyphData(view, glyphDataOffset, maybeCompressed);
   for (let i = 0, offset = cmapOffset + 16; i < cmapNGroups; i++) {
     const startChar = view.getUint32(offset + 0);
     const endChar = view.getUint32(offset + 4);
     const startGlyph = view.getUint32(offset + 8);
     offset += 12;
     for (let code = startChar, g = startGlyph; code <= endChar; code++, g++) {
-      const width = view.getUint8(glyphInfoOffset + g * 4 + 3);
-      charInfo.push({ code, char: String.fromCharCode(code), width });
+      if (charFilter && !charFilter.has(code)) {
+        continue;
+      }
+      const word = view.getUint32(glyphInfoOffset + g * 4);
+      const glyphOffset = (word >> 16 & 65535) + ((word & 65280) << 8);
+      const width = word & 255;
+      const [glyphAscent, glyphDescent] = getGlyphAscentDescent(
+        glyphData,
+        glyphOffset,
+        width,
+        height,
+        ascent,
+        align,
+        glyphFlags
+      );
+      charInfo.push({
+        code,
+        char: String.fromCharCode(code),
+        width,
+        glyphAscent,
+        glyphDescent
+      });
     }
   }
+  if (charInfoAsArray && charInfo.length) {
+    return {
+      name,
+      height,
+      ascent,
+      internalLeading,
+      charInfo: charInfo.map((info) => Object.values(info)),
+      charInfoNames: Object.keys(charInfo[0])
+    };
+  }
   return {
     name,
     height,
@@ -66,10 +104,10 @@ function getCFTFontInfoFromBuffer(name, data) {
     charInfo
   };
 }
-function getCFTFontInfo(filename) {
+function getCFTFontInfo(filename, chars) {
   return fs.readFile(filename).then((data) => {
     const name = path.basename(filename, ".cft");
-    return getCFTFontInfoFromBuffer(name, data);
+    return getCFTFontInfoFromBuffer(name, data, chars);
   });
 }
 function getDeviceFontInfo(dirname) {
@@ -104,6 +142,144 @@ function getDeviceFontInfo(dirname) {
     return { device: path.basename(dirname), fontSets, langMap };
   });
 }
+async function getGlyphData(view, offset, maybeCompressed) {
+  if (maybeCompressed) {
+    const firstWord = view.getUint32(offset);
+    if (firstWord === 3439329293) {
+      offset += 4;
+    } else if (firstWord === 3489660941) {
+      offset += 4;
+      maybeCompressed = false;
+    }
+  }
+  if (maybeCompressed) {
+    const result = [];
+    const _length = view.getUint32(offset);
+    offset += 4;
+    const inflate = zlib.createInflate();
+    inflate.on("data", (chunk) => result.push(chunk));
+    const promise = new Promise((resolve2, reject) => {
+      inflate.on("end", () => resolve2(Buffer.concat(result)));
+      inflate.on("error", (e) => reject(e));
+    });
+    inflate.write(
+      Buffer.from(
+        view.buffer,
+        view.byteOffset + offset,
+        view.byteLength - offset
+      )
+    );
+    inflate.end();
+    const buffer = await promise;
+    return new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  return new DataView(
+    view.buffer,
+    view.byteOffset + offset,
+    view.byteLength - offset
+  );
+}
+function getGlyphAscentDescent(glyphData, glyphOffset, width, height, ascent, align, flags) {
+  const rle = (flags & 2) !== 0;
+  if (rle) {
+    glyphOffset &= 8388607;
+  }
+  const pixelsPerByte = flags & 4 ? 4 : 8;
+  const bytesToCount = Math.ceil(width / pixelsPerByte);
+  const byteWidth = Math.ceil(bytesToCount / align) * align;
+  const size = byteWidth * height;
+  const glyph = rle ? rleDecode(glyphData, glyphOffset, size) : new DataView(glyphData.buffer, glyphData.byteOffset + glyphOffset, size);
+  const glyphAscent = (() => {
+    let row = 0;
+    do {
+      const offset = row * byteWidth;
+      for (let i = 0; i < bytesToCount; i++) {
+        if (glyph.getUint8(offset + i))
+          return ascent - row;
+      }
+    } while (++row < ascent);
+    return 0;
+  })();
+  const glyphDescent = (() => {
+    let row = height;
+    while (row-- > ascent) {
+      const offset = row * byteWidth;
+      for (let i = 0; i < bytesToCount; i++) {
+        if (glyph.getUint8(offset + i))
+          return row - ascent;
+      }
+    }
+    return 0;
+  })();
+  return [glyphAscent, glyphDescent];
+}
+function rleDecode(encoded, offset, size) {
+  let bitsLeft = 0;
+  let val = 0;
+  const getBits = (n) => {
+    if (bitsLeft >= n) {
+      const result = val & (1 << n) - 1;
+      bitsLeft -= n;
+      val >>>= n;
+      return result;
+    }
+    if (bitsLeft === 0) {
+      val = encoded.getUint8(offset);
+      offset += 1;
+      bitsLeft = 8;
+      return getBits(n);
+    }
+    const bl = bitsLeft;
+    return getBits(bl) + (getBits(n - bl) << bl);
+  };
+  let runBits = 1;
+  while (getBits(1) === 0) {
+    runBits++;
+  }
+  const chunkSize = getBits(5) + 1;
+  const escape = getBits(chunkSize);
+  const output = new DataView(new ArrayBuffer(size + 3 & ~3));
+  let outOffset = 0;
+  let outBitOff = 0;
+  let outVal = 0;
+  const putBits = (value) => {
+    outVal |= value << outBitOff;
+    outBitOff += chunkSize;
+    if (outBitOff >= 32) {
+      output.setUint32(outOffset, outVal, true);
+      outOffset += 4;
+      outBitOff -= 32;
+      outVal = 0;
+      if (outBitOff !== 0) {
+        outVal = value >>> chunkSize - outBitOff;
+      }
+    }
+  };
+  let prev = -1;
+  const getChunk = () => {
+    const val2 = getBits(chunkSize);
+    if (val2 !== escape) {
+      prev = val2;
+      return [val2, 1];
+    }
+    const run = getBits(runBits);
+    if (run === 0) {
+      prev = val2;
+      return [val2, 1];
+    }
+    return [prev, run + 1];
+  };
+  while (outOffset + (outBitOff >>> 3) < size) {
+    let [val2, run] = getChunk();
+    while (run--) {
+      putBits(val2);
+    }
+  }
+  if (outOffset < size) {
+    output.setUint32(outOffset, outVal, true);
+  }
+  return output;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getCFTFontInfo,

package/build/{chunk-LZIGQANB.cjs → chunk-NB4IMZ6R.cjs}

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var chunk_LZIGQANB_exports = {};
-__export(chunk_LZIGQANB_exports, {
+var chunk_NB4IMZ6R_exports = {};
+__export(chunk_NB4IMZ6R_exports, {
   EnumTagsConst: () => EnumTagsConst,
   LastTypeTag: () => LastTypeTag,
   ObjectLikeTagsConst: () => ObjectLikeTagsConst,
@@ -133,7 +133,7 @@ __export(chunk_LZIGQANB_exports, {
   visitorNode: () => visitorNode,
   xml_util_exports: () => xml_util_exports
 });
-module.exports = __toCommonJS(chunk_LZIGQANB_exports);
+module.exports = __toCommonJS(chunk_NB4IMZ6R_exports);
 var import_chunk_SG7ODKRM = require("./chunk-SG7ODKRM.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
@@ -28344,7 +28344,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
       const opt_time = await (0, import_chunk_SG7ODKRM.first_modified)(
         Object.values(fnMap).map((v) => v.output)
       );
-      if (source_time < opt_time && 1708219691011 < opt_time) {
+      if (source_time < opt_time && 1708360159116 < opt_time) {
         return {
           hasTests,
           diagnostics: prevDiagnostics,
@@ -28383,7 +28383,7 @@ async function generateOneConfig(buildConfig, manifestXML, dependencyFiles, conf
             hasTests: hasTests2,
             diagnostics,
             sdkVersion,
-            optimizerVersion: "1.1.46",
+            optimizerVersion: "1.1.48",
             ...Object.fromEntries(
               configOptionsToCheck.map((option) => [option, config[option]])
             )

package/build/optimizer.cjs

@@ -18,28 +18,28 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var optimizer_exports = {};
 __export(optimizer_exports, {
-  StateNodeAttributes: () => import_chunk_LZIGQANB.StateNodeAttributes,
-  buildOptimizedProject: () => import_chunk_LZIGQANB.buildOptimizedProject,
+  StateNodeAttributes: () => import_chunk_NB4IMZ6R.StateNodeAttributes,
+  buildOptimizedProject: () => import_chunk_NB4IMZ6R.buildOptimizedProject,
   copyRecursiveAsNeeded: () => import_chunk_SG7ODKRM.copyRecursiveAsNeeded,
-  defaultConfig: () => import_chunk_LZIGQANB.defaultConfig,
-  display: () => import_chunk_LZIGQANB.display,
-  generateOneConfig: () => import_chunk_LZIGQANB.generateOneConfig,
-  generateOptimizedProject: () => import_chunk_LZIGQANB.generateOptimizedProject,
-  getConfig: () => import_chunk_LZIGQANB.getConfig,
-  getProjectAnalysis: () => import_chunk_LZIGQANB.getProjectAnalysis,
-  get_jungle: () => import_chunk_LZIGQANB.get_jungle,
-  isErrorWithLocation: () => import_chunk_LZIGQANB.isErrorWithLocation,
-  launchSimulator: () => import_chunk_LZIGQANB.launchSimulator,
-  manifestProducts: () => import_chunk_LZIGQANB.manifestProducts,
-  mctree: () => import_chunk_LZIGQANB.mctree,
-  simulateProgram: () => import_chunk_LZIGQANB.simulateProgram
+  defaultConfig: () => import_chunk_NB4IMZ6R.defaultConfig,
+  display: () => import_chunk_NB4IMZ6R.display,
+  generateOneConfig: () => import_chunk_NB4IMZ6R.generateOneConfig,
+  generateOptimizedProject: () => import_chunk_NB4IMZ6R.generateOptimizedProject,
+  getConfig: () => import_chunk_NB4IMZ6R.getConfig,
+  getProjectAnalysis: () => import_chunk_NB4IMZ6R.getProjectAnalysis,
+  get_jungle: () => import_chunk_NB4IMZ6R.get_jungle,
+  isErrorWithLocation: () => import_chunk_NB4IMZ6R.isErrorWithLocation,
+  launchSimulator: () => import_chunk_NB4IMZ6R.launchSimulator,
+  manifestProducts: () => import_chunk_NB4IMZ6R.manifestProducts,
+  mctree: () => import_chunk_NB4IMZ6R.mctree,
+  simulateProgram: () => import_chunk_NB4IMZ6R.simulateProgram
 });
 module.exports = __toCommonJS(optimizer_exports);
-var import_chunk_LZIGQANB = require("./chunk-LZIGQANB.cjs");
+var import_chunk_NB4IMZ6R = require("./chunk-NB4IMZ6R.cjs");
 var import_chunk_SG7ODKRM = require("./chunk-SG7ODKRM.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_LZIGQANB.init_optimizer)();
+(0, import_chunk_NB4IMZ6R.init_optimizer)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StateNodeAttributes,

package/build/sdk-util.cjs

@@ -18,25 +18,25 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var sdk_util_exports = {};
 __export(sdk_util_exports, {
-  SectionKinds: () => import_chunk_LZIGQANB.SectionKinds,
-  appSupport: () => import_chunk_LZIGQANB.appSupport,
-  connectiq: () => import_chunk_LZIGQANB.connectiq,
-  getDeviceInfo: () => import_chunk_LZIGQANB.getDeviceInfo,
-  getFunctionDocumentation: () => import_chunk_LZIGQANB.getFunctionDocumentation,
-  getLanguages: () => import_chunk_LZIGQANB.getLanguages,
-  getSdkPath: () => import_chunk_LZIGQANB.getSdkPath,
-  isWin: () => import_chunk_LZIGQANB.isWin,
-  optimizeProgram: () => import_chunk_LZIGQANB.optimizeProgram,
-  readPrg: () => import_chunk_LZIGQANB.readPrg,
-  readPrgWithOffsets: () => import_chunk_LZIGQANB.readPrgWithOffsets,
-  xmlUtil: () => import_chunk_LZIGQANB.xml_util_exports
+  SectionKinds: () => import_chunk_NB4IMZ6R.SectionKinds,
+  appSupport: () => import_chunk_NB4IMZ6R.appSupport,
+  connectiq: () => import_chunk_NB4IMZ6R.connectiq,
+  getDeviceInfo: () => import_chunk_NB4IMZ6R.getDeviceInfo,
+  getFunctionDocumentation: () => import_chunk_NB4IMZ6R.getFunctionDocumentation,
+  getLanguages: () => import_chunk_NB4IMZ6R.getLanguages,
+  getSdkPath: () => import_chunk_NB4IMZ6R.getSdkPath,
+  isWin: () => import_chunk_NB4IMZ6R.isWin,
+  optimizeProgram: () => import_chunk_NB4IMZ6R.optimizeProgram,
+  readPrg: () => import_chunk_NB4IMZ6R.readPrg,
+  readPrgWithOffsets: () => import_chunk_NB4IMZ6R.readPrgWithOffsets,
+  xmlUtil: () => import_chunk_NB4IMZ6R.xml_util_exports
 });
 module.exports = __toCommonJS(sdk_util_exports);
-var import_chunk_LZIGQANB = require("./chunk-LZIGQANB.cjs");
+var import_chunk_NB4IMZ6R = require("./chunk-NB4IMZ6R.cjs");
 var import_chunk_SG7ODKRM = require("./chunk-SG7ODKRM.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
-(0, import_chunk_LZIGQANB.init_sdk_util)();
+(0, import_chunk_NB4IMZ6R.init_sdk_util)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SectionKinds,

package/build/src/cftinfo.d.ts

@@ -1,5 +1,16 @@
 /// <reference types="node" />
-export declare function getCFTFontInfoFromBuffer(name: string, data: Buffer): {
+export type FontInfoOptions = {
+    chars?: string;
+    charInfoAsArray?: boolean;
+};
+export declare function getCFTFontInfoFromBuffer(name: string, data: Buffer, options?: FontInfoOptions | string): Promise<{
+    name: string;
+    height: number;
+    ascent: number;
+    internalLeading: number;
+    charInfo: (string | number)[][];
+    charInfoNames: string[];
+} | {
     name: string;
     height: number;
     ascent: number;
@@ -8,9 +19,19 @@ export declare function getCFTFontInfoFromBuffer(name: string, data: Buffer): {
         code: number;
         char: string;
         width: number;
+        glyphAscent: number;
+        glyphDescent: number;
     }[];
-};
-export declare function getCFTFontInfo(filename: string): Promise<{
+    charInfoNames?: undefined;
+}>;
+export declare function getCFTFontInfo(filename: string, chars?: string): Promise<{
+    name: string;
+    height: number;
+    ascent: number;
+    internalLeading: number;
+    charInfo: (string | number)[][];
+    charInfoNames: string[];
+} | {
     name: string;
     height: number;
     ascent: number;
@@ -19,7 +40,10 @@ export declare function getCFTFontInfo(filename: string): Promise<{
         code: number;
         char: string;
         width: number;
+        glyphAscent: number;
+        glyphDescent: number;
     }[];
+    charInfoNames?: undefined;
 }>;
 export declare function getDeviceFontInfo(dirname: string): Promise<{
     device: string;

package/build/worker-thread.cjs

@@ -21,17 +21,17 @@ __export(worker_thread_exports, {
   default: () => worker_thread_default
 });
 module.exports = __toCommonJS(worker_thread_exports);
-var import_chunk_LZIGQANB = require("./chunk-LZIGQANB.cjs");
+var import_chunk_NB4IMZ6R = require("./chunk-NB4IMZ6R.cjs");
 var import_chunk_SG7ODKRM = require("./chunk-SG7ODKRM.cjs");
 var import_chunk_MBTLUWXR = require("./chunk-MBTLUWXR.cjs");
 var import_chunk_ABYVSU2C = require("./chunk-ABYVSU2C.cjs");
 var import_node_worker_threads = require("node:worker_threads");
 var require_worker_thread = (0, import_chunk_ABYVSU2C.__commonJS)({
   "src/worker-thread.ts"() {
-    (0, import_chunk_LZIGQANB.init_worker_task)();
+    (0, import_chunk_NB4IMZ6R.init_worker_task)();
     if (import_node_worker_threads.parentPort) {
       import_node_worker_threads.parentPort.on("message", async (task) => {
-        return import_node_worker_threads.parentPort.postMessage(await (0, import_chunk_LZIGQANB.performTask)(task));
+        return import_node_worker_threads.parentPort.postMessage(await (0, import_chunk_NB4IMZ6R.performTask)(task));
       });
     }
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@markw65/monkeyc-optimizer",
   "type": "commonjs",
-  "version": "1.1.46",
+  "version": "1.1.48",
   "description": "Source to source optimizer for Garmin Monkey C code",
   "main": "build/optimizer.cjs",
   "types": "build/src/optimizer.d.ts",