decocms 4.113.3 → 4.113.4

package/dist/server/node_modules/@shuding/opentype.js/package.json

@@ -0,0 +1,73 @@
+{
+    "name": "@shuding/opentype.js",
+    "description": "OpenType font parser",
+    "version": "1.4.0-beta.0",
+    "author": {
+        "name": "Frederik De Bleser",
+        "email": "frederik@debleser.be"
+    },
+    "keywords": [
+        "graphics",
+        "fonts",
+        "font",
+        "opentype",
+        "otf",
+        "ttf",
+        "woff",
+        "type"
+    ],
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/opentypejs/opentype.js.git"
+    },
+    "main": "dist/opentype.js",
+    "module": "dist/opentype.module.js",
+    "bin": {
+        "ot": "./bin/ot"
+    },
+    "scripts": {
+        "start": "node ./bin/server.js",
+        "watch": "rollup -c -w",
+        "test": "mocha --require reify --recursive && jscs .",
+        "build": "rollup -c",
+        "minify": "uglifyjs --source-map \"url='opentype.min.js.map'\" --compress drop_console,hoist_funs --mangle --mangle-props --output ./dist/opentype.min.js -- ./dist/opentype.js",
+        "dist": "npm run test && npm run build && npm run minify"
+    },
+    "files": [
+        "LICENSE",
+        "RELEASES.md",
+        "README.md",
+        "bin",
+        "dist",
+        "src"
+    ],
+    "engines": {
+        "node": ">= 8.0.0"
+    },
+    "devDependencies": {
+        "@babel/preset-env": "^7.9.5",
+        "buble": "^0.20.0",
+        "cross-env": "^7.0.2",
+        "jscs": "^3.0.7",
+        "jshint": "^2.11.0",
+        "mocha": "^7.1.1",
+        "reify": "^0.20.12",
+        "rollup": "^1.32.1",
+        "rollup-plugin-buble": "^0.19.8",
+        "rollup-plugin-commonjs": "^10.1.0",
+        "rollup-plugin-license": "^0.9.0",
+        "rollup-plugin-node-resolve": "^5.2.0",
+        "uglify-js": "^3.8.1"
+    },
+    "browser": {
+        "fs": false
+    },
+    "dependencies": {
+        "fflate": "^0.7.3",
+        "string.prototype.codepointat": "^0.2.1"
+    },
+    "prettier": {
+        "singleQuote": true
+    }
+}

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

@@ -0,0 +1,158 @@
+// The Bounding Box object
+
+function derive(v0, v1, v2, v3, t) {
+    return Math.pow(1 - t, 3) * v0 +
+        3 * Math.pow(1 - t, 2) * t * v1 +
+        3 * (1 - t) * Math.pow(t, 2) * v2 +
+        Math.pow(t, 3) * v3;
+}
+/**
+ * A bounding box is an enclosing box that describes the smallest measure within which all the points lie.
+ * It is used to calculate the bounding box of a glyph or text path.
+ *
+ * On initialization, x1/y1/x2/y2 will be NaN. Check if the bounding box is empty using `isEmpty()`.
+ *
+ * @exports opentype.BoundingBox
+ * @class
+ * @constructor
+ */
+function BoundingBox() {
+    this.x1 = Number.NaN;
+    this.y1 = Number.NaN;
+    this.x2 = Number.NaN;
+    this.y2 = Number.NaN;
+}
+
+/**
+ * Returns true if the bounding box is empty, that is, no points have been added to the box yet.
+ */
+BoundingBox.prototype.isEmpty = function() {
+    return isNaN(this.x1) || isNaN(this.y1) || isNaN(this.x2) || isNaN(this.y2);
+};
+
+/**
+ * Add the point to the bounding box.
+ * The x1/y1/x2/y2 coordinates of the bounding box will now encompass the given point.
+ * @param {number} x - The X coordinate of the point.
+ * @param {number} y - The Y coordinate of the point.
+ */
+BoundingBox.prototype.addPoint = function(x, y) {
+    if (typeof x === 'number') {
+        if (isNaN(this.x1) || isNaN(this.x2)) {
+            this.x1 = x;
+            this.x2 = x;
+        }
+        if (x < this.x1) {
+            this.x1 = x;
+        }
+        if (x > this.x2) {
+            this.x2 = x;
+        }
+    }
+    if (typeof y === 'number') {
+        if (isNaN(this.y1) || isNaN(this.y2)) {
+            this.y1 = y;
+            this.y2 = y;
+        }
+        if (y < this.y1) {
+            this.y1 = y;
+        }
+        if (y > this.y2) {
+            this.y2 = y;
+        }
+    }
+};
+
+/**
+ * Add a X coordinate to the bounding box.
+ * This extends the bounding box to include the X coordinate.
+ * This function is used internally inside of addBezier.
+ * @param {number} x - The X coordinate of the point.
+ */
+BoundingBox.prototype.addX = function(x) {
+    this.addPoint(x, null);
+};
+
+/**
+ * Add a Y coordinate to the bounding box.
+ * This extends the bounding box to include the Y coordinate.
+ * This function is used internally inside of addBezier.
+ * @param {number} y - The Y coordinate of the point.
+ */
+BoundingBox.prototype.addY = function(y) {
+    this.addPoint(null, y);
+};
+
+/**
+ * Add a Bézier curve to the bounding box.
+ * This extends the bounding box to include the entire Bézier.
+ * @param {number} x0 - The starting X coordinate.
+ * @param {number} y0 - The starting Y coordinate.
+ * @param {number} x1 - The X coordinate of the first control point.
+ * @param {number} y1 - The Y coordinate of the first control point.
+ * @param {number} x2 - The X coordinate of the second control point.
+ * @param {number} y2 - The Y coordinate of the second control point.
+ * @param {number} x - The ending X coordinate.
+ * @param {number} y - The ending Y coordinate.
+ */
+BoundingBox.prototype.addBezier = function(x0, y0, x1, y1, x2, y2, x, y) {
+    // This code is based on http://nishiohirokazu.blogspot.com/2009/06/how-to-calculate-bezier-curves-bounding.html
+    // and https://github.com/icons8/svg-path-bounding-box
+
+    const p0 = [x0, y0];
+    const p1 = [x1, y1];
+    const p2 = [x2, y2];
+    const p3 = [x, y];
+
+    this.addPoint(x0, y0);
+    this.addPoint(x, y);
+
+    for (let i = 0; i <= 1; i++) {
+        const b = 6 * p0[i] - 12 * p1[i] + 6 * p2[i];
+        const a = -3 * p0[i] + 9 * p1[i] - 9 * p2[i] + 3 * p3[i];
+        const c = 3 * p1[i] - 3 * p0[i];
+
+        if (a === 0) {
+            if (b === 0) continue;
+            const t = -c / b;
+            if (0 < t && t < 1) {
+                if (i === 0) this.addX(derive(p0[i], p1[i], p2[i], p3[i], t));
+                if (i === 1) this.addY(derive(p0[i], p1[i], p2[i], p3[i], t));
+            }
+            continue;
+        }
+
+        const b2ac = Math.pow(b, 2) - 4 * c * a;
+        if (b2ac < 0) continue;
+        const t1 = (-b + Math.sqrt(b2ac)) / (2 * a);
+        if (0 < t1 && t1 < 1) {
+            if (i === 0) this.addX(derive(p0[i], p1[i], p2[i], p3[i], t1));
+            if (i === 1) this.addY(derive(p0[i], p1[i], p2[i], p3[i], t1));
+        }
+        const t2 = (-b - Math.sqrt(b2ac)) / (2 * a);
+        if (0 < t2 && t2 < 1) {
+            if (i === 0) this.addX(derive(p0[i], p1[i], p2[i], p3[i], t2));
+            if (i === 1) this.addY(derive(p0[i], p1[i], p2[i], p3[i], t2));
+        }
+    }
+};
+
+/**
+ * Add a quadratic curve to the bounding box.
+ * This extends the bounding box to include the entire quadratic curve.
+ * @param {number} x0 - The starting X coordinate.
+ * @param {number} y0 - The starting Y coordinate.
+ * @param {number} x1 - The X coordinate of the control point.
+ * @param {number} y1 - The Y coordinate of the control point.
+ * @param {number} x - The ending X coordinate.
+ * @param {number} y - The ending Y coordinate.
+ */
+BoundingBox.prototype.addQuad = function(x0, y0, x1, y1, x, y) {
+    const cp1x = x0 + 2 / 3 * (x1 - x0);
+    const cp1y = y0 + 2 / 3 * (y1 - y0);
+    const cp2x = cp1x + 1 / 3 * (x - x0);
+    const cp2y = cp1y + 1 / 3 * (y - y0);
+    this.addBezier(x0, y0, cp1x, cp1y, cp2x, cp2y, x, y);
+};
+
+export default BoundingBox;

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

@@ -0,0 +1,243 @@
+/**
+ * Infer bidirectional properties for a given text and apply
+ * the corresponding layout rules.
+ */
+
+import Tokenizer from './tokenizer';
+import FeatureQuery from './features/featureQuery';
+import arabicWordCheck from './features/arab/contextCheck/arabicWord';
+import arabicSentenceCheck from './features/arab/contextCheck/arabicSentence';
+import arabicPresentationForms from './features/arab/arabicPresentationForms';
+import arabicRequiredLigatures from './features/arab/arabicRequiredLigatures';
+import latinWordCheck from './features/latn/contextCheck/latinWord';
+import latinLigature from './features/latn/latinLigatures';
+
+/**
+ * Create Bidi. features
+ * @param {string} baseDir text base direction. value either 'ltr' or 'rtl'
+ */
+function Bidi(baseDir) {
+    this.baseDir = baseDir || 'ltr';
+    this.tokenizer = new Tokenizer();
+    this.featuresTags = {};
+}
+
+/**
+ * Sets Bidi text
+ * @param {string} text a text input
+ */
+Bidi.prototype.setText = function (text) {
+    this.text = text;
+};
+
+/**
+ * Store essential context checks:
+ * arabic word check for applying gsub features
+ * arabic sentence check for adjusting arabic layout
+ */
+Bidi.prototype.contextChecks = ({
+    latinWordCheck,
+    arabicWordCheck,
+    arabicSentenceCheck
+});
+
+/**
+ * Register arabic word check
+ */
+function registerContextChecker(checkId) {
+    const check = this.contextChecks[`${checkId}Check`];
+    return this.tokenizer.registerContextChecker(
+        checkId, check.startCheck, check.endCheck
+    );
+}
+
+/**
+ * Perform pre tokenization procedure then
+ * tokenize text input
+ */
+function tokenizeText() {
+    registerContextChecker.call(this, 'latinWord');
+    registerContextChecker.call(this, 'arabicWord');
+    registerContextChecker.call(this, 'arabicSentence');
+    return this.tokenizer.tokenize(this.text);
+}
+
+/**
+ * Reverse arabic sentence layout
+ * TODO: check base dir before applying adjustments - priority low
+ */
+function reverseArabicSentences() {
+    const ranges = this.tokenizer.getContextRanges('arabicSentence');
+    ranges.forEach(range => {
+        let rangeTokens = this.tokenizer.getRangeTokens(range);
+        this.tokenizer.replaceRange(
+            range.startIndex,
+            range.endOffset,
+            rangeTokens.reverse()
+        );
+    });
+}
+
+/**
+ * Register supported features tags
+ * @param {script} script script tag
+ * @param {Array} tags features tags list
+ */
+Bidi.prototype.registerFeatures = function (script, tags) {
+    const supportedTags = tags.filter(
+        tag => this.query.supports({script, tag})
+    );
+    if (!this.featuresTags.hasOwnProperty(script)) {
+        this.featuresTags[script] = supportedTags;
+    } else {
+        this.featuresTags[script] =
+        this.featuresTags[script].concat(supportedTags);
+    }
+};
+
+/**
+ * Apply GSUB features
+ * @param {Array} tagsList a list of features tags
+ * @param {string} script a script tag
+ * @param {Font} font opentype font instance
+ */
+Bidi.prototype.applyFeatures = function (font, features) {
+    if (!font) throw new Error(
+        'No valid font was provided to apply features'
+    );
+    if (!this.query) this.query = new FeatureQuery(font);
+    for (let f = 0; f < features.length; f++) {
+        const feature = features[f];
+        if (!this.query.supports({script: feature.script})) continue;
+        this.registerFeatures(feature.script, feature.tags);
+    }
+};
+
+/**
+ * Register a state modifier
+ * @param {string} modifierId state modifier id
+ * @param {function} condition a predicate function that returns true or false
+ * @param {function} modifier a modifier function to set token state
+ */
+Bidi.prototype.registerModifier = function (modifierId, condition, modifier) {
+    this.tokenizer.registerModifier(modifierId, condition, modifier);
+};
+
+/**
+ * Check if 'glyphIndex' is registered
+ */
+function checkGlyphIndexStatus() {
+    if (this.tokenizer.registeredModifiers.indexOf('glyphIndex') === -1) {
+        throw new Error(
+            'glyphIndex modifier is required to apply ' +
+            'arabic presentation features.'
+        );
+    }
+}
+
+/**
+ * Apply arabic presentation forms features
+ */
+function applyArabicPresentationForms() {
+    const script = 'arab';
+    if (!this.featuresTags.hasOwnProperty(script)) return;
+    checkGlyphIndexStatus.call(this);
+    const ranges = this.tokenizer.getContextRanges('arabicWord');
+    ranges.forEach(range => {
+        arabicPresentationForms.call(this, range);
+    });
+}
+
+/**
+ * Apply required arabic ligatures
+ */
+function applyArabicRequireLigatures() {
+    const script = 'arab';
+    if (!this.featuresTags.hasOwnProperty(script)) return;
+    const tags = this.featuresTags[script];
+    if (tags.indexOf('rlig') === -1) return;
+    checkGlyphIndexStatus.call(this);
+    const ranges = this.tokenizer.getContextRanges('arabicWord');
+    ranges.forEach(range => {
+        arabicRequiredLigatures.call(this, range);
+    });
+}
+
+/**
+ * Apply required arabic ligatures
+ */
+function applyLatinLigatures() {
+    const script = 'latn';
+    if (!this.featuresTags.hasOwnProperty(script)) return;
+    const tags = this.featuresTags[script];
+    if (tags.indexOf('liga') === -1) return;
+    checkGlyphIndexStatus.call(this);
+    const ranges = this.tokenizer.getContextRanges('latinWord');
+    ranges.forEach(range => {
+        latinLigature.call(this, range);
+    });
+}
+
+/**
+ * Check if a context is registered
+ * @param {string} contextId context id
+ */
+Bidi.prototype.checkContextReady = function (contextId) {
+    return !!this.tokenizer.getContext(contextId);
+};
+
+/**
+ * Apply features to registered contexts
+ */
+Bidi.prototype.applyFeaturesToContexts = function () {
+    if (this.checkContextReady('arabicWord')) {
+        applyArabicPresentationForms.call(this);
+        applyArabicRequireLigatures.call(this);
+    }
+    if (this.checkContextReady('latinWord')) {
+        applyLatinLigatures.call(this);
+    }
+    if (this.checkContextReady('arabicSentence')) {
+        reverseArabicSentences.call(this);
+    }
+};
+
+/**
+ * process text input
+ * @param {string} text an input text
+ */
+Bidi.prototype.processText = function(text) {
+    if (!this.text || this.text !== text) {
+        this.setText(text);
+        tokenizeText.call(this);
+        this.applyFeaturesToContexts();
+    }
+};
+
+/**
+ * Process a string of text to identify and adjust
+ * bidirectional text entities.
+ * @param {string} text input text
+ */
+Bidi.prototype.getBidiText = function (text) {
+    this.processText(text);
+    return this.tokenizer.getText();
+};
+
+/**
+ * Get the current state index of each token
+ * @param {text} text an input text
+ */
+Bidi.prototype.getTextGlyphs = function (text) {
+    this.processText(text);
+    let indexes = [];
+    for (let i = 0; i < this.tokenizer.tokens.length; i++) {
+        const token = this.tokenizer.tokens[i];
+        if (token.state.deleted) continue;
+        const index = token.activeState.value;
+        indexes.push(Array.isArray(index) ? index[0] : index);
+    }
+    return indexes;
+};
+
+export default Bidi;

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

@@ -0,0 +1,43 @@
+// ╭─┄┄┄────────────────────────┄─────────────────────────────────────────────╮
+// ┊ Character Class Assertions ┊ Checks if a char belongs to a certain class ┊
+// ╰─╾──────────────────────────┄─────────────────────────────────────────────╯
+// jscs:disable maximumLineLength
+/**
+ * Check if a char is Arabic
+ * @param {string} c a single char
+ */
+export function isArabicChar(c) {
+    return /[\u0600-\u065F\u066A-\u06D2\u06FA-\u06FF]/.test(c);
+}
+
+/**
+ * Check if a char is an isolated arabic char
+ * @param {string} c a single char
+ */
+export function isIsolatedArabicChar(char) {
+    return /[\u0630\u0690\u0621\u0631\u0661\u0671\u0622\u0632\u0672\u0692\u06C2\u0623\u0673\u0693\u06C3\u0624\u0694\u06C4\u0625\u0675\u0695\u06C5\u06E5\u0676\u0696\u06C6\u0627\u0677\u0697\u06C7\u0648\u0688\u0698\u06C8\u0689\u0699\u06C9\u068A\u06CA\u066B\u068B\u06CB\u068C\u068D\u06CD\u06FD\u068E\u06EE\u06FE\u062F\u068F\u06CF\u06EF]/.test(char);
+}
+
+/**
+ * Check if a char is an Arabic Tashkeel char
+ * @param {string} c a single char
+ */
+export function isTashkeelArabicChar(char) {
+    return /[\u0600-\u0605\u060C-\u060E\u0610-\u061B\u061E\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED]/.test(char);
+}
+
+/**
+ * Check if a char is Latin
+ * @param {string} c a single char
+ */
+export function isLatinChar(c) {
+    return /[A-z]/.test(c);
+}
+
+/**
+ * Check if a char is whitespace char
+ * @param {string} c a single char
+ */
+export function isWhiteSpace(c) {
+    return /\s/.test(c);
+}

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

@@ -0,0 +1,16 @@
+// Run-time checking of preconditions.
+
+function fail(message) {
+    throw new Error(message);
+}
+
+// Precondition function that checks if the given predicate is true.
+// If not, it will throw an error.
+function argument(predicate, message) {
+    if (!predicate) {
+        fail(message);
+    }
+}
+
+export { fail, argument, argument as assert };
+export default { fail, argument, assert: argument };