decocms 4.161.2 → 4.162.0

package/dist/server/node_modules/@shuding/opentype.js/src/substitution.js

@@ -1,447 +0,0 @@
-// The Substitution object provides utility methods to manipulate
-// the GSUB substitution table.
-
-import check from './check';
-import Layout from './layout';
-
-/**
- * @exports opentype.Substitution
- * @class
- * @extends opentype.Layout
- * @param {opentype.Font}
- * @constructor
- */
-function Substitution(font) {
-    Layout.call(this, font, 'gsub');
-}
-
-// Check if 2 arrays of primitives are equal.
-function arraysEqual(ar1, ar2) {
-    const n = ar1.length;
-    if (n !== ar2.length) {
-        return false;
-    }
-    for (let i = 0; i < n; i++) {
-        if (ar1[i] !== ar2[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-
-// Find the first subtable of a lookup table in a particular format.
-function getSubstFormat(lookupTable, format, defaultSubtable) {
-    const subtables = lookupTable.subtables;
-    for (let i = 0; i < subtables.length; i++) {
-        const subtable = subtables[i];
-        if (subtable.substFormat === format) {
-            return subtable;
-        }
-    }
-    if (defaultSubtable) {
-        subtables.push(defaultSubtable);
-        return defaultSubtable;
-    }
-    return undefined;
-}
-
-Substitution.prototype = Layout.prototype;
-
-/**
- * Create a default GSUB table.
- * @return {Object} gsub - The GSUB table.
- */
-Substitution.prototype.createDefaultTable = function () {
-    // Generate a default empty GSUB table with just a DFLT script and dflt lang sys.
-    return {
-        version: 1,
-        scripts: [
-            {
-                tag: 'DFLT',
-                script: {
-                    defaultLangSys: {
-                        reserved: 0,
-                        reqFeatureIndex: 0xffff,
-                        featureIndexes: [],
-                    },
-                    langSysRecords: [],
-                },
-            },
-        ],
-        features: [],
-        lookups: [],
-    };
-};
-
-/**
- * List all single substitutions (lookup type 1) for a given script, language, and feature.
- * @param {string} [script='DFLT']
- * @param {string} [language='dflt']
- * @param {string} feature - 4-character feature name ('aalt', 'salt', 'ss01'...)
- * @return {Array} substitutions - The list of substitutions.
- */
-Substitution.prototype.getSingle = function (feature, script, language) {
-    const substitutions = [];
-    const lookupTables = this.getLookupTables(script, language, feature, 1);
-    for (let idx = 0; idx < lookupTables.length; idx++) {
-        const subtables = lookupTables[idx].subtables;
-        for (let i = 0; i < subtables.length; i++) {
-            const subtable = subtables[i];
-            const glyphs = this.expandCoverage(subtable.coverage);
-            let j;
-            if (subtable.substFormat === 1) {
-                const delta = subtable.deltaGlyphId;
-                for (j = 0; j < glyphs.length; j++) {
-                    const glyph = glyphs[j];
-                    substitutions.push({ sub: glyph, by: glyph + delta });
-                }
-            } else {
-                const substitute = subtable.substitute;
-                for (j = 0; j < glyphs.length; j++) {
-                    substitutions.push({ sub: glyphs[j], by: substitute[j] });
-                }
-            }
-        }
-    }
-    return substitutions;
-};
-
-/**
- * List all multiple substitutions (lookup type 2) for a given script, language, and feature.
- * @param {string} [script='DFLT']
- * @param {string} [language='dflt']
- * @param {string} feature - 4-character feature name ('ccmp', 'stch')
- * @return {Array} substitutions - The list of substitutions.
- */
-Substitution.prototype.getMultiple = function (feature, script, language) {
-    const substitutions = [];
-    const lookupTables = this.getLookupTables(script, language, feature, 2);
-    for (let idx = 0; idx < lookupTables.length; idx++) {
-        const subtables = lookupTables[idx].subtables;
-        for (let i = 0; i < subtables.length; i++) {
-            const subtable = subtables[i];
-            const glyphs = this.expandCoverage(subtable.coverage);
-            let j;
-
-            for (j = 0; j < glyphs.length; j++) {
-                const glyph = glyphs[j];
-                const replacements = subtable.sequences[j];
-                substitutions.push({ sub: glyph, by: replacements });
-            }
-        }
-    }
-    return substitutions;
-};
-
-/**
- * List all alternates (lookup type 3) for a given script, language, and feature.
- * @param {string} [script='DFLT']
- * @param {string} [language='dflt']
- * @param {string} feature - 4-character feature name ('aalt', 'salt'...)
- * @return {Array} alternates - The list of alternates
- */
-Substitution.prototype.getAlternates = function (feature, script, language) {
-    const alternates = [];
-    const lookupTables = this.getLookupTables(script, language, feature, 3);
-    for (let idx = 0; idx < lookupTables.length; idx++) {
-        const subtables = lookupTables[idx].subtables;
-        for (let i = 0; i < subtables.length; i++) {
-            const subtable = subtables[i];
-            const glyphs = this.expandCoverage(subtable.coverage);
-            const alternateSets = subtable.alternateSets;
-            for (let j = 0; j < glyphs.length; j++) {
-                alternates.push({ sub: glyphs[j], by: alternateSets[j] });
-            }
-        }
-    }
-    return alternates;
-};
-
-/**
- * List all ligatures (lookup type 4) for a given script, language, and feature.
- * The result is an array of ligature objects like { sub: [ids], by: id }
- * @param {string} feature - 4-letter feature name ('liga', 'rlig', 'dlig'...)
- * @param {string} [script='DFLT']
- * @param {string} [language='dflt']
- * @return {Array} ligatures - The list of ligatures.
- */
-Substitution.prototype.getLigatures = function (feature, script, language) {
-    const ligatures = [];
-    const lookupTables = this.getLookupTables(script, language, feature, 4);
-    for (let idx = 0; idx < lookupTables.length; idx++) {
-        const subtables = lookupTables[idx].subtables;
-        for (let i = 0; i < subtables.length; i++) {
-            const subtable = subtables[i];
-            const glyphs = this.expandCoverage(subtable.coverage);
-            const ligatureSets = subtable.ligatureSets;
-            for (let j = 0; j < glyphs.length; j++) {
-                const startGlyph = glyphs[j];
-                const ligSet = ligatureSets[j];
-                for (let k = 0; k < ligSet.length; k++) {
-                    const lig = ligSet[k];
-                    ligatures.push({
-                        sub: [startGlyph].concat(lig.components),
-                        by: lig.ligGlyph,
-                    });
-                }
-            }
-        }
-    }
-    return ligatures;
-};
-
-/**
- * Add or modify a single substitution (lookup type 1)
- * Format 2, more flexible, is always used.
- * @param {string} feature - 4-letter feature name ('liga', 'rlig', 'dlig'...)
- * @param {Object} substitution - { sub: id, by: id } (format 1 is not supported)
- * @param {string} [script='DFLT']
- * @param {string} [language='dflt']
- */
-Substitution.prototype.addSingle = function (
-    feature,
-    substitution,
-    script,
-    language
-) {
-    const lookupTable = this.getLookupTables(
-        script,
-        language,
-        feature,
-        1,
-        true
-    )[0];
-    const subtable = getSubstFormat(lookupTable, 2, {
-        // lookup type 1 subtable, format 2, coverage format 1
-        substFormat: 2,
-        coverage: { format: 1, glyphs: [] },
-        substitute: [],
-    });
-    check.assert(
-        subtable.coverage.format === 1,
-        'Single: unable to modify coverage table format ' +
-            subtable.coverage.format
-    );
-    const coverageGlyph = substitution.sub;
-    let pos = this.binSearch(subtable.coverage.glyphs, coverageGlyph);
-    if (pos < 0) {
-        pos = -1 - pos;
-        subtable.coverage.glyphs.splice(pos, 0, coverageGlyph);
-        subtable.substitute.splice(pos, 0, 0);
-    }
-    subtable.substitute[pos] = substitution.by;
-};
-
-/**
- * Add or modify a multiple substitution (lookup type 2)
- * @param {string} feature - 4-letter feature name ('ccmp', 'stch')
- * @param {Object} substitution - { sub: id, by: [id] } for format 2.
- * @param {string} [script='DFLT']
- * @param {string} [language='dflt']
- */
-Substitution.prototype.addMultiple = function (
-    feature,
-    substitution,
-    script,
-    language
-) {
-    check.assert(
-        substitution.by instanceof Array && substitution.by.length > 1,
-        'Multiple: "by" must be an array of two or more ids'
-    );
-    const lookupTable = this.getLookupTables(
-        script,
-        language,
-        feature,
-        2,
-        true
-    )[0];
-    const subtable = getSubstFormat(lookupTable, 1, {
-        // lookup type 2 subtable, format 1, coverage format 1
-        substFormat: 1,
-        coverage: { format: 1, glyphs: [] },
-        sequences: [],
-    });
-    check.assert(
-        subtable.coverage.format === 1,
-        'Multiple: unable to modify coverage table format ' +
-            subtable.coverage.format
-    );
-    const coverageGlyph = substitution.sub;
-    let pos = this.binSearch(subtable.coverage.glyphs, coverageGlyph);
-    if (pos < 0) {
-        pos = -1 - pos;
-        subtable.coverage.glyphs.splice(pos, 0, coverageGlyph);
-        subtable.sequences.splice(pos, 0, 0);
-    }
-    subtable.sequences[pos] = substitution.by;
-};
-
-/**
- * Add or modify an alternate substitution (lookup type 3)
- * @param {string} feature - 4-letter feature name ('liga', 'rlig', 'dlig'...)
- * @param {Object} substitution - { sub: id, by: [ids] }
- * @param {string} [script='DFLT']
- * @param {string} [language='dflt']
- */
-Substitution.prototype.addAlternate = function (
-    feature,
-    substitution,
-    script,
-    language
-) {
-    const lookupTable = this.getLookupTables(
-        script,
-        language,
-        feature,
-        3,
-        true
-    )[0];
-    const subtable = getSubstFormat(lookupTable, 1, {
-        // lookup type 3 subtable, format 1, coverage format 1
-        substFormat: 1,
-        coverage: { format: 1, glyphs: [] },
-        alternateSets: [],
-    });
-    check.assert(
-        subtable.coverage.format === 1,
-        'Alternate: unable to modify coverage table format ' +
-            subtable.coverage.format
-    );
-    const coverageGlyph = substitution.sub;
-    let pos = this.binSearch(subtable.coverage.glyphs, coverageGlyph);
-    if (pos < 0) {
-        pos = -1 - pos;
-        subtable.coverage.glyphs.splice(pos, 0, coverageGlyph);
-        subtable.alternateSets.splice(pos, 0, 0);
-    }
-    subtable.alternateSets[pos] = substitution.by;
-};
-
-/**
- * Add a ligature (lookup type 4)
- * Ligatures with more components must be stored ahead of those with fewer components in order to be found
- * @param {string} feature - 4-letter feature name ('liga', 'rlig', 'dlig'...)
- * @param {Object} ligature - { sub: [ids], by: id }
- * @param {string} [script='DFLT']
- * @param {string} [language='dflt']
- */
-Substitution.prototype.addLigature = function (
-    feature,
-    ligature,
-    script,
-    language
-) {
-    const lookupTable = this.getLookupTables(
-        script,
-        language,
-        feature,
-        4,
-        true
-    )[0];
-    let subtable = lookupTable.subtables[0];
-    if (!subtable) {
-        subtable = {
-            // lookup type 4 subtable, format 1, coverage format 1
-            substFormat: 1,
-            coverage: { format: 1, glyphs: [] },
-            ligatureSets: [],
-        };
-        lookupTable.subtables[0] = subtable;
-    }
-    check.assert(
-        subtable.coverage.format === 1,
-        'Ligature: unable to modify coverage table format ' +
-            subtable.coverage.format
-    );
-    const coverageGlyph = ligature.sub[0];
-    const ligComponents = ligature.sub.slice(1);
-    const ligatureTable = {
-        ligGlyph: ligature.by,
-        components: ligComponents,
-    };
-    let pos = this.binSearch(subtable.coverage.glyphs, coverageGlyph);
-    if (pos >= 0) {
-        // ligatureSet already exists
-        const ligatureSet = subtable.ligatureSets[pos];
-        for (let i = 0; i < ligatureSet.length; i++) {
-            // If ligature already exists, return.
-            if (arraysEqual(ligatureSet[i].components, ligComponents)) {
-                return;
-            }
-        }
-        // ligature does not exist: add it.
-        ligatureSet.push(ligatureTable);
-    } else {
-        // Create a new ligatureSet and add coverage for the first glyph.
-        pos = -1 - pos;
-        subtable.coverage.glyphs.splice(pos, 0, coverageGlyph);
-        subtable.ligatureSets.splice(pos, 0, [ligatureTable]);
-    }
-};
-
-/**
- * List all feature data for a given script and language.
- * @param {string} feature - 4-letter feature name
- * @param {string} [script='DFLT']
- * @param {string} [language='dflt']
- * @return {Array} substitutions - The list of substitutions.
- */
-Substitution.prototype.getFeature = function (feature, script, language) {
-    if (/ss\d\d/.test(feature)) {
-        // ss01 - ss20
-        return this.getSingle(feature, script, language);
-    }
-    switch (feature) {
-        case 'aalt':
-        case 'salt':
-            return this.getSingle(feature, script, language).concat(
-                this.getAlternates(feature, script, language)
-            );
-        case 'dlig':
-        case 'liga':
-        case 'rlig':
-            return this.getLigatures(feature, script, language);
-        case 'ccmp':
-            return this.getMultiple(feature, script, language).concat(
-                this.getLigatures(feature, script, language)
-            );
-        case 'stch':
-            return this.getMultiple(feature, script, language);
-    }
-    return undefined;
-};
-
-/**
- * Add a substitution to a feature for a given script and language.
- * @param {string} feature - 4-letter feature name
- * @param {Object} sub - the substitution to add (an object like { sub: id or [ids], by: id or [ids] })
- * @param {string} [script='DFLT']
- * @param {string} [language='dflt']
- */
-Substitution.prototype.add = function (feature, sub, script, language) {
-    if (/ss\d\d/.test(feature)) {
-        // ss01 - ss20
-        return this.addSingle(feature, sub, script, language);
-    }
-    switch (feature) {
-        case 'aalt':
-        case 'salt':
-            if (typeof sub.by === 'number') {
-                return this.addSingle(feature, sub, script, language);
-            }
-            return this.addAlternate(feature, sub, script, language);
-        case 'dlig':
-        case 'liga':
-        case 'rlig':
-            return this.addLigature(feature, sub, script, language);
-        case 'ccmp':
-            if (sub.by instanceof Array) {
-                return this.addMultiple(feature, sub, script, language);
-            }
-            return this.addLigature(feature, sub, script, language);
-    }
-    return undefined;
-};
-
-export default Substitution;

package/dist/server/node_modules/@shuding/opentype.js/src/table.js

@@ -1,215 +0,0 @@
-// Table metadata
-
-import check from './check';
-import { encode, sizeOf } from './types';
-
-/**
- * @exports opentype.Table
- * @class
- * @param {string} tableName
- * @param {Array} fields
- * @param {Object} options
- * @constructor
- */
-function Table(tableName, fields, options) {
-    // For coverage tables with coverage format 2, we do not want to add the coverage data directly to the table object,
-    // as this will result in wrong encoding order of the coverage data on serialization to bytes.
-    // The fallback of using the field values directly when not present on the table is handled in types.encode.TABLE() already.
-    if (fields.length && (fields[0].name !== 'coverageFormat' || fields[0].value === 1)) {
-        for (let i = 0; i < fields.length; i += 1) {
-            const field = fields[i];
-            this[field.name] = field.value;
-        }
-    }
-
-    this.tableName = tableName;
-    this.fields = fields;
-    if (options) {
-        const optionKeys = Object.keys(options);
-        for (let i = 0; i < optionKeys.length; i += 1) {
-            const k = optionKeys[i];
-            const v = options[k];
-            if (this[k] !== undefined) {
-                this[k] = v;
-            }
-        }
-    }
-}
-
-/**
- * Encodes the table and returns an array of bytes
- * @return {Array}
- */
-Table.prototype.encode = function() {
-    return encode.TABLE(this);
-};
-
-/**
- * Get the size of the table.
- * @return {number}
- */
-Table.prototype.sizeOf = function() {
-    return sizeOf.TABLE(this);
-};
-
-/**
- * @private
- */
-function ushortList(itemName, list, count) {
-    if (count === undefined) {
-        count = list.length;
-    }
-    const fields = new Array(list.length + 1);
-    fields[0] = {name: itemName + 'Count', type: 'USHORT', value: count};
-    for (let i = 0; i < list.length; i++) {
-        fields[i + 1] = {name: itemName + i, type: 'USHORT', value: list[i]};
-    }
-    return fields;
-}
-
-/**
- * @private
- */
-function tableList(itemName, records, itemCallback) {
-    const count = records.length;
-    const fields = new Array(count + 1);
-    fields[0] = {name: itemName + 'Count', type: 'USHORT', value: count};
-    for (let i = 0; i < count; i++) {
-        fields[i + 1] = {name: itemName + i, type: 'TABLE', value: itemCallback(records[i], i)};
-    }
-    return fields;
-}
-
-/**
- * @private
- */
-function recordList(itemName, records, itemCallback) {
-    const count = records.length;
-    let fields = [];
-    fields[0] = {name: itemName + 'Count', type: 'USHORT', value: count};
-    for (let i = 0; i < count; i++) {
-        fields = fields.concat(itemCallback(records[i], i));
-    }
-    return fields;
-}
-
-// Common Layout Tables
-
-/**
- * @exports opentype.Coverage
- * @class
- * @param {opentype.Table}
- * @constructor
- * @extends opentype.Table
- */
-function Coverage(coverageTable) {
-    if (coverageTable.format === 1) {
-        Table.call(this, 'coverageTable',
-            [{name: 'coverageFormat', type: 'USHORT', value: 1}]
-            .concat(ushortList('glyph', coverageTable.glyphs))
-        );
-    } else if (coverageTable.format === 2) {
-        Table.call(this, 'coverageTable',
-            [{name: 'coverageFormat', type: 'USHORT', value: 2}]
-            .concat(recordList('rangeRecord', coverageTable.ranges, function(RangeRecord) {
-                return [
-                    {name: 'startGlyphID', type: 'USHORT', value: RangeRecord.start},
-                    {name: 'endGlyphID', type: 'USHORT', value: RangeRecord.end},
-                    {name: 'startCoverageIndex', type: 'USHORT', value: RangeRecord.index},
-                ];
-            }))
-        );
-    } else {
-        check.assert(false, 'Coverage format must be 1 or 2.');
-    }
-}
-Coverage.prototype = Object.create(Table.prototype);
-Coverage.prototype.constructor = Coverage;
-
-function ScriptList(scriptListTable) {
-    Table.call(this, 'scriptListTable',
-        recordList('scriptRecord', scriptListTable, function(scriptRecord, i) {
-            const script = scriptRecord.script;
-            let defaultLangSys = script.defaultLangSys;
-            check.assert(!!defaultLangSys, 'Unable to write GSUB: script ' + scriptRecord.tag + ' has no default language system.');
-            return [
-                {name: 'scriptTag' + i, type: 'TAG', value: scriptRecord.tag},
-                {name: 'script' + i, type: 'TABLE', value: new Table('scriptTable', [
-                    {name: 'defaultLangSys', type: 'TABLE', value: new Table('defaultLangSys', [
-                        {name: 'lookupOrder', type: 'USHORT', value: 0},
-                        {name: 'reqFeatureIndex', type: 'USHORT', value: defaultLangSys.reqFeatureIndex}]
-                        .concat(ushortList('featureIndex', defaultLangSys.featureIndexes)))}
-                    ].concat(recordList('langSys', script.langSysRecords, function(langSysRecord, i) {
-                        const langSys = langSysRecord.langSys;
-                        return [
-                            {name: 'langSysTag' + i, type: 'TAG', value: langSysRecord.tag},
-                            {name: 'langSys' + i, type: 'TABLE', value: new Table('langSys', [
-                                {name: 'lookupOrder', type: 'USHORT', value: 0},
-                                {name: 'reqFeatureIndex', type: 'USHORT', value: langSys.reqFeatureIndex}
-                                ].concat(ushortList('featureIndex', langSys.featureIndexes)))}
-                        ];
-                    })))}
-            ];
-        })
-    );
-}
-ScriptList.prototype = Object.create(Table.prototype);
-ScriptList.prototype.constructor = ScriptList;
-
-/**
- * @exports opentype.FeatureList
- * @class
- * @param {opentype.Table}
- * @constructor
- * @extends opentype.Table
- */
-function FeatureList(featureListTable) {
-    Table.call(this, 'featureListTable',
-        recordList('featureRecord', featureListTable, function(featureRecord, i) {
-            const feature = featureRecord.feature;
-            return [
-                {name: 'featureTag' + i, type: 'TAG', value: featureRecord.tag},
-                {name: 'feature' + i, type: 'TABLE', value: new Table('featureTable', [
-                    {name: 'featureParams', type: 'USHORT', value: feature.featureParams},
-                    ].concat(ushortList('lookupListIndex', feature.lookupListIndexes)))}
-            ];
-        })
-    );
-}
-FeatureList.prototype = Object.create(Table.prototype);
-FeatureList.prototype.constructor = FeatureList;
-
-/**
- * @exports opentype.LookupList
- * @class
- * @param {opentype.Table}
- * @param {Object}
- * @constructor
- * @extends opentype.Table
- */
-function LookupList(lookupListTable, subtableMakers) {
-    Table.call(this, 'lookupListTable', tableList('lookup', lookupListTable, function(lookupTable) {
-        let subtableCallback = subtableMakers[lookupTable.lookupType];
-        check.assert(!!subtableCallback, 'Unable to write GSUB lookup type ' + lookupTable.lookupType + ' tables.');
-        return new Table('lookupTable', [
-            {name: 'lookupType', type: 'USHORT', value: lookupTable.lookupType},
-            {name: 'lookupFlag', type: 'USHORT', value: lookupTable.lookupFlag}
-        ].concat(tableList('subtable', lookupTable.subtables, subtableCallback)));
-    }));
-}
-LookupList.prototype = Object.create(Table.prototype);
-LookupList.prototype.constructor = LookupList;
-
-// Record = same as Table, but inlined (a Table has an offset and its data is further in the stream)
-// Don't use offsets inside Records (probable bug), only in Tables.
-export default {
-    Table,
-    Record: Table,
-    Coverage,
-    ScriptList,
-    FeatureList,
-    LookupList,
-    ushortList,
-    tableList,
-    recordList,
-};