@cube-nl/dmp-sdk 1.0.0-rc.4 → 1.1.0-rc.2

package/dist/wireframe.js

@@ -0,0 +1,352 @@
+import { DmpError } from './errors.js';
+import { compare, PreviewStore } from './preview.js';
+import { isoDate } from './ui/format.js';
+const FORMATS = {
+    tekst: 'text',
+    getal: 'number',
+    bedrag: 'currency',
+    datum: 'date',
+    keuze: 'text',
+    'ja/nee': 'boolean',
+};
+const filled = (value) => typeof value === 'string' && value !== '';
+const own = (row, key) => Object.prototype.hasOwnProperty.call(row, key);
+// `a, -b` and ['a', '-b'] alike: the items of a comma list, as the server reads it.
+const items = (value = []) => [value].flat().join(',').split(',').map((item) => item.trim());
+function isGap(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const entry = value;
+    const waarden = entry.waarden;
+    return typeof entry.resource === 'string'
+        && /^[a-z][a-z0-9_]*$/.test(entry.resource)
+        && (entry.veld === undefined || filled(entry.veld))
+        && typeof entry.type === 'string'
+        && own(FORMATS, entry.type)
+        && (waarden === undefined || (Array.isArray(waarden) && waarden.every((item) => typeof item === 'string')))
+        && (entry.type !== 'keuze' || (Array.isArray(waarden) && waarden.length > 0))
+        && filled(entry.scherm)
+        && filled(entry.reden);
+}
+/** The valid gap entries of `ontbreekt`; malformed ones are dropped with a single warning. */
+export function readGaps(value) {
+    const gaps = [];
+    const dropped = [];
+    // Anything but a list is one malformed entry: a typo must not silently mean "nothing is missing".
+    for (const entry of Array.isArray(value) ? value : value == null ? [] : [value]) {
+        (isGap(entry) ? gaps : dropped).push(entry);
+    }
+    if (dropped.length > 0) {
+        console.warn(`cube-app.json ontbreekt: ${dropped.length} malformed entries ignored`, dropped);
+    }
+    return gaps;
+}
+export function gapFormat(type) {
+    return FORMATS[type];
+}
+/**
+ * A schema with the missing fields of its resource added, so a block that takes its columns from the schema shows
+ * them, and can filter and sort on them (the page only). They are writable: a wireframe's writes stay in the browser.
+ */
+export function withGaps(schema, gaps) {
+    if (schema === null) {
+        return null;
+    }
+    // Only these two formats are carried by a schema field; the others follow from its type.
+    const shown = (type) => {
+        const format = gapFormat(type);
+        return format === 'date' || format === 'currency' ? format : null;
+    };
+    const added = gaps.flatMap(({ resource, veld, type, waarden, reden }) => {
+        if (resource !== schema.name || veld === undefined || schema.fields.some((field) => field.name === veld)) {
+            return [];
+        }
+        const format = gapFormat(type);
+        return [{
+                name: veld,
+                type: format === 'boolean' ? format : format === 'number' || format === 'currency' ? 'number' : 'string',
+                format: shown(type),
+                nullable: true,
+                readonly: false,
+                enum: waarden ?? null,
+                description: reden,
+            }];
+    });
+    const names = added.map((field) => field.name);
+    return {
+        ...schema,
+        // Money is not recognisable by its values, dates are (inferFormat): only an amount gets its format here, and a
+        // stale `datum` gap must not drop a live date-time's time.
+        fields: [...schema.fields.map((field) => {
+                const gap = gaps.find(({ resource, veld }) => resource === schema.name && veld === field.name);
+                return gap?.type === 'bedrag' && field.format == null ? { ...field, format: 'currency' } : field;
+            }), ...added],
+        // An empty summary means "every field of a row", which already holds the invented ones.
+        summary: schema.summary.length > 0 ? [...schema.summary, ...names] : schema.summary,
+        filterable: [...schema.filterable, ...names],
+        sortable: [...schema.sortable, ...names],
+    };
+}
+// FNV-1a 32-bit: a stable hash, so the same row gets the same invented value on every render and reload.
+function fnv1a(text) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        hash = Math.imul(hash ^ text.charCodeAt(i), 0x01000193) >>> 0;
+    }
+    return hash;
+}
+/** An example value for a missing field of row `id`: from mock rows that carry the field, else made up by type. */
+export function inventValue(gap, id, mockRows) {
+    const { veld, type, waarden } = gap;
+    const h = fnv1a(`${gap.resource}.${veld}.${String(id)}`);
+    if (veld !== undefined) {
+        const rowsWithField = mockRows.filter((row) => own(row, veld) && row[veld] !== undefined);
+        if (rowsWithField.length > 0) {
+            return rowsWithField[h % rowsWithField.length]?.[veld];
+        }
+    }
+    switch (type) {
+        case 'tekst':
+            return `Voorbeeld ${(h % 100) + 1}`;
+        case 'getal':
+            return h % 1000;
+        case 'bedrag':
+            return (h % 100000) / 100;
+        case 'datum':
+            return isoDate(new Date(2026, 0, 1 + (h % 365)));
+        case 'keuze':
+            return waarden !== undefined && waarden.length > 0 ? waarden[h % waarden.length] : null;
+        case 'ja/nee':
+            return h % 2 === 0;
+    }
+}
+/** The fields a query asks of resource `name`, or undefined for all of them. */
+function selection(query, name) {
+    const fields = query?.fields;
+    return (Array.isArray(fields) ? fields : fields?.[name]);
+}
+/** The preview's own filter and sort over these rows alone, typed by value so numbers compare as numbers. */
+async function locally(name, rows, { filter = {}, sort = [] }) {
+    const sorted = [sort].flat().join(',').split(',').map((item) => item.replace(/^[-+]/, ''));
+    const fields = Object.fromEntries([...rows.flatMap(Object.keys), ...Object.keys(filter), ...sorted]
+        .filter((key) => key !== '')
+        .map((key) => [key, { type: typeof rows.find((row) => row[key] != null)?.[key] }]));
+    const byId = new Map(rows.map((row) => [String(row.id), row]));
+    const store = new PreviewStore({ [name]: { schema: { fields }, rows } });
+    const { data } = await store.resource(name).list({ filter, sort, page: { size: 200 } });
+    return data.map((row) => byId.get(String(row.id)));
+}
+/**
+ * A live resource some of whose fields do not exist yet. Those fields never reach the server (naming one would be a
+ * 422): each row gets an invented value, a filter or sort on one applies to the returned page only, and an aggregate
+ * that names one is answered from the mock rows.
+ */
+export function mixedResource(live, gaps, mock, mockRows) {
+    const { name } = live;
+    const missing = new Map(gaps.filter((gap) => gap.resource === name && gap.veld !== undefined).map((gap) => [gap.veld, gap]));
+    // `-field`, `sum(field)` and `field.month` name `field`; `count` and `created_at.month` do not name a field
+    // called `count` or `month`.
+    const names = (item) => missing.has(/^[-+]?(?:\w+\()?([^.()]*)/.exec(item)?.[1] ?? '');
+    const split = (query = {}) => {
+        const selected = selection(query, name);
+        const kept = selected?.filter((field) => !missing.has(field));
+        const filters = Object.entries(query.filter ?? {});
+        const sort = items(query.sort).filter((item) => item !== '');
+        // The live part names no missing field; the local part only missing ones.
+        const part = (local) => ({
+            filter: Object.fromEntries(filters.filter(([key]) => missing.has(key) === local)),
+            sort: sort.filter((item) => names(item) === local),
+        });
+        return {
+            // The id is what an invented value hangs on, so a narrowed request always asks for it.
+            live: { ...query, ...(kept && { fields: kept.includes('id') ? kept : [...kept, 'id'] }), ...part(false) },
+            local: part(true),
+            shown: (field) => selected === undefined || selected.includes(field),
+        };
+    };
+    const fill = (row, shown, all = false) => {
+        for (const [field, gap] of missing) {
+            // Own properties only: a field named `constructor` must not find Object's.
+            if ((all || shown(field)) && (!own(row, field) || row[field] == null)) {
+                row[field] = inventValue(gap, row.id, mockRows);
+            }
+        }
+    };
+    const merge = async (page, { local, shown }) => {
+        let data = page.data;
+        data.forEach((row) => fill(row, shown, true));
+        if (data.length > 0 && (local.sort.length > 0 || Object.keys(local.filter).length > 0)) {
+            data = await locally(name, data, local);
+        }
+        for (const row of data) {
+            for (const field of missing.keys()) {
+                if (!shown(field)) {
+                    delete row[field];
+                }
+            }
+        }
+        const { meta } = page;
+        return {
+            ...page,
+            data: data,
+            // A filter on a missing field covers this page only, so the count and the last page say so too.
+            meta: Object.keys(local.filter).length > 0
+                ? { ...meta, page: { ...meta.page, total: data.length, pages: meta.page.number } }
+                : meta,
+        };
+    };
+    const list = async (query, init) => {
+        const parts = split(query);
+        return merge(await live.list(parts.live, init), parts);
+    };
+    const pages = async function* (query, init) {
+        const parts = split(query);
+        for await (const page of live.pages(parts.live, init)) {
+            yield await merge(page, parts);
+        }
+    };
+    return {
+        ...live,
+        list,
+        pages,
+        async *all(query, init) {
+            for await (const page of pages(query, init)) {
+                yield* page.data;
+            }
+        },
+        async get(id, query, init) {
+            const parts = split(query);
+            const response = await live.get(id, parts.live, init);
+            fill(response.data, parts.shown);
+            // The id was only asked for the invented values.
+            if (!parts.shown('id')) {
+                delete response.data.id;
+            }
+            return response;
+        },
+        aggregate: (query, init) => [items(query.fn).map((fn) => fn.replace(/^\w+$/, '')), items(query.group), Object.keys(query.filter ?? {})]
+            .flat()
+            .some(names)
+            ? mock.resource(name).aggregate(query)
+            : live.aggregate(query, init),
+    };
+}
+/**
+ * A wireframe's writes, answered in this browser and never sent: what is created, changed or deleted lies over the
+ * wrapped client's reads until the page reloads. A created row's id is `voorbeeld-<n>`. A list shows a created or
+ * changed row only where the query's filter puts it, so a moved board card lands in its new column.
+ */
+export function simulatedWrites(client, name) {
+    const key = (row) => String(row.id);
+    // Created rows and whole changed copies of real ones, newest last; they stand in for the server's version.
+    const local = new Map();
+    // The server's own copy of each real row changed or deleted here: whether the server still lists it.
+    const origins = new Map();
+    const deleted = new Set();
+    let count = 0;
+    const answer = (status, data) => ({
+        status,
+        data,
+        meta: null,
+        headers: new Headers(),
+        etag: null,
+        recordVersion: null,
+        location: null,
+        replayed: false,
+        rateLimit: { limit: null, remaining: null, reset: null },
+    });
+    const pick = (row, query) => {
+        const fields = selection(query, name);
+        return Object.fromEntries(Object.entries(row).filter(([field]) => fields?.includes(field) ?? true));
+    };
+    const overlay = async (response, query = {}) => {
+        const { page } = response.meta;
+        const fitting = local.size > 0 ? (await locally(name, [...local.values()].reverse(), query)) : [];
+        const fits = new Set(fitting.map(key));
+        const served = new Set(origins.size > 0 ? (await locally(name, [...origins.values()], query)).map(key) : []);
+        const listed = new Set(response.data.map(key));
+        // A changed row keeps its place while the query still fits it; one only it fits now joins page 1.
+        const kept = response.data
+            .filter((row) => !deleted.has(key(row)) && (!local.has(key(row)) || fits.has(key(row))))
+            .map((row) => local.get(key(row)) ?? row);
+        const joined = fitting.filter((row) => !served.has(key(row)) && !listed.has(key(row)));
+        const total = page.total - [...served].filter((id) => !fits.has(id)).length + joined.length;
+        let data = page.number === 1 ? [...joined, ...kept] : kept;
+        // No sort reads as one empty field, which no row has: then nothing moves.
+        const sorts = items(query.sort)
+            .map((item) => [item.replace(/^[-+]/, ''), item.startsWith('-') ? -1 : 1]);
+        // A row written here that the server did not list (created, or joining the list) or that changed in a sort
+        // field is placed by the sort; the others keep the server's order, whose collation may differ from ours.
+        const placed = (row) => local.has(key(row))
+            && (!listed.has(key(row)) || sorts.some(([field]) => origins.get(key(row))?.[field] !== row[field]));
+        const server = data.filter((row) => !placed(row));
+        // Only when the server's rows carry every sort field to compare on; a placed row without one sorts as empty.
+        if (sorts.every(([field]) => server.every((row) => own(row, field)))) {
+            for (const row of data.filter(placed)) {
+                // Before the first row (server or placed) it sorts before; -1 >>> 0 is past the end, so it appends.
+                const at = server.findIndex((other) => sorts.reduce((result, [field, sign]) => result || sign * compare(row[field], other[field]), 0) < 0);
+                server.splice(at >>> 0, 0, row);
+            }
+            data = server;
+        }
+        return {
+            ...response,
+            data: data.map((row) => pick(row, query)),
+            meta: { ...response.meta, page: { ...page, total } },
+        };
+    };
+    const get = async (id, query, init) => {
+        const copy = local.get(String(id));
+        if (deleted.has(String(id))) {
+            const detail = `No such ${name} record.`;
+            throw new DmpError(404, new Headers(), { status: 404, code: 'not_found', detail });
+        }
+        return copy === undefined ? client.get(id, query, init) : answer(200, pick(copy, query));
+    };
+    // The row as it is here; a real one's server copy is kept the first time it changes.
+    const current = async (id) => {
+        const { data } = await get(id);
+        if (!local.has(String(id))) {
+            origins.set(String(id), data);
+        }
+        return data;
+    };
+    const operation = async () => ({ ...answer(202, null), accepted: true });
+    const pages = async function* (query, init) {
+        for await (const page of client.pages(query, init)) {
+            yield await overlay(page, query);
+        }
+    };
+    return {
+        ...client,
+        get,
+        pages,
+        operation,
+        collectionOperation: operation,
+        list: async (query, init) => overlay(await client.list(query, init), query),
+        async *all(query, init) {
+            for await (const page of pages(query, init)) {
+                yield* page.data;
+            }
+        },
+        async create(body) {
+            const row = { ...body, id: `voorbeeld-${++count}` };
+            local.set(row.id, row);
+            return answer(201, { ...row });
+        },
+        async update(id, body) {
+            const data = await current(id);
+            const row = { ...data, ...body, id: data.id };
+            local.set(String(id), row);
+            return answer(200, { ...row });
+        },
+        // As the server: an id that is not there is a 404, and a delete never lowers a count for nothing.
+        async delete(id) {
+            await current(id);
+            local.delete(String(id));
+            deleted.add(String(id));
+            return answer(204, null);
+        },
+    };
+}

package/fonts/OFL-albert-sans.txt

@@ -0,0 +1,93 @@
+Copyright 2021 The Albert Sans Project Authors (https://github.com/usted/Albert-Sans) AlbertSans-Italic[wght].ttf: Copyright 2021 The Albert Sans Project Authors (https://github.com/usted/Albert-Sans)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/fonts/OFL-ibm-plex-sans.txt

@@ -0,0 +1,93 @@
+Copyright 2019 IBM Corp. All rights reserved. IBMPlexSans-Italic[wdth,wght].ttf: Copyright 2019 IBM Corp. All rights reserved.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/fonts/OFL-inter.txt

@@ -0,0 +1,93 @@
+Copyright 2016 The Inter Project Authors (https://github.com/rsms/inter) Inter-Italic[opsz,wght].ttf: Copyright 2016 The Inter Project Authors (https://github.com/rsms/inter)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.