@pascal-app/editor 1.0.3 → 1.0.4

package/src/lib/floorplan/open-wall-ends.test.ts

@@ -0,0 +1,268 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  findOpenWallEnds,
+  LevelNode,
+  type OpenWallEnd,
+  planJoinOpenWallEnd,
+  type SceneCommit,
+  subscribeSceneCommits,
+  useScene,
+  WallNode,
+} from '@pascal-app/core'
+import {
+  collapseMutualOpenWallEnds,
+  formatOpenWallEndDistance,
+  joinOpenWallEnd,
+  openWallEndLabel,
+  openWallEndsSummary,
+  visibleOpenWallEnds,
+} from './open-wall-ends'
+
+const end = (overrides: Partial<OpenWallEnd>): OpenWallEnd => ({
+  wallId: 'wall_a',
+  end: 'end',
+  point: [0, 0],
+  reason: 'gap',
+  ...overrides,
+})
+
+describe('open wall end labels', () => {
+  test('name the problem with the distance a person would say', () => {
+    expect(openWallEndLabel(end({ reason: 'gap', gap: 0.04 }), 'metric')).toBe('4 cm gap')
+    expect(openWallEndLabel(end({ reason: 'gap', gap: 0.004 }), 'metric')).toBe('4 mm gap')
+    expect(
+      openWallEndLabel(
+        end({
+          reason: 'crosses',
+          point: [0, 0],
+          candidate: { wallId: 'wall_b', point: [0.12, 0], kind: 'body' },
+        }),
+        'metric',
+      ),
+    ).toBe('Overlaps by 12 cm')
+    expect(openWallEndLabel(end({ reason: 'parallel', gap: 0.05 }), 'metric')).toBe(
+      'Parallel, 5 cm apart',
+    )
+    expect(openWallEndLabel(end({ reason: 'rejected' }), 'metric')).toBe('Not joined')
+    expect(openWallEndLabel(end({ reason: 'isolated' }), 'metric')).toBeNull()
+  })
+
+  test('falls back to the distance to the candidate when the gap is not given', () => {
+    const label = openWallEndLabel(
+      end({ reason: 'gap', candidate: { wallId: 'wall_b', point: [0, 0.03], kind: 'endpoint' } }),
+      'metric',
+    )
+    expect(label).toBe('3 cm gap')
+  })
+
+  test('imperial distances read in inches below a foot', () => {
+    expect(formatOpenWallEndDistance(0.0381, 'imperial')).toBe('1.5"')
+    expect(formatOpenWallEndDistance(0.2, 'imperial')).toBe('7.9"')
+    expect(formatOpenWallEndDistance(1.2, 'metric')).toBe('1.2m')
+  })
+})
+
+describe('which open ends the floor plan marks', () => {
+  const nearMissRoomless = end({
+    wallId: 'roomless',
+    candidate: { wallId: 'x', point: [0.04, 0], kind: 'endpoint' },
+  })
+  const nearMissInRoom = end({
+    wallId: 'in_room',
+    candidate: { wallId: 'x', point: [0.04, 0], kind: 'endpoint' },
+  })
+  const isolatedRoomless = end({ wallId: 'roomless', end: 'start', reason: 'isolated' })
+  const ends = [nearMissRoomless, nearMissInRoom, isolatedRoomless]
+  const roomWallIds = new Set(['in_room'])
+
+  test('outside drawing, only near misses on walls that bound no room', () => {
+    expect(visibleOpenWallEnds(ends, roomWallIds, false)).toEqual([nearMissRoomless])
+  })
+
+  test('while drawing, every near miss and the loose ends of room-less walls', () => {
+    expect(visibleOpenWallEnds(ends, roomWallIds, true)).toEqual(ends)
+  })
+
+  test('a summary only when something is left to join', () => {
+    expect(openWallEndsSummary(0)).toBeNull()
+    expect(openWallEndsSummary(2)).toBe("2 wall ends aren't joined — rooms can't close")
+  })
+})
+
+test("two ends that are each other's candidate show once, on the wall that slides straight", () => {
+  // Horizontal wall_a ends at (0, 1); vertical wall_b starts 9 cm above it.
+  const a = end({
+    wallId: 'wall_a',
+    end: 'end',
+    point: [0, 1],
+    candidate: { wallId: 'wall_b', point: [0, 1.09], kind: 'endpoint' },
+  })
+  const b = end({
+    wallId: 'wall_b',
+    end: 'start',
+    point: [0, 1.09],
+    candidate: { wallId: 'wall_a', point: [0, 1], kind: 'endpoint' },
+  })
+  const lone = end({
+    wallId: 'wall_c',
+    candidate: { wallId: 'wall_a', point: [2, 1], kind: 'body' },
+  })
+  const directions: Record<string, [number, number]> = {
+    wall_a: [4.5, 0],
+    wall_b: [0, 4.41],
+    wall_c: [1, 0],
+  }
+  expect(collapseMutualOpenWallEnds([a, b, lone], (id) => directions[id] ?? null)).toEqual([
+    b,
+    lone,
+  ])
+})
+
+test('Join emits one scene commit and one undo step, restoring both wall endpoints on undo', () => {
+  const before = useScene.getState()
+  const history = useScene.temporal.getState()
+  const source = WallNode.parse({
+    id: 'wall_join_source',
+    parentId: 'level_join',
+    start: [0, 0],
+    end: [2, 0],
+  })
+  const target = WallNode.parse({
+    id: 'wall_join_target',
+    parentId: 'level_join',
+    start: [2.09, 0],
+    end: [2.09, 2],
+  })
+  const level = LevelNode.parse({ id: 'level_join', children: [source.id, target.id] })
+  useScene.setState({
+    nodes: { [level.id]: level, [source.id]: source, [target.id]: target },
+    readOnly: false,
+  })
+  useScene.temporal.getState().resume()
+  useScene.temporal.getState().clear()
+  const commits: SceneCommit[] = []
+  const unsubscribe = subscribeSceneCommits((commit) => commits.push(commit))
+  try {
+    const diagnostic = {
+      wallId: source.id,
+      end: 'end',
+      point: source.end,
+      reason: 'gap',
+      candidate: { wallId: target.id, point: target.start, kind: 'endpoint' },
+    } satisfies OpenWallEnd
+    expect(joinOpenWallEnd(diagnostic)).toBeNull()
+    expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+    expect(commits).toHaveLength(1)
+    expect(commits[0]?.origin).toBe('local')
+    expect(commits[0]?.current.nodes[source.id]).toMatchObject({ end: target.start })
+    expect(useScene.getState().nodes[source.id]).toMatchObject({ end: target.start })
+    useScene.temporal.getState().undo()
+    expect(useScene.getState().nodes[source.id]).toMatchObject({
+      start: source.start,
+      end: source.end,
+    })
+    expect(useScene.getState().nodes[target.id]).toEqual(target)
+    commits.length = 0
+    expect(joinOpenWallEnd({ ...diagnostic, point: [1, 0] })).toBe('This wall end has changed')
+    expect(joinOpenWallEnd({ ...diagnostic, candidate: undefined })).toBe(
+      'The other wall has moved or is no longer available',
+    )
+    expect(commits).toHaveLength(0)
+    useScene.setState({ readOnly: true })
+    expect(joinOpenWallEnd(diagnostic)).toBe('This scene is read-only')
+    expect(useScene.getState().nodes[source.id]).toMatchObject({ end: source.end })
+    expect(commits).toHaveLength(0)
+  } finally {
+    unsubscribe()
+    useScene.setState(before)
+    useScene.temporal.setState(history)
+  }
+})
+
+test('a gap core plans as a squared corner shows once, on the end that moves', () => {
+  // Both ends name the corner (0, 1): wall_a stays put, wall_b slides 9 cm down onto it.
+  const a = end({
+    wallId: 'wall_a',
+    end: 'end',
+    point: [0, 1],
+    candidate: { wallId: 'wall_b', point: [0, 1], kind: 'endpoint' },
+  })
+  const b = end({
+    wallId: 'wall_b',
+    end: 'start',
+    point: [0, 1.09],
+    candidate: { wallId: 'wall_a', point: [0, 1], kind: 'endpoint' },
+  })
+  const directions: Record<string, [number, number]> = { wall_a: [4.5, 0], wall_b: [0, 4.41] }
+  expect(collapseMutualOpenWallEnds([a, b], (id) => directions[id] ?? null)).toEqual([b])
+})
+
+test.each([
+  {
+    name: 'target endpoint',
+    a: [
+      [0, 0],
+      [2, 0],
+    ],
+    b: [
+      [2.09, 0],
+      [4, 0],
+    ],
+    marker: 'wall_a',
+  },
+  {
+    name: 'squared corner',
+    a: [
+      [-4.5, 1],
+      [0, 1],
+    ],
+    b: [
+      [0, 1.09],
+      [0, 5.5],
+    ],
+    marker: 'wall_b',
+  },
+])('a real $name gap can be joined from either end and shows one marker', ({ a, b, marker }) => {
+  const walls = [
+    WallNode.parse({
+      id: 'wall_a',
+      parentId: 'level_pair',
+      start: a[0],
+      end: a[1],
+      thickness: 0.1,
+    }),
+    WallNode.parse({
+      id: 'wall_b',
+      parentId: 'level_pair',
+      start: b[0],
+      end: b[1],
+      thickness: 0.1,
+    }),
+  ]
+  const nodes = Object.fromEntries(walls.map((wall) => [wall.id, wall]))
+  const ends = findOpenWallEnds(nodes, 'level_pair').filter((end) => end.candidate)
+  expect(ends).toHaveLength(2)
+  for (const diagnostic of ends) {
+    const result = planJoinOpenWallEnd(nodes, diagnostic)
+    expect(result.ok).toBe(true)
+    if (!result.ok) continue
+    const resolved =
+      diagnostic.end === 'start' ? result.plan.resolvedStart : result.plan.resolvedEnd
+    expect(resolved).toEqual(diagnostic.candidate!.point)
+    const joined = { ...nodes }
+    for (const { id, data } of result.plan.changes.update) {
+      if (joined[id]) joined[id] = { ...joined[id]!, ...data } as (typeof walls)[number]
+    }
+    for (const id of result.plan.changes.delete) delete joined[id]
+    for (const { node: wall } of result.plan.changes.create) {
+      if (wall.type === 'wall') joined[wall.id] = wall
+    }
+    expect(findOpenWallEnds(joined, 'level_pair').filter((end) => end.candidate)).toEqual([])
+  }
+  const collapsed = collapseMutualOpenWallEnds(ends, (id) => {
+    const wall = nodes[id]
+    return wall ? [wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]] : null
+  })
+  expect(collapsed).toHaveLength(1)
+  expect(collapsed[0]?.wallId).toBe(marker)
+})

package/src/lib/floorplan/open-wall-ends.ts

@@ -0,0 +1,162 @@
+import {
+  type OpenWallEnd,
+  planJoinOpenWallEnd,
+  runAsSingleSceneHistoryStep,
+  useScene,
+  type WallJoinResult,
+} from '@pascal-app/core'
+import { formatLinearMeasurement, type LinearUnit } from '../measurements'
+
+const JOIN_REFUSALS: Record<Extract<WallJoinResult, { ok: false }>['reason'], string> = {
+  'covered-existing-wall': 'An existing wall already covers this span',
+  'segment-too-short': 'Joining would make the wall too short',
+  'stale-end': 'This wall end has changed',
+  'no-target': 'The other wall has moved or is no longer available',
+  'attachment-outside-wall': 'A door or window is in the way',
+  'attachment-straddles-junction': 'A door or window is in the way',
+}
+
+export function joinOpenWallEnd(end: OpenWallEnd): string | null {
+  const scene = useScene.getState()
+  if (scene.readOnly) return 'This scene is read-only'
+  const result = planJoinOpenWallEnd(scene.nodes, end)
+  if (!result.ok) return JOIN_REFUSALS[result.reason]
+  runAsSingleSceneHistoryStep(useScene, () =>
+    useScene.getState().applyNodeChanges(result.plan.changes),
+  )
+  return null
+}
+
+/** Stable id of one wall end, for hover / pin state. */
+export function openWallEndKey(end: Pick<OpenWallEnd, 'wallId' | 'end'>): string {
+  return `${end.wallId}:${end.end}`
+}
+
+/** Short distances read in the unit a person would say out loud: "4 cm", "8 mm", `1.5"`. */
+export function formatOpenWallEndDistance(meters: number, unit: LinearUnit): string {
+  const value = Math.abs(meters)
+  if (unit === 'imperial') {
+    const inches = value / 0.0254
+    if (inches >= 12) return formatLinearMeasurement(value, unit)
+    return `${Number.parseFloat(inches.toFixed(inches < 1 ? 2 : 1))}"`
+  }
+  if (value >= 1) return formatLinearMeasurement(value, unit)
+  if (value < 0.01) return `${Math.max(1, Math.round(value * 1000))} mm`
+  return `${Math.round(value * 100)} cm`
+}
+
+function candidateDistance(end: OpenWallEnd): number | null {
+  if (!end.candidate) return null
+  return Math.hypot(end.candidate.point[0] - end.point[0], end.candidate.point[1] - end.point[1])
+}
+
+/** What is wrong at this end, in a few words. Null when there is nothing to name. */
+export function openWallEndLabel(end: OpenWallEnd, unit: LinearUnit): string | null {
+  const gap = end.gap ?? candidateDistance(end)
+  switch (end.reason) {
+    case 'gap':
+      return gap === null ? 'Not joined' : `${formatOpenWallEndDistance(gap, unit)} gap`
+    case 'crosses': {
+      const overlap = candidateDistance(end)
+      return overlap === null
+        ? 'Walls cross'
+        : `Overlaps by ${formatOpenWallEndDistance(overlap, unit)}`
+    }
+    case 'parallel':
+      return gap === null
+        ? 'Runs alongside a wall'
+        : `Parallel, ${formatOpenWallEndDistance(gap, unit)} apart`
+    case 'rejected':
+      return 'Not joined'
+    case 'isolated':
+      return null
+  }
+}
+
+/**
+ * Which open ends the floor plan marks. A near miss (an end with a join
+ * candidate) on a wall that bounds no room is always worth a dot — it is what
+ * keeps a room from closing. While walls or rooms are being drawn, every open
+ * end of a room-less wall shows, and near misses on walls that already bound a
+ * room too, since that is when the person is joining things.
+ */
+export function visibleOpenWallEnds(
+  ends: readonly OpenWallEnd[],
+  roomWallIds: ReadonlySet<string>,
+  drawing: boolean,
+): OpenWallEnd[] {
+  return ends.filter((end) => {
+    const boundsRoom = roomWallIds.has(end.wallId)
+    if (end.candidate) return drawing || !boundsRoom
+    return drawing && !boundsRoom
+  })
+}
+
+// Core looks for join targets within 0.35 m; two ends naming each other sit closer than that.
+const MUTUAL_GAP_REACH = 0.5
+
+/**
+ * How well this end shows its gap when it is the one marked: an end that
+ * slides along its own wall onto the join (1) beats one that stays put while
+ * the other wall comes to it (0.5), which beats one that would tilt its wall.
+ */
+function joinAlignment(
+  end: OpenWallEnd,
+  wallDirection: (wallId: string) => readonly [number, number] | null,
+): number {
+  const direction = wallDirection(end.wallId)
+  if (!(direction && end.candidate)) return 0
+  const dx = end.candidate.point[0] - end.point[0]
+  const dz = end.candidate.point[1] - end.point[1]
+  const move = Math.hypot(dx, dz)
+  const length = Math.hypot(direction[0], direction[1])
+  if (move < 1e-9) return 0.5
+  if (length < 1e-9) return 0
+  return Math.abs(dx * direction[0] + dz * direction[1]) / (move * length)
+}
+
+/**
+ * Two ends of different walls that name each other as the join target, a
+ * join's reach apart, are one gap — whether core plans the join as one end
+ * onto the other or both onto a squared corner. Keep the end that shows the
+ * gap best (`joinAlignment`), so the floor plan and the 3D view mark it once.
+ */
+export function collapseMutualOpenWallEnds(
+  ends: readonly OpenWallEnd[],
+  wallDirection: (wallId: string) => readonly [number, number] | null,
+): OpenWallEnd[] {
+  const dropped = new Set<OpenWallEnd>()
+  const byWall = new Map<string, OpenWallEnd[]>()
+  for (const end of ends) {
+    const group = byWall.get(end.wallId)
+    if (group) group.push(end)
+    else byWall.set(end.wallId, [end])
+  }
+  for (const end of ends) {
+    if (dropped.has(end) || !end.candidate) continue
+    const candidate = end.candidate
+    const partner = byWall
+      .get(candidate.wallId)
+      ?.find(
+        (other) =>
+          other !== end &&
+          !dropped.has(other) &&
+          other.candidate?.wallId === end.wallId &&
+          Math.hypot(other.point[0] - end.point[0], other.point[1] - end.point[1]) <=
+            MUTUAL_GAP_REACH,
+      )
+    if (!partner) continue
+    dropped.add(
+      joinAlignment(partner, wallDirection) > joinAlignment(end, wallDirection) ? end : partner,
+    )
+  }
+  return ends.filter((end) => !dropped.has(end))
+}
+
+/** "2 wall ends aren't joined — rooms can't close", or null when every end is joined. */
+export function openWallEndsSummary(joinableCount: number): string | null {
+  if (joinableCount === 0) return null
+  return joinableCount === 1
+    ? "1 wall end isn't joined — a room can't close"
+    : `${joinableCount} wall ends aren't joined — rooms can't close`
+}

package/src/lib/floorplan/pdf-fonts/LICENSE-GeistMono.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2023 Vercel, in collaboration with basement.studio
+
+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 AND 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/src/lib/floorplan/pdf-fonts/LICENSE-LiberationSans.txt

@@ -0,0 +1,102 @@
+Digitized data copyright (c) 2010 Google Corporation
+	with Reserved Font Arimo, Tinos and Cousine.
+Copyright (c) 2012 Red Hat, Inc.
+	with Reserved Font Name Liberation.
+
+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.
+