decocms 4.161.1 → 4.162.0

package/dist/server/node_modules/@shuding/opentype.js/src/tables/cmap.js

@@ -1,145 +0,0 @@
-// The `cmap` table stores the mappings from characters to glyphs.
-// https://www.microsoft.com/typography/OTSPEC/cmap.htm
-
-import check from '../check';
-import parse from '../parse';
-
-function parseCmapTableFormat12(cmap, p) {
-    //Skip reserved.
-    p.parseUShort();
-
-    // Length in bytes of the sub-tables.
-    cmap.length = p.parseULong();
-    cmap.language = p.parseULong();
-
-    let groupCount;
-    cmap.groupCount = groupCount = p.parseULong();
-    cmap.glyphIndexMap = {};
-
-    for (let i = 0; i < groupCount; i += 1) {
-        const startCharCode = p.parseULong();
-        const endCharCode = p.parseULong();
-        let startGlyphId = p.parseULong();
-
-        for (let c = startCharCode; c <= endCharCode; c += 1) {
-            cmap.glyphIndexMap[c] = startGlyphId;
-            startGlyphId++;
-        }
-    }
-}
-
-function parseCmapTableFormat4(cmap, p, data, start, offset) {
-    // Length in bytes of the sub-tables.
-    cmap.length = p.parseUShort();
-    cmap.language = p.parseUShort();
-
-    // segCount is stored x 2.
-    let segCount;
-    cmap.segCount = segCount = p.parseUShort() >> 1;
-
-    // Skip searchRange, entrySelector, rangeShift.
-    p.skip('uShort', 3);
-
-    // The "unrolled" mapping from character codes to glyph indices.
-    cmap.glyphIndexMap = {};
-    const endCountParser = new parse.Parser(data, start + offset + 14);
-    const startCountParser = new parse.Parser(
-        data,
-        start + offset + 16 + segCount * 2
-    );
-    const idDeltaParser = new parse.Parser(
-        data,
-        start + offset + 16 + segCount * 4
-    );
-    const idRangeOffsetParser = new parse.Parser(
-        data,
-        start + offset + 16 + segCount * 6
-    );
-    let glyphIndexOffset = start + offset + 16 + segCount * 8;
-    for (let i = 0; i < segCount - 1; i += 1) {
-        let glyphIndex;
-        const endCount = endCountParser.parseUShort();
-        const startCount = startCountParser.parseUShort();
-        const idDelta = idDeltaParser.parseShort();
-        const idRangeOffset = idRangeOffsetParser.parseUShort();
-        for (let c = startCount; c <= endCount; c += 1) {
-            if (idRangeOffset !== 0) {
-                // The idRangeOffset is relative to the current position in the idRangeOffset array.
-                // Take the current offset in the idRangeOffset array.
-                glyphIndexOffset =
-                    idRangeOffsetParser.offset +
-                    idRangeOffsetParser.relativeOffset -
-                    2;
-
-                // Add the value of the idRangeOffset, which will move us into the glyphIndex array.
-                glyphIndexOffset += idRangeOffset;
-
-                // Then add the character index of the current segment, multiplied by 2 for USHORTs.
-                glyphIndexOffset += (c - startCount) * 2;
-                glyphIndex = parse.getUShort(data, glyphIndexOffset);
-                if (glyphIndex !== 0) {
-                    glyphIndex = (glyphIndex + idDelta) & 0xffff;
-                }
-            } else {
-                glyphIndex = (c + idDelta) & 0xffff;
-            }
-
-            cmap.glyphIndexMap[c] = glyphIndex;
-        }
-    }
-}
-
-// Parse the `cmap` table. This table stores the mappings from characters to glyphs.
-// There are many available formats, but we only support the Windows format 4 and 12.
-// This function returns a `CmapEncoding` object or null if no supported format could be found.
-function parseCmapTable(data, start) {
-    const cmap = {};
-    cmap.version = parse.getUShort(data, start);
-    check.argument(cmap.version === 0, 'cmap table version should be 0.');
-
-    // The cmap table can contain many sub-tables, each with their own format.
-    // We're only interested in a "platform 0" (Unicode format) and "platform 3" (Windows format) table.
-    cmap.numTables = parse.getUShort(data, start + 2);
-    let offset = -1;
-    for (let i = cmap.numTables - 1; i >= 0; i -= 1) {
-        const platformId = parse.getUShort(data, start + 4 + i * 8);
-        const encodingId = parse.getUShort(data, start + 4 + i * 8 + 2);
-        if (
-            (platformId === 3 &&
-                (encodingId === 0 || encodingId === 1 || encodingId === 10)) ||
-            (platformId === 0 &&
-                (encodingId === 0 ||
-                    encodingId === 1 ||
-                    encodingId === 2 ||
-                    encodingId === 3 ||
-                    encodingId === 4))
-        ) {
-            offset = parse.getULong(data, start + 4 + i * 8 + 4);
-            break;
-        }
-    }
-
-    if (offset === -1) {
-        // There is no cmap table in the font that we support.
-        throw new Error('No valid cmap sub-tables found.');
-    }
-
-    const p = new parse.Parser(data, start + offset);
-    cmap.format = p.parseUShort();
-
-    if (cmap.format === 12) {
-        parseCmapTableFormat12(cmap, p);
-    } else if (cmap.format === 4) {
-        parseCmapTableFormat4(cmap, p, data, start, offset);
-    } else {
-        throw new Error(
-            'Only format 4 and 12 cmap tables are supported (found format ' +
-                cmap.format +
-                ').'
-        );
-    }
-
-    return cmap;
-}
-
-export default { parse: parseCmapTable };

package/dist/server/node_modules/@shuding/opentype.js/src/tables/fvar.js

@@ -1,71 +0,0 @@
-// The `fvar` table stores font variation axes and instances.
-// https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6fvar.html
-
-import check from '../check';
-import parse from '../parse';
-
-function parseFvarAxis(data, start, names) {
-    const axis = {};
-    const p = new parse.Parser(data, start);
-    axis.tag = p.parseTag();
-    axis.minValue = p.parseFixed();
-    axis.defaultValue = p.parseFixed();
-    axis.maxValue = p.parseFixed();
-    p.skip('uShort', 1); // reserved for flags; no values defined
-    axis.name = names[p.parseUShort()] || {};
-    return axis;
-}
-
-function parseFvarInstance(data, start, axes, names) {
-    const inst = {};
-    const p = new parse.Parser(data, start);
-    inst.name = names[p.parseUShort()] || {};
-    p.skip('uShort', 1); // reserved for flags; no values defined
-
-    inst.coordinates = {};
-    for (let i = 0; i < axes.length; ++i) {
-        inst.coordinates[axes[i].tag] = p.parseFixed();
-    }
-
-    return inst;
-}
-
-function parseFvarTable(data, start, names) {
-    const p = new parse.Parser(data, start);
-    const tableVersion = p.parseULong();
-    check.argument(
-        tableVersion === 0x00010000,
-        'Unsupported fvar table version.'
-    );
-    const offsetToData = p.parseOffset16();
-    // Skip countSizePairs.
-    p.skip('uShort', 1);
-    const axisCount = p.parseUShort();
-    const axisSize = p.parseUShort();
-    const instanceCount = p.parseUShort();
-    const instanceSize = p.parseUShort();
-
-    const axes = [];
-    for (let i = 0; i < axisCount; i++) {
-        axes.push(
-            parseFvarAxis(data, start + offsetToData + i * axisSize, names)
-        );
-    }
-
-    const instances = [];
-    const instanceStart = start + offsetToData + axisCount * axisSize;
-    for (let j = 0; j < instanceCount; j++) {
-        instances.push(
-            parseFvarInstance(
-                data,
-                instanceStart + j * instanceSize,
-                axes,
-                names
-            )
-        );
-    }
-
-    return { axes: axes, instances: instances };
-}
-
-export default { parse: parseFvarTable };

package/dist/server/node_modules/@shuding/opentype.js/src/tables/gdef.js

@@ -1,62 +0,0 @@
-// The `GDEF` table contains various glyph properties
-// https://docs.microsoft.com/en-us/typography/opentype/spec/gdef
-
-import check from '../check';
-import { Parser } from '../parse';
-
-var attachList = function() {
-    return {
-        coverage: this.parsePointer(Parser.coverage),
-        attachPoints: this.parseList(Parser.pointer(Parser.uShortList))
-    };
-};
-
-var caretValue = function() {
-    var format = this.parseUShort();
-    check.argument(format === 1 || format === 2 || format === 3,
-        'Unsupported CaretValue table version.');
-    if (format === 1) {
-        return { coordinate: this.parseShort() };
-    } else if (format === 2) {
-        return { pointindex: this.parseShort() };
-    } else if (format === 3) {
-        // Device / Variation Index tables unsupported
-        return { coordinate: this.parseShort() };
-    }
-};
-
-var ligGlyph = function() {
-    return this.parseList(Parser.pointer(caretValue));
-};
-
-var ligCaretList = function() {
-    return {
-        coverage: this.parsePointer(Parser.coverage),
-        ligGlyphs: this.parseList(Parser.pointer(ligGlyph))
-    };
-};
-
-var markGlyphSets = function() {
-    this.parseUShort(); // Version
-    return this.parseList(Parser.pointer(Parser.coverage));
-};
-
-function parseGDEFTable(data, start) {
-    start = start || 0;
-    const p = new Parser(data, start);
-    const tableVersion = p.parseVersion(1);
-    check.argument(tableVersion === 1 || tableVersion === 1.2 || tableVersion === 1.3,
-        'Unsupported GDEF table version.');
-    var gdef = {
-        version: tableVersion,
-        classDef: p.parsePointer(Parser.classDef),
-        attachList: p.parsePointer(attachList),
-        ligCaretList: p.parsePointer(ligCaretList),
-        markAttachClassDef: p.parsePointer(Parser.classDef)
-    };
-    if (tableVersion >= 1.2) {
-        gdef.markGlyphSets = p.parsePointer(markGlyphSets);
-    }
-    return gdef;
-}
-export default { parse: parseGDEFTable };

package/dist/server/node_modules/@shuding/opentype.js/src/tables/glyf.js

@@ -1,349 +0,0 @@
-// The `glyf` table describes the glyphs in TrueType outline format.
-// http://www.microsoft.com/typography/otspec/glyf.htm
-
-import check from '../check';
-import glyphset from '../glyphset';
-import parse from '../parse';
-import Path from '../path';
-
-// Parse the coordinate data for a glyph.
-function parseGlyphCoordinate(p, flag, previousValue, shortVectorBitMask, sameBitMask) {
-    let v;
-    if ((flag & shortVectorBitMask) > 0) {
-        // The coordinate is 1 byte long.
-        v = p.parseByte();
-        // The `same` bit is re-used for short values to signify the sign of the value.
-        if ((flag & sameBitMask) === 0) {
-            v = -v;
-        }
-
-        v = previousValue + v;
-    } else {
-        //  The coordinate is 2 bytes long.
-        // If the `same` bit is set, the coordinate is the same as the previous coordinate.
-        if ((flag & sameBitMask) > 0) {
-            v = previousValue;
-        } else {
-            // Parse the coordinate as a signed 16-bit delta value.
-            v = previousValue + p.parseShort();
-        }
-    }
-
-    return v;
-}
-
-// Parse a TrueType glyph.
-function parseGlyph(glyph, data, start) {
-    const p = new parse.Parser(data, start);
-    glyph.numberOfContours = p.parseShort();
-    glyph._xMin = p.parseShort();
-    glyph._yMin = p.parseShort();
-    glyph._xMax = p.parseShort();
-    glyph._yMax = p.parseShort();
-    let flags;
-    let flag;
-
-    if (glyph.numberOfContours > 0) {
-        // This glyph is not a composite.
-        const endPointIndices = glyph.endPointIndices = [];
-        for (let i = 0; i < glyph.numberOfContours; i += 1) {
-            endPointIndices.push(p.parseUShort());
-        }
-
-        glyph.instructionLength = p.parseUShort();
-        glyph.instructions = [];
-        for (let i = 0; i < glyph.instructionLength; i += 1) {
-            glyph.instructions.push(p.parseByte());
-        }
-
-        const numberOfCoordinates = endPointIndices[endPointIndices.length - 1] + 1;
-        flags = [];
-        for (let i = 0; i < numberOfCoordinates; i += 1) {
-            flag = p.parseByte();
-            flags.push(flag);
-            // If bit 3 is set, we repeat this flag n times, where n is the next byte.
-            if ((flag & 8) > 0) {
-                const repeatCount = p.parseByte();
-                for (let j = 0; j < repeatCount; j += 1) {
-                    flags.push(flag);
-                    i += 1;
-                }
-            }
-        }
-
-        check.argument(flags.length === numberOfCoordinates, 'Bad flags.');
-
-        if (endPointIndices.length > 0) {
-            const points = [];
-            let point;
-            // X/Y coordinates are relative to the previous point, except for the first point which is relative to 0,0.
-            if (numberOfCoordinates > 0) {
-                for (let i = 0; i < numberOfCoordinates; i += 1) {
-                    flag = flags[i];
-                    point = {};
-                    point.onCurve = !!(flag & 1);
-                    point.lastPointOfContour = endPointIndices.indexOf(i) >= 0;
-                    points.push(point);
-                }
-
-                let px = 0;
-                for (let i = 0; i < numberOfCoordinates; i += 1) {
-                    flag = flags[i];
-                    point = points[i];
-                    point.x = parseGlyphCoordinate(p, flag, px, 2, 16);
-                    px = point.x;
-                }
-
-                let py = 0;
-                for (let i = 0; i < numberOfCoordinates; i += 1) {
-                    flag = flags[i];
-                    point = points[i];
-                    point.y = parseGlyphCoordinate(p, flag, py, 4, 32);
-                    py = point.y;
-                }
-            }
-
-            glyph.points = points;
-        } else {
-            glyph.points = [];
-        }
-    } else if (glyph.numberOfContours === 0) {
-        glyph.points = [];
-    } else {
-        glyph.isComposite = true;
-        glyph.points = [];
-        glyph.components = [];
-        let moreComponents = true;
-        while (moreComponents) {
-            flags = p.parseUShort();
-            const component = {
-                glyphIndex: p.parseUShort(),
-                xScale: 1,
-                scale01: 0,
-                scale10: 0,
-                yScale: 1,
-                dx: 0,
-                dy: 0
-            };
-            if ((flags & 1) > 0) {
-                // The arguments are words
-                if ((flags & 2) > 0) {
-                    // values are offset
-                    component.dx = p.parseShort();
-                    component.dy = p.parseShort();
-                } else {
-                    // values are matched points
-                    component.matchedPoints = [p.parseUShort(), p.parseUShort()];
-                }
-
-            } else {
-                // The arguments are bytes
-                if ((flags & 2) > 0) {
-                    // values are offset
-                    component.dx = p.parseChar();
-                    component.dy = p.parseChar();
-                } else {
-                    // values are matched points
-                    component.matchedPoints = [p.parseByte(), p.parseByte()];
-                }
-            }
-
-            if ((flags & 8) > 0) {
-                // We have a scale
-                component.xScale = component.yScale = p.parseF2Dot14();
-            } else if ((flags & 64) > 0) {
-                // We have an X / Y scale
-                component.xScale = p.parseF2Dot14();
-                component.yScale = p.parseF2Dot14();
-            } else if ((flags & 128) > 0) {
-                // We have a 2x2 transformation
-                component.xScale = p.parseF2Dot14();
-                component.scale01 = p.parseF2Dot14();
-                component.scale10 = p.parseF2Dot14();
-                component.yScale = p.parseF2Dot14();
-            }
-
-            glyph.components.push(component);
-            moreComponents = !!(flags & 32);
-        }
-        if (flags & 0x100) {
-            // We have instructions
-            glyph.instructionLength = p.parseUShort();
-            glyph.instructions = [];
-            for (let i = 0; i < glyph.instructionLength; i += 1) {
-                glyph.instructions.push(p.parseByte());
-            }
-        }
-    }
-}
-
-// Transform an array of points and return a new array.
-function transformPoints(points, transform) {
-    const newPoints = [];
-    for (let i = 0; i < points.length; i += 1) {
-        const pt = points[i];
-        const newPt = {
-            x: transform.xScale * pt.x + transform.scale01 * pt.y + transform.dx,
-            y: transform.scale10 * pt.x + transform.yScale * pt.y + transform.dy,
-            onCurve: pt.onCurve,
-            lastPointOfContour: pt.lastPointOfContour
-        };
-        newPoints.push(newPt);
-    }
-
-    return newPoints;
-}
-
-function getContours(points) {
-    const contours = [];
-    let currentContour = [];
-    for (let i = 0; i < points.length; i += 1) {
-        const pt = points[i];
-        currentContour.push(pt);
-        if (pt.lastPointOfContour) {
-            contours.push(currentContour);
-            currentContour = [];
-        }
-    }
-
-    check.argument(currentContour.length === 0, 'There are still points left in the current contour.');
-    return contours;
-}
-
-// Convert the TrueType glyph outline to a Path.
-function getPath(points) {
-    const p = new Path();
-    if (!points) {
-        return p;
-    }
-
-    const contours = getContours(points);
-
-    for (let contourIndex = 0; contourIndex < contours.length; ++contourIndex) {
-        const contour = contours[contourIndex];
-
-        let prev = null;
-        let curr = contour[contour.length - 1];
-        let next = contour[0];
-
-        if (curr.onCurve) {
-            p.moveTo(curr.x, curr.y);
-        } else {
-            if (next.onCurve) {
-                p.moveTo(next.x, next.y);
-            } else {
-                // If both first and last points are off-curve, start at their middle.
-                const start = {x: (curr.x + next.x) * 0.5, y: (curr.y + next.y) * 0.5};
-                p.moveTo(start.x, start.y);
-            }
-        }
-
-        for (let i = 0; i < contour.length; ++i) {
-            prev = curr;
-            curr = next;
-            next = contour[(i + 1) % contour.length];
-
-            if (curr.onCurve) {
-                // This is a straight line.
-                p.lineTo(curr.x, curr.y);
-            } else {
-                let prev2 = prev;
-                let next2 = next;
-
-                if (!prev.onCurve) {
-                    prev2 = { x: (curr.x + prev.x) * 0.5, y: (curr.y + prev.y) * 0.5 };
-                }
-
-                if (!next.onCurve) {
-                    next2 = { x: (curr.x + next.x) * 0.5, y: (curr.y + next.y) * 0.5 };
-                }
-
-                p.quadraticCurveTo(curr.x, curr.y, next2.x, next2.y);
-            }
-        }
-
-        p.closePath();
-    }
-    return p;
-}
-
-function buildPath(glyphs, glyph) {
-    if (glyph.isComposite) {
-        for (let j = 0; j < glyph.components.length; j += 1) {
-            const component = glyph.components[j];
-            const componentGlyph = glyphs.get(component.glyphIndex);
-            // Force the ttfGlyphLoader to parse the glyph.
-            componentGlyph.getPath();
-            if (componentGlyph.points) {
-                let transformedPoints;
-                if (component.matchedPoints === undefined) {
-                    // component positioned by offset
-                    transformedPoints = transformPoints(componentGlyph.points, component);
-                } else {
-                    // component positioned by matched points
-                    if ((component.matchedPoints[0] > glyph.points.length - 1) ||
-                        (component.matchedPoints[1] > componentGlyph.points.length - 1)) {
-                        throw Error('Matched points out of range in ' + glyph.name);
-                    }
-                    const firstPt = glyph.points[component.matchedPoints[0]];
-                    let secondPt = componentGlyph.points[component.matchedPoints[1]];
-                    const transform = {
-                        xScale: component.xScale, scale01: component.scale01,
-                        scale10: component.scale10, yScale: component.yScale,
-                        dx: 0, dy: 0
-                    };
-                    secondPt = transformPoints([secondPt], transform)[0];
-                    transform.dx = firstPt.x - secondPt.x;
-                    transform.dy = firstPt.y - secondPt.y;
-                    transformedPoints = transformPoints(componentGlyph.points, transform);
-                }
-                glyph.points = glyph.points.concat(transformedPoints);
-            }
-        }
-    }
-
-    return getPath(glyph.points);
-}
-
-function parseGlyfTableAll(data, start, loca, font) {
-    const glyphs = new glyphset.GlyphSet(font);
-
-    // The last element of the loca table is invalid.
-    for (let i = 0; i < loca.length - 1; i += 1) {
-        const offset = loca[i];
-        const nextOffset = loca[i + 1];
-        if (offset !== nextOffset) {
-            glyphs.push(i, glyphset.ttfGlyphLoader(font, i, parseGlyph, data, start + offset, buildPath));
-        } else {
-            glyphs.push(i, glyphset.glyphLoader(font, i));
-        }
-    }
-
-    return glyphs;
-}
-
-function parseGlyfTableOnLowMemory(data, start, loca, font) {
-    const glyphs = new glyphset.GlyphSet(font);
-
-    font._push = function(i) {
-        const offset = loca[i];
-        const nextOffset = loca[i + 1];
-        if (offset !== nextOffset) {
-            glyphs.push(i, glyphset.ttfGlyphLoader(font, i, parseGlyph, data, start + offset, buildPath));
-        } else {
-            glyphs.push(i, glyphset.glyphLoader(font, i));
-        }
-    };
-
-    return glyphs;
-}
-
-// Parse all the glyphs according to the offsets from the `loca` table.
-function parseGlyfTable(data, start, loca, font, opt) {
-    if (opt.lowMemory)
-        return parseGlyfTableOnLowMemory(data, start, loca, font);
-    else
-        return parseGlyfTableAll(data, start, loca, font);
-}
-
-export default { getPath, parse: parseGlyfTable};